stepflow-json 0.0.3

StepFlow flow definitions using JSON
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

use std::collections::HashMap;
use tinyjson::JsonValue;
use super::error::StepFlowParseError;

// FUTURE: would be cleaner as a trait on JsonValue

pub fn jsonval_get_obj<'a>(val: &'a JsonValue, key: &str) -> Result<&'a HashMap<String, JsonValue>, StepFlowParseError> {
    if let JsonValue::Object(o) = val {
        Ok(o)
    } else {
        Err(StepFlowParseError::WrongType { key: key.to_owned(), expected: "Object".to_owned() })
    }
}

pub fn jsonval_get_str<'a>(val: &'a JsonValue, key: &str) -> Result<&'a String, StepFlowParseError> {
    if let JsonValue::String(s) = val {
        Ok(s)
    } else {
        Err(StepFlowParseError::WrongType { key: key.to_owned(), expected: "String".to_owned() })
    }
}

pub fn jsonval_get_u64(val: &JsonValue, key: &str) -> Result<u64, StepFlowParseError> {
    if let JsonValue::Number(num) = val {
        let uint = *num as u64;
        if uint as f64 == *num {
            Ok(uint)
        } else {
            Err(StepFlowParseError::WrongType { key: key.to_owned(), expected: "uint".to_owned() })
        }
    } else {
        Err(StepFlowParseError::WrongType { key: key.to_owned(), expected: "Number".to_owned() })
    }
}

pub fn jsonval_obj_get_u64(jsonobj: &HashMap<String, JsonValue>, key: &str) -> Result<u64, StepFlowParseError> {
    if let Some(val) = jsonobj.get(key) {
        jsonval_get_u64(val, key)
    } else {
        Err(StepFlowParseError::MissingValue(key.to_owned()))
    }
}

pub fn jsonval_obj_get_obj<'a>(jsonobj: &'a HashMap<String, JsonValue>, key: &str) -> Result<&'a HashMap<String, JsonValue>, StepFlowParseError> {
    if let Some(val) = jsonobj.get(key) {
        jsonval_get_obj(val, key)
    } else {
        Err(StepFlowParseError::MissingValue(key.to_owned()))
    }
}

pub fn jsonval_obj_get_str<'a>(jsonobj: &'a HashMap<String, JsonValue>, key: &str) -> Result<&'a String, StepFlowParseError> {
    if let Some(val) = jsonobj.get(key) {
        jsonval_get_str(val, key)
    } else {
        Err(StepFlowParseError::MissingValue(key.to_owned()))
    }
}

pub fn jsonval_obj_get_vec<'a>(jsonobj: &'a HashMap<String, JsonValue>, key: &str) -> Result<&'a Vec<JsonValue>, StepFlowParseError> {
    if let Some(val) = jsonobj.get(key) {
        if let JsonValue::Array(arr) = val {
            return Ok(arr);
        } else {
            return Err(StepFlowParseError::WrongType { key: key.to_owned(), expected: "Array".to_owned() });
        }
    } else {
        return Err(StepFlowParseError::MissingValue(key.to_owned()));
    }
}


pub fn jsonval_obj_get_vec_str<'a>(jsonobj: &'a HashMap<String, JsonValue>, key: &str)
        -> Result<Vec<&'a String>, StepFlowParseError>
{
    jsonval_obj_get_vec(jsonobj, key)
        .and_then(|v| v.iter().map(|val| jsonval_get_str(val, key)).collect())
}

#[cfg(test)]
mod tests {
    use tinyjson::JsonValue;
    use super::jsonval_get_u64;

    #[test]
    fn u64_from_val() {
        let tests = vec![
            (JsonValue::Number(5.0), Some(5)),
            (JsonValue::Number(5.5), None),
            (JsonValue::Number(0.0), Some(0)),
            (JsonValue::Number(-1.0), None),
            (JsonValue::Number(u64::MAX as f64), Some(u64::MAX)),
            (JsonValue::Number(f64::MAX), None),
            (JsonValue::String("hi".to_owned()), None),
        ];
        for test in tests {
            let result = jsonval_get_u64(&test.0, "t");
            if test.1 == None {
                assert!(matches!(result, Err(_)));
            } else {
                assert_eq!(result.unwrap(), test.1.unwrap());
            }
        }
    }
}