JSON

// JSON is how programs that share nothing else agree on what a value is. The Json package reads
// a document into a tree of `JsonValue`s, and every value in the tree is one of six kinds: text,
// number, boolean, null, array or object.
//
//     Parse(allocator, text) -> JsonValue ! JsonParseError
//
// Parsing hands back a whole document or the reason there is none, never half of one. Reading the
// tree then means asking a value what it is before taking it apart: `Find` and `At` answer a
// pointer that is null when the member or element is not there, and the conversions answer
// `false`, through an out-parameter, when the value is some other kind.
import Allocator::{ Allocator, SystemAllocator };
import Io::PrintLine;
import Json::{ JsonKind, JsonValue, Parse };
import Text::StringView;

func KindName(kind: JsonKind) -> char8[..] {
    return match kind {
        JsonKind::Text => "text",
        JsonKind::Number => "number",
        JsonKind::Boolean => "boolean",
        JsonKind::Array => "array",
        JsonKind::Object => "object",
        else => "null"
    };
}

// Member names are compared as text, so `Find` takes a `StringView`.
func Member(object: &JsonValue, name: char8[..]) -> *JsonValue {
    return object.Find(StringView::FromValidated(name));
}

func Inspect(root: &JsonValue) {
    PrintLine("root      {} of {} members", KindName(root.Kind()), root.Length());

    // A member that is not there is a null pointer, so check before reading through it.
    let name = Member(root, "name");
    if name != null {
        PrintLine("name      {}", (*name).AsText());
    }
    PrintLine("license   present: {}", Member(root, "license") != null);

    // A number keeps the text it was written with, and converting it is a question that can
    // be answered `false`: the text may have a fraction, or not fit the type asked for.
    var year: int64 = 0;
    let number = (*Member(root, "year")).AsNumber();
    let fits = (*number).AsInt64(@year);
    PrintLine("year      {} (text \"{}\", fits an int64: {})", year, (*number).Text(), fits);

    // An array is walked by index, and each element is asked its kind like any other value.
    let tags = Member(root, "tags");
    for i in 0..(*tags).Length() {
        let tag = (*tags).At(i);
        PrintLine("tags[{}]   {} {}", i, KindName((*tag).Kind()), (*tag).AsText());
    }

    // A nested object is just another value with members of its own.
    var beta = false;
    let flags = Member(root, "flags");
    let isBoolean = (*Member(*flags, "beta")).AsBoolean(@beta);
    PrintLine("beta      boolean: {}, value: {}", isBoolean, beta);
}

func Check(allocator: Allocator, document: char8[..]) {
    match Parse(allocator, document) {
        .Success(root) => PrintLine("{:18} parsed as {}", document, KindName(root.Kind())),
        .Failure(reason) =>
            PrintLine("{:18} refused at byte {}: {}", document, reason.Offset(), reason)
    }
}

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

    let document =
        "{\"name\":\"Rux\",\"year\":2026,\"tags\":[\"fast\",\"small\"],\"flags\":{\"beta\":true}}";
    match Parse(allocator, document) {
        .Success(root) => Inspect(root),
        .Failure(reason) => PrintLine("refused at byte {}: {}", reason.Offset(), reason)
    }

    // Malformed input. The failure says why, and the byte where the parser stopped, so a message
    // to a person can point at the problem. JSON is strict: no trailing commas, no single quotes.
    PrintLine("");
    Check(allocator, "[1, 2, 3]");
    Check(allocator, "[1, 2, 3,]");
    Check(allocator, "{'name': 'Rux'}");
    Check(allocator, "{\"open\": [1, 2}");
    Check(allocator, "{\"a\": 1} extra");
    Check(allocator, "");
    return 0;
}