incrust 0.2.15

Template engine inspired by Jinja2
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

use container::expression::*;


pub type ParsedNodes = Vec<ParsedNode>;


#[derive(Debug, PartialEq, Clone)]
pub enum ParsedNode {
    Raw(ParsedRawStatement),
    Text(String),
    Comment(String),
    Mustache(Mustache),
    For(ParsedForStatement),
    If(ParsedIfStatement),
    Block(ParsedBlockStatement),
    Extends(ExprStatement),
    Include(ExprStatement),
}

#[derive(Debug, PartialEq, Clone)]
pub struct SimpleStatement {
    pub strip_left: bool,
    pub strip_right: bool,
}

#[derive(Debug, PartialEq, Clone)]
pub struct NamedStatement {
    pub strip_left: bool,
    pub strip_right: bool,
    pub name: String,
}

#[derive(Debug, PartialEq, Clone)]
pub struct ExprStatement {
    pub strip_left: bool,
    pub strip_right: bool,
    pub expression: FullExpression,
}

#[derive(Debug, PartialEq, Clone)]
pub struct ParsedRawStatement {
    pub begin: SimpleStatement,
    pub text: String,
    pub end: SimpleStatement,
}

#[derive(Debug, PartialEq, Clone)]
pub struct ParsedIfBranch {
    pub begin: ExprStatement,
    pub block: ParsedNodes,
}

#[derive(Debug, PartialEq, Clone)]
pub struct ParsedElseBranch {
    pub begin: SimpleStatement,
    pub block: ParsedNodes,
}

#[derive(Debug, PartialEq, Clone)]
pub struct ParsedIfStatement {
    pub if_branches: Vec<ParsedIfBranch>,
    pub else_branch: Option<ParsedElseBranch>,
    pub end: SimpleStatement,
}

#[derive(Debug, PartialEq, Clone)]
pub struct ParsedForStatement {
    pub begin: ExprStatement,
    pub block: ParsedNodes,
    pub key_var: Option<String>,
    pub value_var: String,
    pub end: SimpleStatement,
}

#[derive(Debug, PartialEq, Clone)]
pub struct ParsedBlockStatement {
    pub begin: NamedStatement,
    pub block: ParsedNodes,
    pub end: SimpleStatement,
}

// ---------------------------------------------------------------------------

impl Default for SimpleStatement {
    fn default() -> Self {
        SimpleStatement {
            strip_left: false,
            strip_right: false,
        }
    }
}

impl Default for NamedStatement {
    fn default() -> Self {
        NamedStatement {
            strip_left: false,
            strip_right: false,
            name: Default::default(),
        }
    }
}

//impl Default for ExprStatement {
//    fn default() -> Self {
//        ExprStatement {
//            strip_left: false,
//            strip_right: false,
//            expression: None,
//        }
//    }
//}

impl Mustache { pub fn new(expr: FullExpression) -> Self { Mustache { expr: expr } } }
impl From<Mustache> for ParsedNode { fn from(v: Mustache) -> Self { ParsedNode::Mustache(v) } }


impl FullExpression {
    pub fn new(expr: DisjExpr, filters: Vec<FilterItem>) -> Self {
        FullExpression { expr: expr, filters: filters }
    }
}


impl From<Literal> for Factor { fn from(v: Literal) -> Self { Factor::Literal(v) } }
impl From<String> for Factor { fn from(v: String) -> Self { Factor::Variable(v) } }
impl From<DisjExpr> for Factor { fn from(v: DisjExpr) -> Self { Factor::Subexpression(v) } }
impl From<Attribute> for Factor { fn from(v: Attribute) -> Self { Factor::Attribute(v) } }
impl From<Invocation> for Factor { fn from(v: Invocation) -> Self { Factor::Invocation(v) } }

impl From<ParsedIfStatement> for ParsedNode { fn from(v: ParsedIfStatement) -> Self { ParsedNode::If(v) } }
impl From<ParsedForStatement> for ParsedNode { fn from(v: ParsedForStatement) -> Self { ParsedNode::For(v) } }
impl From<ParsedBlockStatement> for ParsedNode { fn from(v: ParsedBlockStatement) -> Self { ParsedNode::Block(v) } }
impl From<ParsedRawStatement> for ParsedNode { fn from(v: ParsedRawStatement) -> Self { ParsedNode::Raw(v) } }