femstache 0.1.7

Embrace the feminine mustache to unlock your templating dreams! Or something, I don't know. :3
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

use std::collections::BTreeMap;

use femstache_eval::{EvalError, EvalResult, StringValue, TemplateEnv, TemplateInput, eval_expr};
use femstache_loader::{LoaderError, TemplateLoader};
use femstache_parser::nodes::{Control, Document, DocumentNode, DocumentNodes, Stache};

use crate::output::Output;

pub struct TemplateRenderer<'i, I: TemplateInput> {
    env: TemplateEnv<'i, I>,
    blocks: BTreeMap<String, String>,
    loader: Option<TemplateLoader>,
}

impl<'i, I: TemplateInput> TemplateRenderer<'i, I> {
    pub fn new(
        env: TemplateEnv<'i, I>,
        blocks: BTreeMap<String, String>,
        loader: Option<TemplateLoader>,
    ) -> Self {
        Self {
            env,
            blocks,
            loader,
        }
    }

    pub fn render_document(&mut self, document: &Document, output: &mut Output) -> EvalResult<()> {
        if let Some(meta) = &document.meta
            && let Some(inherit) = &meta.inherit
        {
            if let Some(loader) = self.loader.as_mut() {
                let template = loader.load(inherit.path.as_str())?;
                self.env.push();
                self.render_document_nodes(&document.nodes, &mut Output::null(output.escape()))?;
                self.env.pop();
                self.env.push();
                self.render_document(template.document(), output)?;
                self.env.pop();
            } else {
                return Err(EvalError::Loader(LoaderError::NoLoader));
            }
        } else {
            self.render_document_nodes(&document.nodes, output)?;
        }
        Ok(())
    }

    pub fn render_document_nodes(
        &mut self,
        nodes: &DocumentNodes,
        output: &mut Output,
    ) -> EvalResult<()> {
        for node in &nodes.nodes {
            self.render_document_node(node, output)?;
        }
        Ok(())
    }

    pub fn render_document_node(
        &mut self,
        node: &DocumentNode,
        output: &mut Output,
    ) -> EvalResult<()> {
        match node {
            DocumentNode::Output(o) => {
                output.push(&o.data);
                Ok(())
            }
            DocumentNode::Stache(s) => self.render_stache(s, output),
            DocumentNode::Control(c) => self.render_control(c, output),
        }
    }

    pub fn render_stache(&mut self, stache: &Stache, output: &mut Output) -> EvalResult<()> {
        let val = eval_expr(&self.env, &stache.expr)?;
        let s = val.as_string().ok_or(EvalError::InvalidType)?;
        match s {
            StringValue::Regular(s) => output.push_escaped(s),
            StringValue::Raw(s) => output.push(s),
        }
        Ok(())
    }

    pub fn render_control(&mut self, control: &Control, output: &mut Output) -> EvalResult<()> {
        match control {
            Control::IfControl(if_control) => {
                let cond = eval_expr(&self.env, &if_control.open.cond)?;
                if cond.is_truthy() {
                    self.env.push();
                    self.render_document_nodes(&if_control.inner, output)?;
                    self.env.pop();
                }
            }
            Control::ForControl(for_control) => {
                let value = eval_expr(&self.env, &for_control.open.expr)?;
                let list = value.into_list().ok_or(EvalError::InvalidType)?;
                for item in list {
                    self.env.push();
                    self.env.set(&for_control.open.var.data, item);
                    self.render_document_nodes(&for_control.inner, output)?;
                    self.env.pop();
                }
            }
            Control::BlockControl(block_control) => {
                self.env.push();
                if let Some(block) = self.blocks.get(block_control.open.name.as_str()) {
                    output.push(block);
                } else {
                    let key = block_control.open.name.as_str().to_owned();
                    let mut block = Output::string(output.escape());
                    self.env.push();
                    self.render_document_nodes(&block_control.inner, &mut block)?;
                    let block = block.into_inner();
                    output.push(&block);
                    self.blocks.insert(key, block);
                    self.env.pop();
                }
                self.env.pop();
            }
            Control::IncludeControl(include_control) => {
                if let Some(loader) = self.loader.as_mut() {
                    let template = loader.load(include_control.path.as_str())?;
                    self.env.push();
                    self.render_document(template.document(), output)?;
                    self.env.pop();
                } else {
                    return Err(EvalError::Loader(LoaderError::NoLoader));
                }
            }
            Control::LetControl(let_control) => {
                let value = eval_expr(&self.env, &let_control.expr)?;
                self.env.set(&let_control.var.data, value);
            }
        }
        Ok(())
    }
}