use std::path::Path;
use std::sync::Arc;
use minijinja::{Environment, path_loader};
use mlua::{AnyUserData, ExternalResult, Lua, Table, UserData, UserDataMethods, Value};
pub(crate) struct LuaTemplate(Arc<Environment<'static>>);
impl UserData for LuaTemplate {
fn add_methods<M: UserDataMethods<Self>>(methods: &mut M) {
methods.add_async_method("render", |_, templ, args: (String, Option<Table>)| {
let (name, data) = args;
let env = templ.0.clone();
let bounded = match &data {
Some(data) => crate::utils::check_json_bounds(&Value::Table(data.clone())),
None => Ok(()),
};
let context = bounded.as_ref().ok().map(|()| {
let data = data.map_or(Value::Nil, Value::Table);
let path = crate::bounded::TablePath::default();
minijinja::Value::from_serialize(crate::bounded::LuaData::new(&data, &path))
});
async move {
bounded?;
let context = context.unwrap_or_default();
tokio::task::spawn_blocking(move || {
env.get_template(&name)
.and_then(|template| template.render(context))
})
.await
.map_err(mlua::Error::external)?
.into_lua_err()
}
});
}
}
fn auto_escape_for(name: &str) -> minijinja::AutoEscape {
let stem = name
.strip_suffix(".j2")
.or_else(|| name.strip_suffix(".jinja"))
.or_else(|| name.strip_suffix(".jinja2"))
.unwrap_or(name);
let plain = [
".txt", ".text", ".md", ".csv", ".json", ".yaml", ".yml", ".toml",
];
if plain.iter().any(|ext| stem.ends_with(ext)) {
minijinja::AutoEscape::None
} else {
minijinja::AutoEscape::Html
}
}
pub(crate) fn create_template_fn(lua: &Lua, dir: &Path) -> mlua::Result<AnyUserData> {
let mut env = Environment::new();
env.set_loader(path_loader(dir));
env.set_auto_escape_callback(auto_escape_for);
let env = Arc::new(env);
lua.create_userdata(LuaTemplate(env))
}
#[cfg(test)]
mod tests {
use super::*;
use crate::utils::{MAX_JSON_DEPTH, deep_table};
fn template_userdata(lua: &Lua) -> AnyUserData {
let mut env = Environment::new();
env.add_template("t.html", "{{ x }}")
.expect("add the test template");
lua.create_userdata(LuaTemplate(Arc::new(env)))
.expect("template userdata")
}
#[tokio::test]
async fn render_bounds_its_context_at_the_shared_depth() {
use mlua::ObjectLike as _;
let lua = Lua::new();
let templ = template_userdata(&lua);
let Value::Table(ok) = deep_table(&lua, MAX_JSON_DEPTH) else {
panic!("deep_table returns a table");
};
templ
.call_async_method::<String>("render", ("t.html", ok))
.await
.expect("a context at the bound still renders");
let Value::Table(too_deep) = deep_table(&lua, MAX_JSON_DEPTH + 1) else {
panic!("deep_table returns a table");
};
let err = templ
.call_async_method::<String>("render", ("t.html", too_deep))
.await
.expect_err("a context past the bound must be refused");
assert!(
err.to_string().contains("nested deeper than 128 levels"),
"got: {err}"
);
}
#[tokio::test]
async fn render_refuses_a_table_mixing_list_items_and_named_keys() {
use mlua::ObjectLike as _;
let lua = Lua::new();
let templ = template_userdata(&lua);
let data: Table = lua.load("{ x = { 'a', total = 1 } }").eval().expect("data");
let err = templ
.call_async_method::<String>("render", ("t.html", data))
.await
.expect_err("mixed");
assert!(
err.to_string().contains("mixes list items and named keys"),
"got: {err}"
);
}
#[tokio::test]
async fn templates_escape_html_unless_named_as_plain_text() {
use mlua::ObjectLike as _;
let lua = Lua::new();
let mut env = Environment::new();
env.set_auto_escape_callback(auto_escape_for);
for name in ["page.j2", "page.html", "page", "mail.html.j2"] {
env.add_template(name, "{{ x }}").expect("add");
}
env.add_template("mail.txt.j2", "{{ x }}").expect("add");
env.add_template("data.json", "{{ x }}").expect("add");
let templ = lua
.create_userdata(LuaTemplate(Arc::new(env)))
.expect("userdata");
let ctx = lua.create_table().expect("table");
ctx.set("x", "<b>&</b>").expect("set");
for name in ["page.j2", "page.html", "page", "mail.html.j2"] {
let out: String = templ
.call_async_method("render", (name, &ctx))
.await
.expect("render");
assert_eq!(out, "<b>&</b>", "{name} must escape");
}
for name in ["mail.txt.j2", "data.json"] {
let out: String = templ
.call_async_method("render", (name, &ctx))
.await
.expect("render");
assert_eq!(out, "<b>&</b>", "{name} is plain text");
}
}
#[tokio::test]
async fn render_bounds_its_context_by_node_count() {
use mlua::ObjectLike as _;
let lua = Lua::new();
let templ = template_userdata(&lua);
let Value::Table(dag) = crate::utils::dag_table(&lua, 21) else {
panic!("dag_table returns a table");
};
let err = templ
.call_async_method::<String>("render", ("t.html", dag))
.await
.expect_err("a DAG context must be refused");
assert!(
err.to_string().contains("expands to more than"),
"got: {err}"
);
}
}