jsonld-expandable-core 0.22.1

Runtime traits, attribute parser, and codegen for the JSON-LD `Expandable` derive
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

//! `JsonValue` impl for [`serde_json::Value`] plus a `ToJsonValue` impl
//! that lets a `serde_json::Value` field be projected into any backend.

use crate::{JsonValue, ToJsonValue};
use serde_json::{Map, Number, Value};

impl JsonValue for Value {
    #[inline]
    fn null() -> Self {
        Value::Null
    }
    #[inline]
    fn bool(b: bool) -> Self {
        Value::Bool(b)
    }
    #[inline]
    fn integer(n: i64) -> Self {
        Value::Number(Number::from(n))
    }
    #[inline]
    fn unsigned(n: u64) -> Self {
        Value::Number(Number::from(n))
    }
    #[inline]
    fn float(n: f64) -> Self {
        Number::from_f64(n).map_or(Value::Null, Value::Number)
    }
    #[inline]
    fn string(s: &str) -> Self {
        Value::String(s.to_owned())
    }
    #[inline]
    fn from_string(s: String) -> Self {
        Value::String(s)
    }
    #[inline]
    fn array<I: IntoIterator<Item = Self>>(items: I) -> Self {
        Value::Array(items.into_iter().collect())
    }
    #[inline]
    fn object<I: IntoIterator<Item = (String, Self)>>(entries: I) -> Self {
        let mut map = Map::new();
        for (k, v) in entries {
            map.insert(k, v);
        }
        Value::Object(map)
    }
    #[inline]
    fn into_object_entries(self) -> Option<Vec<(String, Self)>> {
        match self {
            Value::Object(map) => Some(map.into_iter().collect()),
            _ => None,
        }
    }
}

/// Recursively translate a [`serde_json::Value`] into the chosen `JsonValue`
/// backend. Lets fields whose type is `serde_json::Value` participate in
/// generic expansion without forcing the backend to *be* `serde_json`.
impl<V: JsonValue> ToJsonValue<V> for Value {
    fn to_json_value(&self) -> V {
        match self {
            Value::Null => V::null(),
            Value::Bool(b) => V::bool(*b),
            Value::Number(n) => {
                if let Some(i) = n.as_i64() {
                    V::integer(i)
                } else if let Some(u) = n.as_u64() {
                    V::unsigned(u)
                } else if let Some(f) = n.as_f64() {
                    V::float(f)
                } else {
                    V::null()
                }
            }
            Value::String(s) => V::string(s),
            Value::Array(arr) => V::array(arr.iter().map(ToJsonValue::<V>::to_json_value)),
            Value::Object(map) => V::object(map.iter().map(|(k, v)| (k.clone(), v.to_json_value()))),
        }
    }
}

#[cfg(test)]
#[allow(clippy::expect_used)]
mod tests {
    use crate::JsonValue;
    use serde_json::{Value, json};

    #[test]
    fn duplicate_keys_collapse_last_wins() {
        let v = Value::object([("a".to_string(), Value::integer(1)), ("a".to_string(), Value::integer(2))]);
        assert_eq!(v, json!({"a": 2}));
    }

    #[test]
    fn non_finite_floats_become_null() {
        assert_eq!(Value::float(f64::NAN), Value::Null);
        assert_eq!(Value::float(f64::INFINITY), Value::Null);
        assert_eq!(Value::float(1.5), json!(1.5));
    }

    #[test]
    fn into_object_entries_is_none_for_non_objects() {
        assert!(Value::string("x").into_object_entries().is_none());
        assert!(Value::array([Value::null()]).into_object_entries().is_none());
    }

    #[cfg(feature = "jstrict")]
    #[test]
    fn to_json_value_projects_into_another_backend() {
        use crate::ToJsonValue;
        let source = json!({"a": [1, "x", null], "b": true});
        let projected: jstrict::Value = source.to_json_value();
        let entries = projected.into_object_entries().expect("object");
        assert_eq!(entries.len(), 2);
        assert_eq!(entries[0].0, "a");
    }
}