#moonyaml

test {
  // A `#|` literal carries no last break, so the text it stands for ends in one.
  let src =
    #|server:
    #|  host: 0.0.0.0
    #|  port: 12000
    #|limits:
    #|  files: 1000
    #|  bytes: 1048576
  let text = src + "\n"
  let config = @moonyaml.loads(text)
  assert_eq(
    config.stringify(),
    "{\"server\":{\"host\":\"0.0.0.0\",\"port\":12000},\"limits\":{\"files\":1000,\"bytes\":1048576}}",
  )
  assert_eq(@moonyaml.dumps(config), text)
}

test {
  let src =
    #|# the deployment
    #|name: web
    #|ports: [80, 443]
  let text = src + "\n"
  let doc = @moonyaml.parse(text)
  // The document, written back with the comment and the flow sequence it had.
  assert_eq(@moonyaml.emit(doc), text)
  // The value it means.
  assert_eq(doc.to_json().stringify(), "{\"name\":\"web\",\"ports\":[80,443]}")
}

#Install

moon add moonbitstack/moonyaml

#The packages

#The interface

#What it reads

test {
  let src = "enabled: yes\nmask: 014\nstarts: 12:30\n"
  assert_eq(
    @moonyaml.loads(src).stringify(),
    "{\"enabled\":\"yes\",\"mask\":14,\"starts\":\"12:30\"}",
  )
  assert_eq(
    @yaml11.loads(src).stringify(),
    "{\"enabled\":true,\"mask\":12,\"starts\":750}",
  )
  assert_eq(
    @strict.loads(src).stringify(),
    "{\"enabled\":\"yes\",\"mask\":\"014\",\"starts\":\"12:30\"}",
  )
}

#The document

test {
  let src =
    #|# the deployment
    #|name: web
    #|ports: [80, 443]
    #|motd: |
    #|  one
    #|  two
  let text = src + "\n"
  let doc = @moonyaml.parse(text)
  match doc.kind {
    Mapping(pairs) => assert_eq(pairs[2].0.text, "motd")
    _ => fail("a mapping")
  }
  assert_eq(@moonyaml.emit(doc), text)
}

test {
  let src = "limits: &shared {files: 1000}\nupload: *shared\n"
  // A value has no anchors in it: the alias is expanded, and both sides are the
  // same mapping.
  assert_eq(
    @moonyaml.loads(src).stringify(),
    "{\"limits\":{\"files\":1000},\"upload\":{\"files\":1000}}",
  )
  // A document keeps them, and writes them back as they were written.
  assert_eq(@moonyaml.emit(@moonyaml.parse(src)), src)
  // Written from the value, the anchors a writer invents are its own.
  assert_eq(
    @moonyaml.dumps(@moonyaml.loads(src)),
    "limits: &a0\n  files: 1000\nupload: *a0\n",
  )
}

test {
  let doc = @moonyaml.parse("name: web\n")
  assert_eq(
    doc.events(),
    "+DOC\n +MAP\n  =VAL :name\n  =VAL :web\n -MAP\n-DOC\n",
  )
}

+DOC
 +MAP
  =VAL :name
  =VAL :web
 -MAP
-DOC

#Configuration

test {
  let nested = "a:\n  b:\n    c: 1\n"
  assert_eq(@moonyaml.emit(@moonyaml.parse(nested)), nested)
  assert_eq(
    @moonyaml.emit(@moonyaml.parse(nested), indent=4),
    "a:\n    b:\n        c: 1\n",
  )
  assert_eq(
    @moonyaml.dumps(@moonyaml.loads("b: 1\na: 2\n"), sort=true),
    "a: 2\nb: 1\n",
  )
  assert_eq(
    @moonyaml.dumps(@moonyaml.loads("a: {b: [1, 2]}\n"), style=@moonyaml.flow),
    "{a: {b: [1, 2]}}\n",
  )
}

test {
  let docs = @moonyaml.loads_all("a: 1\n---\nb: 2\n")
  assert_eq(@moonyaml.dumps_all(docs[:]), "---\na: 1\n---\nb: 2\n")
  // Concatenating two streams still reads as four documents, not as a fault.
  let text = @moonyaml.dumps_all(docs[:])
  assert_eq(@moonyaml.loads_all(text + text).length(), 4)
}

#What it refuses

test {
  let refused = fn(src : String) -> String {
    try {
      @moonyaml.loads(src) |> ignore
      "read"
    } catch {
      e => e.to_string()
    }
  }
  assert_eq(refused("a: [1, 2\n"), "1:4: ends mid-document")
  assert_eq(refused("a: *nope\n"), "1:4: no anchor named `nope`")
}

test {
  let said = try {
    @moonyaml.loads("a: 1\na: 2\n", flavor=@moonyaml.Flavor::new(duplicates=Reject)) |> ignore
    "read"
  } catch {
    e => e.to_string()
  }
  assert_eq(said, "2:1: the key `a` is written twice")
}

#Examples

moon run src/examples/tour        # everything it reads, in one file
moon run src/examples/versions    # one document, read five ways
moon run src/examples/document    # the document model, and a round trip

#Licence