tpl 0.1.4

simple pure template
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::str;
use nom::IResult;
use errors::{Error, ErrorKind};

#[derive(Debug, PartialEq)]
pub enum Exp<'a> {
    Func { name: &'a str },
    Literal(&'a str),
}

named!(literal<&[u8], Exp>,
    map!(
        map_res!(
            is_not!("%{"),
            str::from_utf8
        ),
        Exp::Literal
    )
);

named!(func<&[u8], Exp>,
    do_parse!(
        tag!("%{") >>
        name: map_res!(take_until!("}"), str::from_utf8) >>
        tag!("}") >>
        (Exp::Func {
            name: name,
        })
    )
);

named!(pub exps<&[u8], Vec<Exp>>,
    many0!(
        alt!(func | literal)
    )
);

pub fn parse(input: &str) -> Result<Vec<Exp>, Error> {
    match exps(input.as_bytes()) {
        IResult::Done(_, exps) => Ok(exps),
        _ => Err(ErrorKind::Parse.into()),
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn parse_literal() {
        assert_eq!(
            literal(b"testing"),
            IResult::Done(&b""[..], Exp::Literal("testing"))
        );
    }

    #[test]
    fn parse_func() {
        assert_eq!(
            func(b"%{test}"),
            IResult::Done(&b""[..], Exp::Func { name: "test" })
        );
    }

    #[test]
    fn parse_exps() {
        assert_eq!(
            exps(b"%{test}literal%{test2}haha"),
            IResult::Done(
                &b""[..],
                vec![
                    Exp::Func { name: "test" },
                    Exp::Literal("literal"),
                    Exp::Func { name: "test2" },
                    Exp::Literal("haha"),
                ],
            )
        );

        assert_eq!(
            exps(b"haha%{test}%{test2}lala"),
            IResult::Done(
                &b""[..],
                vec![
                    Exp::Literal("haha"),
                    Exp::Func { name: "test" },
                    Exp::Func { name: "test2" },
                    Exp::Literal("lala"),
                ],
            )
        );
    }
}