trimmer 0.3.6

A whitespace- and memory-friendly template 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
98
99
100
101
102

use grammar::{Body, Statement, StatementCode};
use {Options};


pub struct Optimizer {
}

fn is_whitespace(text: &str) -> bool {
    text.chars().all(|x| x.is_whitespace())
}

fn is_line_or_none(stmt: Option<&Statement>) -> bool {
    if let Some(st) = stmt {
        is_line_statement(&st.code)
    } else {
        true
    }
}

fn is_line_statement(code: &StatementCode) -> bool {
    use grammar::StatementCode::*;
    match *code {
        Joiner => false,
        OutputRaw(..) => false,
        Output {..} => false,
        Cond {..} => true,
        Loop {..} => true,
        Alias {..} => true,
    }
}

impl Optimizer {
    pub fn new() -> Optimizer {
        Optimizer {}
    }
    fn visit_body(&self, body: Body) -> Body {
        use grammar::StatementCode::*;

        let mut interm = Vec::with_capacity(body.statements.len());
        for item in body.statements.into_iter() {
            match (interm.last_mut(), &item) {
                (
                    Some(&mut Statement {
                        position: (_, ref mut old_end),
                        code: OutputRaw(ref mut prev),
                    }),
                    &Statement {
                        position: (_, new_end),
                        code: OutputRaw(ref next),
                    },
                ) => {
                    *old_end = new_end;
                    prev.push_str(next);
                    continue;
                }
                _ => {}
            }
            interm.push(item);
        }
        let mut dst = Vec::with_capacity(interm.len());
        let mut iter = interm.into_iter().peekable();
        while let Some(item) = iter.next() {
            match (dst.last(), &item, iter.peek()) {
                (prev, &Statement { code: OutputRaw(ref this), .. }, next)
                if is_whitespace(this) &&
                    is_line_or_none(prev) && is_line_or_none(next)
                // skip current element
                => continue,
                _ => {}
            }
            dst.push(item);
        }
        let s = dst.into_iter().map(|s| {
            let code = match s.code {
                Joiner => Joiner,
                s@OutputRaw(..) | s@Alias { .. } | s@Output {..} => s,
                Cond { indent, conditional, otherwise } => Cond {
                    indent,
                    conditional: conditional.into_iter().map(|(e, b)| {
                        (e, self.visit_body(b))
                    }).collect(),
                    otherwise: self.visit_body(otherwise),
                },
                Loop { indent, target, iterator, filter, body } => Loop {
                    indent, target, iterator, filter,
                    body: self.visit_body(body),
                }
            };
            Statement {
                code: code,
                .. s
            }
        }).collect();
        Body {
            statements: s,
            .. body
        }
    }
    pub fn optimize(&self, _opt: &Options, body: Body) -> Body {
        self.visit_body(body)
    }
}