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
133
134
135
136
137
138

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

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

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

pub static ARR: ArrHelper = ArrHelper {};
pub static LEN: LenHelper = LenHelper {};
pub static SUB: SubHelper = SubHelper {};
pub static GET: GetHelper = GetHelper {};

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

impl HelperDef for ArrHelper {
    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 \"arr\""))?;

        match param.value() {
            Value::String(txt) => Ok(ScopedJson::Derived(Value::Array(from_str(txt)?))),
            Value::Array(arr) => Ok(ScopedJson::Derived(Value::Array(arr.clone()))),
            _ => Err(RenderError::new("\"arr\" can not convert ")),
        }
    }
}

#[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 params = h.params();
        let arr = params[0]
            .value()
            .as_array()
            .ok_or(RenderError::new("Param invalid for helper \"arr_sub\""))?;

        if params.len() == 2 {
            let start = params[1]
                .value()
                .as_f64()
                .ok_or(RenderError::new("Param invalid for helper \"arr_sub\""))?
                as usize;
            let mut a = Vec::<Value>::new();
            a.clone_from_slice(&arr[start..]);
            return Ok(ScopedJson::Derived(Value::Array(a)));
        } else if params.len() == 3 {
            let start = params[1]
                .value()
                .as_f64()
                .ok_or(RenderError::new("Param invalid for helper \"arr_sub\""))?
                as usize;
            let end = params[2]
                .value()
                .as_f64()
                .ok_or(RenderError::new("Param invalid for helper \"arr_sub\""))?
                as usize;
            let mut a = Vec::<Value>::new();
            a.clone_from_slice(&arr[start..end]);
            return Ok(ScopedJson::Derived(Value::Array(a)));
        } else {
            return Err(RenderError::new("Param invalid for helper \"arr_sub\""));
        }
    }
}

#[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 params = h.params();
        let arr = params[0]
            .value()
            .as_array()
            .ok_or(RenderError::new("Param invalid for helper \"arr_len\""))?;

        Ok(ScopedJson::Derived(Value::Number(Number::from(arr.len()))))
    }
}

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

impl HelperDef for GetHelper {
    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 params = h.params();
        let arr = params[0]
            .value()
            .as_array()
            .ok_or(RenderError::new("Param invalid for helper \"arr_get\""))?;

        if params.len() == 2 {
            let start = params[1]
                .value()
                .as_f64()
                .ok_or(RenderError::new("Param invalid for helper \"arr_get\""))?
                as usize;
            let result = if arr.len() > 0 {
                arr[start].clone()
            } else {
                Value::Null
            };
            return Ok(ScopedJson::Derived(result));
        } else {
            return Err(RenderError::new("Param invalid for helper \"arr_get\""));
        }
    }
}