incrust 0.0.15

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

use std::str;
#[allow(unused_imports)]
use nom::{IResult, Err as NomErr, ErrorKind, alpha, alphanumeric, eof, space, multispace};

use ::template::{Parsed, Mustache};

use super::statements::{statement, stmt_edge};
use super::expressions::{full_expression};


named!(pub text<&[u8], Vec<Parsed> >, chain!( t: inner ~ eof, || t ) );


pub fn inner(input: &[u8]) -> IResult<&[u8], Vec<Parsed> > {
    let (i, list) = try_parse!(input, many0!(parsed) );
    IResult::Done(i, list)
}



named!(parsed<&[u8], Parsed>,
    alt!(
        plain_text          |
        comment             |
        mustache            |
        statement
    )
);


fn comment(input: &[u8]) -> IResult<&[u8], Parsed> {
    let (i, (_, comment, _)) = try_parse!(input,
        tuple!(
            tag!("{#"),
            map_res!(
                take_until!("#}"),
                str::from_utf8
            ),
            tag!("#}")
        )
    );
    IResult::Done(i, Parsed::Comment(comment.to_owned()))
}


fn mustache(input: &[u8]) -> IResult<&[u8], Parsed> {
    let (i, (_, _, fe, _, _)) = try_parse!(input,
        tuple!(
            tag!("{{"),
            many0!(multispace),
            full_expression,
            many0!(multispace),
            tag!("}}")
        )
    );
    IResult::Done(i, Mustache::new(fe).into())
}


fn plain_text(input: &[u8]) -> IResult<&[u8], Parsed> {
    #[cfg_attr(feature = "clippy", allow(needless_lifetimes))]
    fn try_brace<'a>(input: &'a [u8]) -> IResult<&[u8], &str> {
        let b = || -> IResult<&'a [u8], ()> {
            let _ = try_parse!(input, alt!( mustache | comment | stmt_edge ) );
            IResult::Done(input, ())
        };
        match b().is_done() {
            false   => IResult::Done(&input[1..], "{"),
            true    => IResult::Error(NomErr::Code(ErrorKind::Custom(0))),
        }
    }

    let (i, text) = try_parse!(input,
        chain!( v: many1!(
            alt!( map_res!( is_not!("{"), str::from_utf8 ) | try_brace )
        ), || v.join("") )
    );
    IResult::Done(i, Parsed::Text(text))
}



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


//#[cfg(test)]
//mod tests {
//    #![cfg_attr(feature = "clippy", allow(used_underscore_binding))]
//
//    use nom::IResult::Done;
//
//}