zen-tmpl 0.55.0

Zen Template Language
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

use std::iter::Peekable;
use std::rc::Rc;
use std::slice::Iter;

use crate::error::TemplateRenderError;
use crate::parser::Node;
use zen_expression::variable::Variable;
use zen_expression::Isolate;

#[derive(Debug, PartialEq)]
pub(crate) enum InterpreterResult<'a> {
    String(&'a str),
    Variable(Variable),
}

#[derive(Debug)]
pub(crate) struct Interpreter<'source, 'nodes> {
    cursor: Peekable<Iter<'nodes, Node<'source>>>,
    isolate: Isolate<'source>,
    results: Vec<InterpreterResult<'source>>,
}

impl<'source, 'nodes, T> From<T> for Interpreter<'source, 'nodes>
where
    T: Into<&'nodes [Node<'source>]>,
{
    fn from(value: T) -> Self {
        let nodes = value.into();
        let cursor = nodes.iter().peekable();

        Self {
            cursor,
            isolate: Isolate::new(),
            results: Default::default(),
        }
    }
}

impl<'source, 'nodes> Interpreter<'source, 'nodes> {
    pub(crate) fn collect_for(
        mut self,
        context: Variable,
    ) -> Result<Variable, TemplateRenderError> {
        self.isolate.set_environment(context);

        while let Some(node) = self.cursor.next() {
            match node {
                Node::Text(data) => self.text(data),
                Node::Expression(data) => self.expression(data)?,
            }
        }

        match self.results.len() {
            0 => Ok(Variable::Null),
            1 => {
                let item = self.results.remove(0);
                match item {
                    InterpreterResult::Variable(val) => Ok(val),
                    InterpreterResult::String(str) => Ok(Variable::String(Rc::from(str))),
                }
            }
            _ => {
                let string_data = self
                    .results
                    .into_iter()
                    .map(|item| match item {
                        InterpreterResult::String(str) => str.to_string(),
                        InterpreterResult::Variable(value) => var_to_string(value),
                    })
                    .collect::<String>();

                Ok(Variable::String(Rc::from(string_data.as_str())))
            }
        }
    }

    fn text(&mut self, data: &'source str) {
        self.results.push(InterpreterResult::String(data));
    }

    fn expression(&mut self, data: &'source str) -> Result<(), TemplateRenderError> {
        let result = self.isolate.run_standard(data)?;
        self.results.push(InterpreterResult::Variable(result));
        Ok(())
    }
}

fn var_to_string(var: Variable) -> String {
    match var {
        Variable::String(s) => s.to_string(),
        _ => var.to_string(),
    }
}