#moonjson

let config = @json.loads("{\"host\":\"localhost\",\"port\":8080}")
assert_eq(@json.dumps(config), "{\"host\":\"localhost\",\"port\":8080}")
assert_eq(@json.dumps(config, indent=2), "{\n  \"host\": \"localhost\",\n  \"port\": 8080\n}")

// The same document, written the way a settings file is written.
let source =
  #|{
  #|  "port": 8080,  // the one we bound
  #|}
assert_eq(@jsonc.loads(source[:]), @json.loads("{\"port\":8080}"))

// One place in a document, named (RFC 6901).
assert_eq(@json.dumps(@pointer.get(config, "/port")), "8080")

#The surface

// Read a document, change one field, write it back.
let text =
  #|{
  #|  "spec": { "replicas": 1, "image": "app:1" }
  #|}
let cfg = @jsonc.loads(text[:])
let wanted = @pointer.set(cfg, "/spec/replicas", Json::number(5))
assert_eq(@json.dumps(wanted), "{\"spec\":{\"replicas\":5,\"image\":\"app:1\"}}")

#Packages

#One tree, every notation

let doc = @json5.loads("{host:'localhost',port:8080,tls:false}")
let body = @cbor.dump(doc)                    // the same tree, as bytes
assert_eq(@cbor.load(body[:]), doc)           // and back, the same tree

#Configuration

let same = @jsonc.loads(text[:])          // strict JSON, plus comments
assert_eq(same, @json.loads(text[:]))     //   and the same tree comes out
let shallow = @json.loads(text[:], flavor=@moonjson.Flavor::new(depth=100))
assert_eq(shallow, same)
let first = @json.loads(
  text[:],
  flavor={ ..@moonjson.strict, duplicates: @moonjson.Duplicates::First },
)
assert_eq(first, same)

let city = @json.loads("{\"city\":\"\u{5965}\u{514b}\u{5170}\"}")
assert_eq(@json.dumps(city, ascii=true), "{\"city\":\"\\u5965\\u514b\\u5170\"}")

let pair = @json.loads("{\"port\":8080,\"host\":\"localhost\"}")
assert_eq(@json.dumps(pair, sort=true), "{\"host\":\"localhost\",\"port\":8080}")

#The defaults

#The tree

let wide = "[1e400,12345678901234567890,0.1]"
assert_eq(@json.dumps(@json.loads(wide)), wide)

#Changing a document

// One field, and nothing else changes.
let patched = @pointer.set(cfg, "/spec/replicas", Json::number(5))

// Two operations, applied in order — or, if one fails, not at all.
let ops = @patch.loads(
  "[{\"op\":\"test\",\"path\":\"/spec/replicas\",\"value\":5},{\"op\":\"replace\",\"path\":\"/spec/image\",\"value\":\"app:2\"}]",
)
assert_eq(@json.dumps(@patch.apply(patched, ops)), "{\"spec\":{\"replicas\":5,\"image\":\"app:2\"}}")

// A patch that looks like the document: a member that is not there is added,
// one that is there is replaced, and a null takes one away.
assert_eq(@json.dumps(@merge.merge(patched, @json.loads("{\"spec\":{\"image\":null}}"))), "{\"spec\":{\"replicas\":5}}")

#Querying a document

let shelf = @json.loads("{\"store\":{\"book\":[{\"title\":\"A\",\"price\":8.95},{\"title\":\"B\",\"price\":12.99},{\"title\":\"C\",\"price\":8.99}]}}")
let cheap = @path.select(shelf, "$..book[?@.price < 10].title")
assert_eq(@json.dumps(Json::array(cheap)), "[\"A\",\"C\"]")

let query = @path.compile("$.store.book[*].title")   // once
assert_eq(@json.dumps(Json::array(query.select(shelf))), "[\"A\",\"B\",\"C\"]")

#Failures

let broken =
  #|{
  #|  "a": 1,
  #|  "b": ?
  #|}
try @json.loads(broken[:]) |> ignore catch {
  e => match e.at() {
    Some(spot) => assert_eq("line \{spot.line}, column \{spot.column}", "line 3, column 8")
    None => abort("a scanner refusal carries a place")
  }
}

try @json.loads(broken[:]) |> ignore catch {
  e => assert_eq(e.message(), "line 3, column 8: unexpected '?'")
}

#Install

moon add moonbitstack/moonjson

#Licence