json-utils 0.3.5

An utility crate for working with JSON and JSON-schemas
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


use crate::json::JsValue;

use super::CoercionError;

type CoercionResult = Result<JsValue, CoercionError>;

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum Coercion {
    #[serde(rename = "identity")]
    Identity,

    #[serde(rename = "replace_with_literal")]
    ReplaceWithLiteral(JsValue),

    #[serde(rename = "number_to_string")]
    NumberToString,

    #[serde(rename = "array")]
    Array(Box<Coercion>),

    #[serde(rename = "object")]
    Object(Vec<(String, Coercion)>),
}

impl Coercion {
    pub fn coerce(self, value: JsValue) -> CoercionResult {
        match self {
            Coercion::Identity => ok_value(value),
            Coercion::ReplaceWithLiteral(literal_value) => ok_value(literal_value),
            Coercion::NumberToString => number_to_string(self, value),
            Coercion::Array(item_coercion) => array_coercion(item_coercion, value),
            Coercion::Object(prop_coercions) => object_coercion(prop_coercions, value),
        }
    }

    pub fn is_subtyping_only(&self) -> bool {
        match *self {
            Coercion::Identity => true,
            Coercion::NumberToString => false,
            Coercion::ReplaceWithLiteral(_) => false,
            Coercion::Array(ref items) => items.is_subtyping_only(),
            Coercion::Object(ref props) => props.iter().all(|(_, prop)| prop.is_subtyping_only()),
        }
    }
}

fn number_to_string(coercion: Coercion, value: JsValue) -> CoercionResult {
    if let JsValue::Number(js_number) = value {
        js_number
            .as_f64()
            .map(|f| format!("{}", f))
            .map(JsValue::String)
            .ok_or(CoercionError::JsNumberError)
    } else {
        err_unexpectd_input(coercion, value)
    }
}

fn array_coercion(item_coercion: Box<Coercion>, value: JsValue) -> CoercionResult {
    if let JsValue::Array(items) = value {
        let item_coercion = *item_coercion;
        let items = items
            .into_iter()
            .map(move |item| item_coercion.clone().coerce(item))
            .collect::<Result<Vec<_>, _>>()?;
        ok_value(JsValue::Array(items))
    } else {
        err_unexpectd_input(Coercion::Array(item_coercion), value)
    }
}

fn object_coercion(prop_coercions: Vec<(String, Coercion)>, value: JsValue) -> CoercionResult {
    if let JsValue::Object(mut input_props) = value {
        let props_count = prop_coercions.len();
        let mut output_props = Vec::<(String, JsValue)>::with_capacity(props_count);

        for (prop_name, prop_coercion) in prop_coercions {
            let input_prop_value =
                input_props
                    .remove(&prop_name)
                    .ok_or(CoercionError::ObjectFieldsMissing(hashset![
                        prop_name.clone()
                    ]))?;
            let output_prop_value = prop_coercion.coerce(input_prop_value)?;

            output_props.push((prop_name, output_prop_value));
        }

        ok_value(JsValue::Object(output_props.into_iter().collect()))
    } else {
        err_unexpectd_input(Coercion::Object(prop_coercions), value)
    }
}

fn ok_value(js_value: JsValue) -> CoercionResult {
    Ok(js_value)
}

fn err_unexpectd_input(coercion: Coercion, input: JsValue) -> CoercionResult {
    Err(CoercionError::UnexpectedInput { coercion, input })
}