Writing TOML

// `TomlWriteDocument` turns a `TomlValue` table back into TOML text, written into any
// `TextWriter`:
//
//     TomlWriteDocument(writer, table) -> ! FormatError
//
// The parser keeps values, not spelling, so writing a parsed document back gives an equivalent
// document rather than the same file. Comments and blank lines are gone, `0xFF` becomes `255`,
// a literal string becomes an ordinary one and an inline table becomes a `[header]` section,
// written after the plain keys because TOML requires it. What does survive is every key, every
// value, and their order within each table. And the writer is deterministic: the same tree
// always writes the same bytes, so write, read and write again, and the second text is the
// first one exactly.
import Allocator::{ Allocator, SystemAllocator };
import Io::PrintLine;
import Text::{ FormatError, String, StringBuilder, StringView, TextError, TextWriter };
import Toml::{ TomlParse, TomlParseFailure, TomlValue, TomlWriteDocument };

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();
}

// Writes `table` as TOML and hands the text back as a String the caller owns.
func Written(allocator: Allocator, table: &TomlValue) -> String ! FormatError {
    var builder = StringBuilder(allocator);
    let sink: &var TextWriter = builder;
    TomlWriteDocument(sink, table)?;
    return builder.IntoString();
}

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

    // A document as a person might write it.
    let lines: char8[..][6] = [
        "# Settings for the demo server",
        "name = 'Rux'      # a literal string",
        "mask = 0xFF",
        "server = { host = \"localhost\", port = 8080 }",
        "",
        "tags = [\"web\", \"api\"]"
    ];
    let text = Lines(allocator, lines)?;
    PrintLine("read:\n{}", text);
    var root = TomlParse(allocator, text.View().Bytes())?;

    // Change the tree before writing it. `FindMutable` lends a table for changing, and
    // `Insert` takes ownership of a new key and value.
    let server = root.FindMutable(StringView::FromValidated("server"));
    (*server).Insert(String::FromBytes(allocator, "debug")?, TomlValue::Boolean(allocator, true));

    let once = Written(allocator, root)?;
    PrintLine("written:\n{}", once);

    // Read the output back and write it again: nothing moves the second time.
    let again = TomlParse(allocator, once.View().Bytes())?;
    let twice = Written(allocator, again)?;
    let first = once.View();
    PrintLine("written twice, same text: {}", twice.View().Equals(first));
}