templar 0.5.0

Lightweight, fast, and powerful templating engine
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

use super::*;

pub struct ParseTree<'a> {
    pub templar: &'a Templar,
    tree: Vec<Node>,
    current_op: Option<Operations>,
}

impl<'a> ParseTree<'a> {
    pub fn new(templar: &'a Templar) -> ParseTree<'a> {
        ParseTree {
            tree: vec![],
            current_op: None,
            templar,
        }
    }

    pub fn set_op(&mut self, op: Operations) -> Result<()> {
        if self.current_op.is_some() {
            self.finish_op()?;
        }
        self.current_op = Some(op);
        Ok(())
    }

    pub fn finish_op(&mut self) -> Result<()> {
        if let Some(ref op) = self.current_op {
            let len = self.tree.len();
            let metadata = op.metadata();
            if len < metadata.minimum_nodes as usize {
                return Err(TemplarError::ParseFailure(format!(
                    "{:?} op requires at least {} nodes",
                    op, metadata.minimum_nodes
                )));
            }
            if let Some(max) = metadata.maximum_nodes {
                if len > max as usize {
                    return Err(TemplarError::ParseFailure(format!(
                        "{:?} op has a maximum of {} nodes",
                        op, max
                    )));
                }
                while self.tree.len() < max as usize {
                    self.tree.push(Node::default())
                }
            }
            let tree = replace(&mut self.tree, vec![]);
            let node = Node::Operation(Arc::new(op.build(tree)));
            self.tree.push(node);
            self.current_op = None;
        }
        Ok(())
    }

    pub fn push(&mut self, node: Node) -> Result<()> {
        self.tree.push(node);
        if let Some(ref op) = self.current_op {
            let metadata = op.metadata();
            if metadata.maximum_nodes.is_some()
                && self.tree.len() == metadata.maximum_nodes.unwrap() as usize
            {
                return self.finish_op();
            }
        }
        Ok(())
    }

    pub fn filter(&mut self, filter: &str, args: Node) -> Result<()> {
        self.finish_op()?;
        let tree = replace(&mut self.tree, vec![]);
        let nodes = vec![tree.into(), args];
        let filter_fn = self
            .templar
            .filters
            .get(filter)
            .ok_or_else(|| TemplarError::FilterNotFound(filter.into()))?
            .clone();
        let executor = FilterExecutor::new(filter_fn);
        self.tree
            .push(Node::Operation(Arc::new(Operation::from_filter(
                filter.into(),
                executor,
                nodes,
            ))));
        Ok(())
    }

    pub fn into_node(mut self) -> Result<Node> {
        self.finish_op()?;
        Ok(self.tree.into())
    }

    pub fn into_nodes(mut self) -> Result<Vec<Node>> {
        self.finish_op()?;
        Ok(self.tree)
    }
}