mustache 0.9.0

Rust implementation of Mustache
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::collections::HashMap;

use mustache::Data;
use mustache::{MapBuilder, VecBuilder};

#[test]
fn test_empty_builders() {
    assert_eq!(MapBuilder::new().build(), Data::Map(HashMap::new()));

    assert_eq!(VecBuilder::new().build(), Data::Vec(Vec::new()));
}

#[test]
fn test_builders() {
    let mut pride_and_prejudice = HashMap::new();
    pride_and_prejudice.insert("title".to_string(),
                               Data::String("Pride and Prejudice".to_string()));
    pride_and_prejudice.insert("publish_date".to_string(), Data::String("1813".to_string()));

    let mut m = HashMap::new();
    m.insert("first_name".to_string(), Data::String("Jane".to_string()));
    m.insert("last_name".to_string(), Data::String("Austen".to_string()));
    m.insert("age".to_string(), Data::String("41".to_string()));
    m.insert("died".to_string(), Data::Bool(true));
    m.insert("works".to_string(),
             Data::Vec(vec![Data::String("Sense and Sensibility".to_string()),
                            Data::Map(pride_and_prejudice)]));

    assert_eq!(MapBuilder::new()
                   .insert_str("first_name", "Jane")
                   .insert_str("last_name", "Austen")
                   .insert("age", &41usize).expect("age")
                   .insert_bool("died", true)
                   .insert_vec("works", |builder| {
            builder.push_str("Sense and Sensibility").push_map(|builder| {
                builder.insert_str("title", "Pride and Prejudice")
                    .insert("publish_date", &1813usize).expect("publish_date")
            })
        })
                   .build(),
               Data::Map(m));
}

#[test]
fn test_map_fn_builder() {
    // We can't directly compare closures, so just make sure we thread
    // through the builder.

    let mut count = 0usize;
    let data = MapBuilder::new()
        .insert_fn("count".to_string(), move |s| {
            count += 1usize;
            s.clone() + &count.to_string()
        })
        .build();

    assert_let!(Data::Map(m) = data => {
        assert_let!(Some(&Data::Fun(ref f)) = m.get("count") => {
            let f = &mut *f.borrow_mut();
            assert_eq!((*f)("count: ".to_string()), "count: 1".to_string());
            assert_eq!((*f)("count: ".to_string()), "count: 2".to_string());
            assert_eq!((*f)("count: ".to_string()), "count: 3".to_string());
        });
    })
}

#[test]
fn test_vec_fn_builder() {
    // We can't directly compare closures, so just make sure we thread
    // through the builder.

    let mut count = 0usize;
    let data = VecBuilder::new()
        .push_fn(move |s| {
            count += 1usize;
            s + &count.to_string()
        })
        .build();

    assert_let!(Data::Vec(vs) = data => {
        let mut iter = vs.iter();

        assert_let!(Some(&Data::Fun(ref f)) = iter.next() => {
            let f = &mut *f.borrow_mut();
            assert_eq!((*f)("count: ".to_string()), "count: 1".to_string());
            assert_eq!((*f)("count: ".to_string()), "count: 2".to_string());
            assert_eq!((*f)("count: ".to_string()), "count: 3".to_string());
        });

        assert_eq!(iter.next(), None);
    })
}