[go: up one dir, main page]

handlebars 0.32.3

Handlebars templating implemented in Rust.
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

extern crate handlebars;
#[macro_use]
extern crate serde_json;

use handlebars::{Handlebars, Helper, HelperDef, RenderContext, RenderError};
use serde_json::Value;

struct GtHelper;

impl HelperDef for GtHelper {
    fn call_inner(
        &self,
        h: &Helper,
        _: &Handlebars,
        _: &mut RenderContext,
    ) -> Result<Option<Value>, RenderError> {
        let p1 = try!(
            h.param(0,)
                .and_then(|v| v.value().as_i64(),)
                .ok_or(RenderError::new(
                    "Param 0 with i64 type is required for gt helper."
                ),)
        );
        let p2 = try!(
            h.param(1,)
                .and_then(|v| v.value().as_i64(),)
                .ok_or(RenderError::new(
                    "Param 1 with i64 type is required for gt helper."
                ),)
        );

        Ok(Some(Value::Bool(p1 > p2)))
    }
}

struct NotHelper;

impl HelperDef for NotHelper {
    fn call_inner(
        &self,
        h: &Helper,
        _: &Handlebars,
        _: &mut RenderContext,
    ) -> Result<Option<Value>, RenderError> {
        let p1 = try!(
            h.param(0,)
                .and_then(|v| v.value().as_bool(),)
                .ok_or(RenderError::new(
                    "Param 0 with bool type is required for not helper."
                ),)
        );

        Ok(Some(Value::Bool(!p1)))
    }
}

#[test]
fn test_subexpression() {
    let mut hbs = Handlebars::new();

    hbs.register_helper("gt", Box::new(GtHelper));
    hbs.register_helper("not", Box::new(NotHelper));

    let data = json!({"a": 1, "b": 0, "c": 2});

    assert_eq!(
        hbs.render_template("{{#if (gt a b)}}Success{{else}}Failed{{/if}}", &data)
            .unwrap(),
        "Success"
    );

    assert_eq!(
        hbs.render_template("{{#if (gt a c)}}Success{{else}}Failed{{/if}}", &data)
            .unwrap(),
        "Failed"
    );

    assert_eq!(
        hbs.render_template("{{#if (not (gt a c))}}Success{{else}}Failed{{/if}}", &data)
            .unwrap(),
        "Success"
    );

    assert_eq!(
        hbs.render_template("{{#if (not (gt a b))}}Success{{else}}Failed{{/if}}", &data)
            .unwrap(),
        "Failed"
    );

    // no argument provided for not
    assert_eq!(
        hbs.render_template("{{#if (not)}}Success{{else}}Failed{{/if}}", &data)
            .unwrap(),
        "Failed"
    );

    // json literal
    assert_eq!(
        hbs.render_template("{{#if (not true)}}Success{{else}}Failed{{/if}}", &data)
            .unwrap(),
        "Failed"
    );
    assert_eq!(
        hbs.render_template("{{#if (not false)}}Success{{else}}Failed{{/if}}", &data)
            .unwrap(),
        "Success"
    );
}