pillow_templates/
lib.rs

1use handlebars::Handlebars;
2use pillow_fs::FS;
3use serde_json::Value;
4use tera::Tera;
5
6pub use tera::Context;
7
8/// Templates options in Pillow
9#[derive(Debug, Clone)]
10pub enum Template {
11    /// Render Html
12    ///
13    /// # Arguments
14    ///
15    /// * `page_name` - Page to render
16    ///
17    /// # Examples
18    ///
19    /// ```rust
20    /// use pillow_templates::Template;
21    ///
22    /// let html = Template::Html("index");
23    /// ```
24    Html(&'static str),
25    /// Render Handlebars
26    ///
27    /// # Arguments
28    ///
29    /// * `page_name` - Page to render
30    /// * `value` - Value from serde_json
31    ///
32    /// # Examples
33    ///
34    /// ```rust
35    /// use pillow_templates::Template;
36    /// use serde_json::json;
37    ///
38    /// let hbs = Template::Handlebars("index", json!({}));
39    /// ```
40    Handlebars(&'static str, Value),
41    /// Render with Tera
42    ///
43    /// # Arguments
44    ///
45    /// * `page_name` - Page to render
46    /// * `extension` - File extension
47    /// * `context` - Context from Tera
48    ///
49    /// # Examples
50    ///
51    /// ```rust
52    /// use pillow_templates::Template;
53    /// use Tera::Context;
54    ///
55    /// let ctx = Context::new();
56    /// let tera = Template::Tera("index", "html", ctx);
57    /// ```
58    Tera(&'static str, &'static str, Context),
59}
60
61impl Template {
62    /// Return a page in string format
63    ///
64    /// # Examples
65    ///
66    /// ```rust
67    /// use pillow_templates::Template;
68    ///
69    /// let html_template = Template::Html("index");
70    //
71    /// assert_eq!(html_template.render(), "".to_string());
72    /// ```
73    pub fn render(&self) -> String {
74        let resources = "resources/views";
75
76        match self {
77            Template::Html(file) => {
78                let path = format!("{}/{}.html", resources, file);
79
80                FS::read_to_string(path.as_str())
81            }
82
83            Template::Handlebars(hbs, value) => {
84                let path = format!("{}/{}.hbs", resources, hbs);
85                let mut reg = Handlebars::new();
86
87                reg.register_template_file(&hbs, path).unwrap();
88
89                reg.render(&hbs, value).unwrap()
90            }
91
92            Template::Tera(name_file, ext, ctx) => {
93                let path = format!("{}/*", resources);
94
95                let tera = match Tera::new(&path) {
96                    Ok(t) => t,
97                    Err(e) => panic!("{e}"),
98                };
99
100                let template_file = format!("{}.{}", name_file, ext);
101
102                tera.render(&template_file, ctx)
103                    .expect("Failed to render template")
104            }
105        }
106    }
107}
108
109#[cfg(test)]
110mod tests {
111    use serde_json::json;
112
113    use super::*;
114
115    #[test]
116    fn it_works_html() {
117        let page = Template::Html("index_html");
118
119        assert_eq!(page.render(), "");
120    }
121
122    #[test]
123    fn it_works_hbs() {
124        let page = Template::Handlebars("index_hbs", json!({}));
125
126        println!("{:#?}", page.render());
127
128        assert_eq!(page.render(), "");
129    }
130
131    #[test]
132    fn it_works_tera_html() {
133        let ctx = Context::new();
134        let page = Template::Tera("index_tera", "html", ctx);
135
136        println!("{:#?}", page.render());
137
138        assert_eq!(page.render(), "");
139    }
140}