chord-flow 0.1.21

async parallel case executor
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
119
120
121
122
123
124
125
126
127
128
129
130
131
132

use handlebars::{
    handlebars_helper, Context, Handlebars, Helper, HelperDef, RenderContext, RenderError,
    ScopedJson,
};

use chord_core::value::{Number, Value};

handlebars_helper!(START_WITH: |x: Json, y: Json|
    x.is_string() && y.is_string() && x.as_str().unwrap().starts_with(y.as_str().unwrap())
);

handlebars_helper!(END_WITH: |x: Json, y: Json|
    x.is_string() && y.is_string() && x.as_str().unwrap().ends_with(y.as_str().unwrap())
);

handlebars_helper!(CONTAINS: |x: Json, y: Json|{
    x.is_string() && y.is_string() && x.as_str().unwrap().contains(y.as_str().unwrap())
});

pub static STR: StrHelper = StrHelper {};
pub static LEN: LenHelper = LenHelper {};
pub static SUB: SubHelper = SubHelper {};
pub static ESCAPE: EscapeHelper = EscapeHelper {};

#[derive(Clone, Copy)]
pub struct StrHelper;

impl HelperDef for StrHelper {
    fn call_inner<'reg: 'rc, 'rc>(
        &self,
        h: &Helper<'reg, 'rc>,
        _: &'reg Handlebars<'reg>,
        _: &'rc Context,
        _: &mut RenderContext<'reg, 'rc>,
    ) -> Result<ScopedJson<'reg, 'rc>, RenderError> {
        let param = h
            .param(0)
            .ok_or_else(|| RenderError::new("Param not found for helper \"str\""))?;

        let json = param.value().to_string();
        Ok(ScopedJson::Derived(Value::String(json)))
    }
}

#[derive(Clone, Copy)]
pub struct SubHelper;

impl HelperDef for SubHelper {
    fn call_inner<'reg: 'rc, 'rc>(
        &self,
        h: &Helper<'reg, 'rc>,
        _: &'reg Handlebars<'reg>,
        _: &'rc Context,
        _: &mut RenderContext<'reg, 'rc>,
    ) -> Result<ScopedJson<'reg, 'rc>, RenderError> {
        let param = h.params();
        let str = param[0]
            .value()
            .as_str()
            .ok_or(RenderError::new("Param invalid for helper \"str_sub\""))?;

        if param.len() == 2 {
            let start = param[1]
                .value()
                .as_f64()
                .ok_or(RenderError::new("Param invalid for helper \"str_sub\""))?
                as usize;
            return Ok(ScopedJson::Derived(Value::String(str[start..].to_owned())));
        } else if param.len() == 3 {
            let start = param[1]
                .value()
                .as_f64()
                .ok_or(RenderError::new("Param invalid for helper \"str_sub\""))?
                as usize;
            let end = param[2]
                .value()
                .as_f64()
                .ok_or(RenderError::new("Param invalid for helper \"str_sub\""))?
                as usize;
            return Ok(ScopedJson::Derived(Value::String(
                str[start..end].to_owned(),
            )));
        } else {
            return Err(RenderError::new("Param invalid for helper \"str_sub\""));
        }
    }
}

#[derive(Clone, Copy)]
pub struct EscapeHelper;

impl HelperDef for EscapeHelper {
    fn call_inner<'reg: 'rc, 'rc>(
        &self,
        h: &Helper<'reg, 'rc>,
        _: &'reg Handlebars<'reg>,
        _: &'rc Context,
        _: &mut RenderContext<'reg, 'rc>,
    ) -> Result<ScopedJson<'reg, 'rc>, RenderError> {
        let param = h.params();
        let str = param[0]
            .value()
            .as_str()
            .ok_or(RenderError::new("Param invalid for helper \"str_escape\""))?;

        return Ok(ScopedJson::Derived(Value::String(
            str.escape_debug().to_string(),
        )));
    }
}

#[derive(Clone, Copy)]
pub struct LenHelper {}

impl HelperDef for LenHelper {
    fn call_inner<'reg: 'rc, 'rc>(
        &self,
        h: &Helper<'reg, 'rc>,
        _: &'reg Handlebars<'reg>,
        _: &'rc Context,
        _: &mut RenderContext<'reg, 'rc>,
    ) -> Result<ScopedJson<'reg, 'rc>, RenderError> {
        let param = h
            .param(0)
            .ok_or_else(|| RenderError::new("Param not found for helper \"str_len\""))?;

        match param.value() {
            Value::String(txt) => Ok(ScopedJson::Derived(Value::Number(Number::from(txt.len())))),
            _ => Err(RenderError::new("Param invalid for helper \"str_len\"")),
        }
    }
}