#Maria JSON Parser

#Features

• ✅ Full JSON Support: Parse and serialize all JSON types (objects, arrays, strings, numbers, booleans, null)
• ✅ Pretty Printing: Format JSON with customizable indentation
• ✅ Error Handling: Detailed error reporting with position information
• ✅ Unicode Support: Handle unicode escape sequences (\uXXXX)
• ✅ Zero Dependencies: Built entirely with MoonBit standard library
• ✅ Type Safe: Strongly typed JSON value representation

#Installation

{
  "import": [
    "tonyfettes/maria_json_parser"
  ]
}

#Quick Start

#Parsing JSON

///|
test "parse basic json" {
  let json_text = "{\"name\": \"Alice\", \"age\": 30}"
  let value = @maria_json_parser.parse(json_text)
  match value {
    @maria_json_parser.JsonValue::Object(obj) => {
      inspect(obj.get("name"), content="Some(String(\"Alice\"))")
      inspect(obj.get("age"), content="Some(Number(30))")
    }
    _ => fail("Expected object")
  }
}

#Serializing JSON

///|
test "serialize to json" {
  let data : Map[String, @maria_json_parser.JsonValue] = {
    "name": @maria_json_parser.JsonValue::String("Bob"),
    "score": @maria_json_parser.JsonValue::Number(95.5),
    "passed": @maria_json_parser.JsonValue::Boolean(true),
  }
  let json = @maria_json_parser.stringify(
    @maria_json_parser.JsonValue::Object(data),
  )
  assert_true(json.contains("\"name\":\"Bob\""))
  assert_true(json.contains("\"score\":95.5"))
}

#Pretty Printing

///|
test "pretty print json" {
  let data : Map[String, @maria_json_parser.JsonValue] = {
    "users": @maria_json_parser.JsonValue::Array([
      @maria_json_parser.JsonValue::String("Alice"),
      @maria_json_parser.JsonValue::String("Bob"),
    ]),
  }
  let pretty = @maria_json_parser.stringify(
    @maria_json_parser.JsonValue::Object(data),
    indent=2,
  )
  assert_true(pretty.contains("\n"))
  assert_true(pretty.contains("  "))
}

#API Reference

#Types

#JsonValue

///|
pub(all) enum JsonValue {
  Object(Map[String, JsonValue])
  Array(Array[JsonValue])
  String(String)
  Number(Double)
  Boolean(Bool)
  Null
}

#ParseError

///|
pub(all) suberror ParseError {
  UnexpectedToken(Position, Token, String)
  UnexpectedChar(Position, Char)
  UnexpectedEof(Position)
  InvalidNumber(Position, String)
  InvalidEscape(Position, Char)
  InvalidUnicode(Position, String)
}

#Functions

#parse

///|
test "parse example" {
  let value = @maria_json_parser.parse("[1, 2, 3]")
  match value {
    @maria_json_parser.JsonValue::Array(arr) =>
      inspect(arr.length(), content="3")
    _ => fail("Expected array")
  }
}

#stringify

///|
test "stringify example" {
  let arr = @maria_json_parser.JsonValue::Array([
    @maria_json_parser.JsonValue::Number(1.0),
    @maria_json_parser.JsonValue::Number(2.0),
  ])
  let json = @maria_json_parser.stringify(arr)
  inspect(json, content="[1,2]")
}

#to_pretty_string

///|
test "pretty string example" {
  let obj : Map[String, @maria_json_parser.JsonValue] = {
    "key": @maria_json_parser.JsonValue::String("value"),
  }
  let pretty = @maria_json_parser.JsonValue::Object(obj).to_pretty_string()
  assert_true(pretty.contains("\n"))
}

#Error Handling

///|
test "handle parse errors" {
  let result : Result[
    @maria_json_parser.JsonValue,
    @maria_json_parser.ParseError,
  ] = try! @maria_json_parser.parse("invalid")
  match result {
    Err(_error) =>
      // Handle error - position and details available in error
      inspect(true, content="true")
    Ok(_) => fail("Expected error")
  }
}

#Advanced Examples

#Complex Nested Structures

///|
test "complex structure" {
  let json =
    #|{
    #|  "user": {
    #|    "name": "Alice",
    #|    "settings": {
    #|      "theme": "dark",
    #|      "notifications": true
    #|    }
    #|  }
    #|}
  let value = @maria_json_parser.parse(json)
  match value {
    @maria_json_parser.JsonValue::Object(root) =>
      match root.get("user") {
        Some(@maria_json_parser.JsonValue::Object(user)) =>
          match user.get("settings") {
            Some(@maria_json_parser.JsonValue::Object(settings)) => {
              inspect(settings.get("theme"), content="Some(String(\"dark\"))")
              inspect(
                settings.get("notifications"),
                content="Some(Boolean(true))",
              )
            }
            _ => fail("Expected settings object")
          }
        _ => fail("Expected user object")
      }
    _ => fail("Expected root object")
  }
}

#Round-Trip Conversion

///|
test "round trip" {
  let original = @maria_json_parser.JsonValue::Array([
    @maria_json_parser.JsonValue::String("hello"),
    @maria_json_parser.JsonValue::Number(42.0),
    @maria_json_parser.JsonValue::Boolean(true),
    @maria_json_parser.JsonValue::Null,
  ])
  let json = @maria_json_parser.stringify(original)
  let parsed = @maria_json_parser.parse(json)
  inspect(parsed == original, content="true")
}

#Supported JSON Features

• ✅ Objects with string keys
• ✅ Arrays
• ✅ Strings with escape sequences (\", \\, \/, \b, \f, \n, \r, \t)
• ✅ Unicode escape sequences (\uXXXX)
• ✅ Numbers (integers, decimals, scientific notation)
• ✅ Booleans (true, false)
• ✅ Null
• ✅ Whitespace handling
• ✅ Pretty printing with configurable indentation

#License