#MoonJsonnet

#Status and installation

moon add pangbit/moonjsonnet@0.1.0

# moon.pkg
import { "pangbit/moonjsonnet" }
supported_targets = "native"
pkgtype(kind: "executable")

///|
fn main raise {
  let value = @moonjsonnet.evaluate("{ answer: 6 * 7 }")
  println(value.stringify())
}

///|
test "readme embedded evaluation" {
  let value = @moonjsonnet.evaluate(
    "local template(n=1) = { replicas: n, port: 8080 }; template(3)",
  )
  assert_eq(value, { "replicas": 3, "port": 8080 })
  assert_eq(
    @moonjsonnet.evaluate("std.thisFile", filename="<cmdline>", anonymous=true),
    Json::string(""),
  )
  assert_eq(
    @moonjsonnet.evaluate_text("'hello'", string_output=true),
    "hello\n",
  )
  assert_eq(@moonjsonnet.evaluate_stream("[42,'hello']"), [
    "42\n", "\"hello\"\n",
  ])
  assert_eq(@moonjsonnet.evaluate_multi("{a:42}")["a"], "42\n")
}

///|
test "readme code and top-level arguments" {
  let result = @moonjsonnet.evaluate(
    "function(replicas, port=8080) {replicas:replicas,port:port}",
    ext_code=Map([("base", "1+2")]),
    tla_code=Map([("replicas", "std.extVar('base')")]),
  )
  assert_eq(result, { "replicas": 3, "port": 8080 })
}

///|
test "readme native callback and trace" {
  let identity : @moonjsonnet.NativeFunction = {
    params: ["value"],
    callback: args => args[0],
  }
  let messages : Array[String] = []
  let result = @moonjsonnet.evaluate(
    "std.trace('calling host', std.native('identity')(value=42))",
    native_functions=Map([("identity", identity)]),
    trace=fn(_, message) { messages.push(message) },
  )
  assert_eq(result, 42)
  assert_eq(messages, ["calling host"])
}

#Evaluation inspection

///|
test "readme structured diagnostic trace" {
  let formatter = @moonjsonnet.DiagnosticFormatter::new()
  try @moonjsonnet.evaluate("error 'failed'", filename="entry") catch {
    @moonjsonnet.Error(d) => {
      assert_eq(d.trace.length(), 2)
      assert_eq(
        formatter.format(d),
        "RUNTIME ERROR: failed\n\tentry:1:1-15\t$\n\tDuring evaluation\t\n",
      )
    }
  } noraise {
    _ => fail("runtime diagnostic expected")
  }
}

///|
test "readme evaluation hook" {
  let evaluator = @moonjsonnet.Evaluator::new()
  let values : Array[Json] = []
  evaluator.set_eval_hook(hook={
    before: ctx => {
      if ctx.node().kind is Var("x") {
        values.push(ctx.lookup("x").json())
      }
    },
    after: (_, _) => (),
  })
  assert_eq(
    evaluator.evaluate(@moonjsonnet.Program::parse("local x=21;x*2")),
    42,
  )
  assert_eq(values, [21])
  evaluator.set_eval_hook()
}

#Source formatting

///|
test "readme source formatting" {
  assert_eq(@moonjsonnet.format_source("{\"a\":[1,2]}"), "{ a: [1, 2] }\n")
  let source = "0" + "+1".repeat(299)
  let syntax = @moonjsonnet.SyntaxDocument::parse(source)
  assert_eq(syntax.format(), "0" + " + 1".repeat(299) + "\n")
}

///|
test "readme raw syntax editing" {
  let raw = @moonjsonnet.RawAst::parse("/*head*/ 1 //tail\n")
  let original = raw.clone()
  for i, part in raw.root.parts {
    if part is Text(text) && text.kind is TokenText {
      raw.root.parts[i] = Text({ ..text, text: "42", })
    }
  }
  assert_eq(original.text(), "/*head*/ 1 //tail\n")
  assert_eq(raw.text(), "/*head*/ 42 //tail\n")
  assert_eq(raw.format(), "/*head*/ 42  //tail\n")
}

#Run from source

moon check --target native --deny-warn
moon test --target native --deny-warn
moon run cmd/main -- examples/environments/main.jsonnet
moon run cmd/main -- examples/dashboards/main.jsonnet
moon run examples/embedded

moon run cmd/main -- --root examples/embedded/config --ext-code replicas=3 main.jsonnet
moon run cmd/main -- --root examples/environments -o result.json main.jsonnet

#Validation and contribution