#minijinja.mbt

#Example

///|
test "hello world" {
  let env = @minijinja.Environment::new()
  env.add_template("hello.txt", "Hello {{ name }}!")
  let tmpl = env.get_template("hello.txt")
  let ctx = @minijinja.Value::from_pairs([
    ("name", @minijinja.Value::from_string("John")),
  ])
  inspect(tmpl.render(ctx), content="Hello John!")
}

#Template inheritance, macros and loops

///|
test "inheritance" {
  let env = @minijinja.Environment::new()
  env.add_template(
    "layout.html", "<title>{% block title %}{% endblock %}</title>{% block body %}{% endblock %}",
  )
  env.add_template(
    "index.html",
    (
      #|{% extends "layout.html" %}
      #|{% macro item(x) %}<li>{{ x }}</li>{% endmacro %}
      #|{% block title %}Items{% endblock %}
      #|{% block body %}<ul>{% for x in items %}{{ item(x) }}{% endfor %}</ul>{% endblock %}
    ),
  )
  let ctx = @minijinja.Value::from_pairs([
    (
      "items",
      @minijinja.Value::from_array([
        @minijinja.Value::from_string("<a>"),
        @minijinja.Value::from_int(42),
      ]),
    ),
  ])
  inspect(
    env.get_template("index.html").render(ctx),
    content="<title>Items</title><ul><li>&lt;a&gt;</li><li>42</li></ul>",
  )
}

#Custom filters, tests and functions

///|
test "custom filter" {
  let env = @minijinja.Environment::new()
  env.add_filter("repeat", (state, args) => {
    let a = @minijinja.Args::new(state, args)
    let kwargs = a.kwargs()
    let value = a.string()
    let times = a.opt_usize().unwrap_or(2)
    let sep = kwargs.get_str("sep").unwrap_or("")
    a.finish()
    kwargs.assert_all_used()
    @minijinja.Value::from_string(Array::make(times, value).join(sep))
  })
  inspect(
    env.render_str(
      "{{ 'ab'|repeat }} {{ 'x'|repeat(3, sep='-') }}",
      @minijinja.Value::none(),
    ),
    content="abab x-x-x",
  )
}

///|
test "typed arguments" {
  let env = @minijinja.Environment::new()
  env.add_function("clamp", (state, args) => {
    let a = @minijinja.Args::new(state, args)
    let value : Int = a.next()
    let lo : Int = a.next()
    let hi : Int? = a.next()
    a.finish()
    let hi = hi.unwrap_or(100)
    @minijinja.Value::from_int(
      if value < lo {
        lo
      } else if value > hi {
        hi
      } else {
        value
      },
    )
  })
  inspect(
    env.render_str(
      "{{ clamp(5, 10) }} {{ clamp(500, 1) }}",
      @minijinja.Value::none(),
    ),
    content="10 100",
  )
}

#Loaders, captured state and streaming

///|
test "loader and blocks" {
  let env = @minijinja.Environment::new()
  let sources = {
    "macros.txt": "{% macro hello(name) %}Hello {{ name }}!{% endmacro %}",
    "page.txt": "{% from 'macros.txt' import hello %}{% block title %}{{ hello(who) }}{% endblock %}",
  }
  env.set_loader(name => sources.get(name))
  let tmpl = env.get_template("page.txt")
  let ctx = @minijinja.Value::from_pairs([
    ("who", @minijinja.Value::from_string("World")),
  ])
  let out = StringBuilder()
  let state = tmpl.render_to(ctx, s => out.write_view(s))
  inspect(out.to_string(), content="Hello World!")
  inspect(state.render_block("title"), content="Hello World!")
  inspect(
    state.call_macro("hello", [@minijinja.Value::from_string("Moon")]),
    content="Hello Moon!",
  )
}

#Dynamic objects

///|
struct Point {
  x : Int
  y : Int
}

///|
impl @minijinja.Object for Point with fn get_value(self, key) {
  match key.as_str() {
    Some("x") => Some(@minijinja.Value::from_int(self.x))
    Some("y") => Some(@minijinja.Value::from_int(self.y))
    _ => None
  }
}

///|
impl @minijinja.Object for Point with fn enumerate(_self) {
  Str(["x", "y"])
}

///|
test "objects" {
  let env = @minijinja.Environment::new()
  let ctx = @minijinja.Value::from_pairs([
    ("p", @minijinja.Value::from_object(Point::{ x: 1, y: 2, })),
  ])
  inspect(
    env.render_str("{{ p.x }},{{ p.y }} {{ p|list }}", ctx),
    content="1,2 ['x', 'y']",
  )
}

#Expressions

///|
test "expressions" {
  let env = @minijinja.Environment::new()
  let expr = env.compile_expression("number < 42 and name is defined")
  let ctx = @minijinja.Value::from_pairs([
    ("number", @minijinja.Value::from_int(23)),
    ("name", @minijinja.Value::from_string("x")),
  ])
  inspect(expr.eval(ctx), content="True")
}

#Errors

///|
test "errors" {
  let env = @minijinja.Environment::new()
  env.add_template("bad.txt", "{{ [1, 2] + 23 }}")
  let tmpl = env.get_template("bad.txt")
  try tmpl.render(@minijinja.Value::none()) catch {
    err => {
      inspect(err.kind() == InvalidOperation, content="true")
      inspect(
        err,
        content="invalid operation: tried to use + operator on unsupported types sequence and number (in bad.txt:1)",
      )
    }
  } noraise {
    _ => fail("expected an error")
  }
}

#Differences to MiniJinja

• Values are built with constructors (Value::from_string, from_int, from_array, from_pairs, from_json_str, ...) instead of From and serde.
• Maps keep their insertion order (like the preserve_order feature).
• Spans and TemplateError::range use UTF-16 offsets (lines and columns match upstream).
• AutoEscape::None is called AutoEscape::NoEscape, ValueKind::None is ValueKind::Null.
• Not ported: the datetime feature of minijinja-contrib, and parts of the CLI (see below).

#Contrib

#Command line tool

moon run cmd/minijinja -- hello.j2 hello.json
moon run cmd/minijinja -- --template='Hello {{ name }}!' -Dname=World
moon run cmd/minijinja -- --expr '1 + 1'
moon run cmd/minijinja -- --help

#License