twig 0.1.0

Twig templating engine for Rust; work in progress.
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
103
104
105
106
107
108
109
110
111
112
113
114
115
116

extern crate twig;

use super::support;
use twig::nodes::expr::Expr;

#[test]
fn test_array_expression() {
    for (template, expected) in get_tests_for_array() {
        let module = support::expect_parsed(template);
        assert_eq!(module.body.expect_print(), &expected);
    }
}

fn get_tests_for_array<'r>() -> Vec<(&'static str, Expr<'r>)> {
    vec![
        // simple array
        (r#"{{ [1, 2] }}"#, Expr::new_array(vec![
            Expr::new_int_constant(1, 1),
            Expr::new_int_constant(2, 1),
        ], 1)),
        // array with trailing ,
        (r#"{{ [1, 2, ] }}"#, Expr::new_array(vec![
            Expr::new_int_constant(1, 1),
            Expr::new_int_constant(2, 1),
        ], 1)),
        // simple hash
        (r#"{{ {"a": "b", "b": "c"} }}"#, Expr::new_hash(vec![
            (
                Expr::new_str_constant("a", 1),
                Expr::new_str_constant("b", 1),
            ),
            (
                Expr::new_str_constant("b", 1),
                Expr::new_str_constant("c", 1),
            ),
        ], 1)),
        // hash with trailing ,
        (r#"{{ {"a": "b", "b": "c", } }}"#, Expr::new_hash(vec![
            (
                Expr::new_str_constant("a", 1),
                Expr::new_str_constant("b", 1),
            ),
            (
                Expr::new_str_constant("b", 1),
                Expr::new_str_constant("c", 1),
            ),
        ], 1)),
        // hash with unquoted keys
        (r#"{{ {a: "b", b: "c" } }}"#, Expr::new_hash(vec![
            (
                Expr::new_str_constant("a", 1),
                Expr::new_str_constant("b", 1),
            ),
            (
                Expr::new_str_constant("b", 1),
                Expr::new_str_constant("c", 1),
            ),
        ], 1)),
        // hash with number keys
        (r#"{{ {2: "b", 3: "c" } }}"#, Expr::new_hash(vec![
            (
                Expr::new_int_constant(2, 1),
                Expr::new_str_constant("b", 1),
            ),
            (
                Expr::new_int_constant(3, 1),
                Expr::new_str_constant("c", 1),
            ),
        ], 1)),
        // hash in an array
        (r#"{{ [1, {"a": "b", "b": "c"}] }}"#, Expr::new_array(vec![
            Expr::new_int_constant(1, 1),
            Expr::new_hash(vec![
                (
                    Expr::new_str_constant("a", 1),
                    Expr::new_str_constant("b", 1),
                ),
                (
                    Expr::new_str_constant("b", 1),
                    Expr::new_str_constant("c", 1),
                ),
            ], 1),
        ], 1)),
        // array in a hash
        (r#"{{ {"a": [1, 2], "b": "c"} }}"#, Expr::new_hash(vec![
            (
                Expr::new_str_constant("a", 1),
                Expr::new_array(vec![
                    Expr::new_int_constant(1, 1),
                    Expr::new_int_constant(2, 1),
                ], 1),
            ),
            (
                Expr::new_str_constant("b", 1),
                Expr::new_str_constant("c", 1),
            ),
        ], 1)),
    ]
}

#[test]
fn test_array_syntax_error() {
    for template in get_failing_tests_for_array() {
        match support::maybe_parsed(template) {
            Ok(_) => panic!("expected {:?} to produce error", template),
            Err(e) => { println!("tmp {} produces {}", template, e); },
        }
    }
}

fn get_failing_tests_for_array<'r>() -> Vec<&'static str> {
    vec![
        r#"{{ [1, "a": "b"] }}"#,
        r#"{{ {"a": "b", 2} }}"#,
    ]
}