TOML

// TOML is a configuration format — the one every `Rux.toml` in this course is written in. A
// document is a table of keys and values, `[name]` opens a nested table, and unlike JSON the
// values have real types: an integer is not a float even when the float is whole, and a date is
// a date rather than a string that looks like one.
//
//     TomlParse(allocator, text) -> TomlValue ! TomlParseFailure
//
// The result is a `TomlValue` tree, read the same way as a JSON one: `Find` answers a pointer
// that is null when the key is missing, and `AsInteger`, `AsFloat`, `AsDate` and the rest
// answer `false` when the value is some other kind. A refused document gives no tree at all,
// only the reason and where it was found, by line and column.
import Allocator::{ Allocator, SystemAllocator };
import Io::PrintLine;
import Text::{ String, StringBuilder, StringView, TextError };
import Time::Date;
import Toml::{ TomlParse, TomlValue };

// A TOML document is lines, so it is written here one literal per line and joined.
func Lines(allocator: Allocator, lines: char8[..][..]) -> String ! TextError {
    var builder = StringBuilder(allocator);
    for i in 0..lines.length {
        builder.Append(lines[i])?;
        builder.Append("\n")?;
    }
    return builder.IntoString();
}

func Key(table: &TomlValue, key: char8[..]) -> *TomlValue {
    return table.Find(StringView::FromValidated(key));
}

func Inspect(root: &TomlValue) {
    PrintLine("name      {}", (*Key(root, "name")).AsText());

    // The same question asked of an integer and a float. Each answers only its own kind.
    let server = Key(root, "server");
    var port: int64 = 0;
    var ratio = 0.0;
    let portIsInteger = (*Key(*server, "port")).AsInteger(@port);
    let portIsFloat = (*Key(*server, "port")).AsFloat(@ratio);
    PrintLine("port      {} (integer: {}, float: {})", port, portIsInteger, portIsFloat);
    (*Key(*server, "ratio")).AsFloat(@ratio);
    PrintLine("ratio     {}", ratio);

    var released = Date { year: 1970, month: 1, day: 1 };
    (*Key(root, "released")).AsDate(@released);
    PrintLine("released  {}", released);

    let tags = Key(*server, "tags");
    for i in 0..(*tags).Length() {
        PrintLine("tags[{}]   {}", i, (*(*tags).At(i)).AsText());
    }
    PrintLine("debug     present: {}", Key(*server, "debug") != null);
}

func Load(allocator: Allocator, text: char8[..]) {
    match TomlParse(allocator, text) {
        .Success(root) => Inspect(root),
        .Failure(failure) =>
            PrintLine("refused at line {}, column {}: {}", failure.line, failure.column, failure)
    }
}

func Main() -> ! TextError {
    var system = SystemAllocator();
    let allocator: Allocator = system;

    let good: char8[..][8] = [
        "name = \"Rux\"",
        "released = 2026-10-04",
        "",
        "[server]",
        "port = 8080",
        "ratio = 0.75",
        "tags = [\"web\", \"api\"]",
        "# A comment, which the parser skips."
    ];
    let document = Lines(allocator, good)?;
    Load(allocator, document.View().Bytes());

    // Two refusals. A key given twice in one table is an error in TOML, not a quiet overwrite,
    // and a value must be spelled the way its type is: there is no thirteenth month.
    PrintLine("");
    let twice: char8[..][3] = ["[server]", "port = 8080", "port = 9090"];
    let repeated = Lines(allocator, twice)?;
    Load(allocator, repeated.View().Bytes());
    Load(allocator, "released = 2026-13-04");
}