liquid 0.21.1

The liquid templating language for Rust
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
117
118

use liquid::ObjectView;
use liquid::ValueView;

#[derive(ObjectView, ValueView, serde::Serialize, serde::Deserialize, Debug)]
struct TestEmpty {}

#[test]
fn test_empty_value() {
    let uut = TestEmpty {};

    assert_eq!(uut.render().to_string(), "");
    assert_eq!(uut.source().to_string(), "{}");
    assert_eq!(uut.type_name(), "object");
    assert_eq!(uut.query_state(liquid::model::State::Truthy), true);
    assert_eq!(uut.query_state(liquid::model::State::DefaultValue), true);
    assert_eq!(uut.query_state(liquid::model::State::Empty), true);
    assert_eq!(uut.query_state(liquid::model::State::Blank), true);
    assert_eq!(uut.to_kstr(), "");
    assert_eq!(uut.to_value(), liquid::model::value!({}));
    assert!(uut.as_object().is_some());
}

#[test]
fn test_empty_object() {
    let uut = TestEmpty {};

    assert_eq!(uut.size(), 0);
    assert!(uut.keys().collect::<Vec<_>>().is_empty());
    assert!(uut.values().collect::<Vec<_>>().is_empty());
    assert!(uut.iter().collect::<Vec<_>>().is_empty());
    assert_eq!(uut.contains_key("non-existent"), false);
    assert!(uut.get("non-existent").is_none());
}

#[derive(ObjectView, ValueView, serde::Serialize, serde::Deserialize, Debug)]
struct TestStatic {
    boolean: bool,
    int: i64,
    float: f64,
    static_str: &'static str,
    string: String,
    kstring: kstring::KString,
    array: Vec<i64>,
}

impl TestStatic {
    fn non_default() -> Self {
        Self {
            boolean: true,
            int: 5,
            float: 4.2,
            static_str: "Hello world",
            string: String::from("Goodbye world"),
            kstring: kstring::KString::from_static("foo"),
            array: vec![1, 2, 3],
        }
    }
}

#[test]
fn test_static_value() {
    let uut = TestStatic::non_default();

    assert_ne!(uut.render().to_string(), "");
    assert_ne!(uut.source().to_string(), "{}");
    assert_eq!(uut.type_name(), "object");
    assert_eq!(uut.query_state(liquid::model::State::Truthy), true);
    assert_eq!(uut.query_state(liquid::model::State::DefaultValue), false);
    assert_eq!(uut.query_state(liquid::model::State::Empty), false);
    assert_eq!(uut.query_state(liquid::model::State::Blank), false);
    assert_ne!(uut.to_kstr(), "");
    assert_ne!(uut.to_value(), liquid::model::value!({}));
    assert!(uut.as_object().is_some());
}

#[test]
fn test_static_object() {
    let uut = TestStatic::non_default();

    assert_eq!(uut.size(), 7i64);
    assert!(!uut.keys().collect::<Vec<_>>().is_empty());
    assert!(!uut.values().collect::<Vec<_>>().is_empty());
    assert!(!uut.iter().collect::<Vec<_>>().is_empty());
    assert_eq!(uut.contains_key("non-existent"), false);
    assert_eq!(uut.contains_key("boolean"), true);
    assert!(uut.get("boolean").is_some());
}

#[derive(ObjectView, ValueView, serde::Serialize, serde::Deserialize, Debug)]
struct TestBorrow<'s> {
    s: &'s str,
}

#[test]
fn test_borrow_value() {
    let fixture = String::from("foo");
    let uut = TestBorrow {
        s: fixture.as_str(),
    };

    assert!(uut.as_object().is_some());
}

#[test]
fn test_borrow_object() {
    let fixture = String::from("foo");
    let uut = TestBorrow {
        s: fixture.as_str(),
    };

    assert_eq!(uut.size(), 1i64);
    assert!(!uut.keys().collect::<Vec<_>>().is_empty());
    assert!(!uut.values().collect::<Vec<_>>().is_empty());
    assert!(!uut.iter().collect::<Vec<_>>().is_empty());
    assert_eq!(uut.contains_key("non-existent"), false);
    assert_eq!(uut.contains_key("s"), true);
    assert!(uut.get("s").is_some());
}