Skip to main content

rocket_dyn_templates/engine/
minijinja.rs

1use std::path::Path;
2use std::collections::HashMap;
3
4use rocket::serde::Serialize;
5use minijinja::{Environment, Error, ErrorKind, AutoEscape};
6use minijinja::value::Serde;
7
8use crate::engine::Engine;
9
10impl Engine for Environment<'static> {
11    const EXT: &'static str = "j2";
12
13    fn init<'a>(templates: impl Iterator<Item = (&'a str, &'a Path)>) -> Self {
14        let templates = templates
15            .map(|(name, path)| (name.to_owned(), path.to_owned()))
16            .collect::<HashMap<_, _>>();
17
18        let mut env = Environment::new();
19        env.set_auto_reload(false);
20        env.set_loader(move |name| {
21            let Some(path) = templates.get(name) else {
22                return Ok(None);
23            };
24
25            match std::fs::read_to_string(path) {
26                Ok(result) => Ok(Some(result)),
27                Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok(None),
28                Err(e) => Err(
29                    Error::new(ErrorKind::InvalidOperation, "template read failed").with_source(e)
30                ),
31            }
32        });
33
34        env.set_auto_escape_callback(|name| {
35            let Some((stem, ext)) = name.rsplit_once('.') else {
36                return AutoEscape::None;
37            };
38
39            let ext = match ext {
40                "j2" | "jinja" | "jinja2" => match stem.rsplit_once('.') {
41                    Some((_, ext)) => ext,
42                    None => return AutoEscape::None,
43                },
44                _ => ext,
45            };
46
47            if ["html", "htm", "xml", "xhtml", "svg"].iter().any(|s| ext.eq_ignore_ascii_case(s)) {
48                AutoEscape::Html
49            } else {
50                minijinja::default_auto_escape_callback(name)
51            }
52        });
53
54        env
55    }
56
57    fn load<'a>(&mut self, _: impl Iterator<Item = (&'a str, &'a Path)>) -> Option<()> {
58        Some(())
59    }
60
61    fn render<C: Serialize>(&self, template: &str, context: C) -> Option<String> {
62        let templ = match self.get_template(template) {
63            Ok(templ) => templ,
64            Err(e) => {
65                span_error!("templating", template, "failed to load Minijinja template" => {
66                    let mut error = Some(&e as &dyn std::error::Error);
67                    while let Some(err) = error {
68                        error!("{err}");
69                        error = err.source();
70                    }
71                });
72
73                return None;
74            }
75        };
76
77        match templ.render(Serde(context)) {
78            Ok(result) => Some(result),
79            Err(e) => {
80                span_error!("templating", template, "failed to render Minijinja template" => {
81                    let mut error = Some(&e as &dyn std::error::Error);
82                    while let Some(err) = error {
83                        error!("{err}");
84                        error = err.source();
85                    }
86                });
87
88                None
89            }
90        }
91    }
92}