jsonld-expandable-core 0.23.0

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

//! `JsonValue` impl for [`jstrict::Value`].

use crate::JsonValue;
use jstrict::{Object, Value, object::Key};

impl JsonValue for Value {
    #[inline]
    fn null() -> Self {
        Value::Null
    }
    #[inline]
    fn bool(b: bool) -> Self {
        Value::Boolean(b)
    }
    #[inline]
    fn integer(n: i64) -> Self {
        Value::Number(n.into())
    }
    #[inline]
    fn unsigned(n: u64) -> Self {
        Value::Number(n.into())
    }
    #[inline]
    fn float(n: f64) -> Self {
        match jstrict::NumberBuf::try_from(n) {
            Ok(buf) => Value::Number(buf),
            Err(_) => Value::Null,
        }
    }
    #[inline]
    fn string(s: &str) -> Self {
        Value::String(jstrict::String::from(s))
    }
    #[inline]
    fn from_string(s: String) -> Self {
        Value::String(jstrict::String::from(s.as_str()))
    }
    #[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 obj = Object::new();
        for (k, v) in entries {
            // `insert`, not `push`: duplicate keys must collapse (last wins)
            // exactly like the serde_json and sonic-rs backends, so `flatten`
            // collisions produce the same document on every backend.
            obj.insert(Key::from(k.as_str()), v);
        }
        Value::Object(obj)
    }
    #[inline]
    fn into_object_entries(self) -> Option<Vec<(String, Self)>> {
        let obj = self.into_object()?;
        Some(obj.into_iter().map(|entry| (entry.key.as_str().to_owned(), entry.value)).collect())
    }
}

#[cfg(test)]
#[allow(clippy::expect_used)]
mod tests {
    use crate::JsonValue;
    use jstrict::Value;

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

    #[test]
    fn non_finite_floats_become_null() {
        assert!(Value::float(f64::NAN).is_null());
        assert!(Value::float(f64::INFINITY).is_null());
        assert!(!Value::float(1.5).is_null());
    }

    #[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());
    }

    #[test]
    fn object_entries_round_trip_in_order() {
        let v = Value::object([("b".to_string(), Value::bool(true)), ("a".to_string(), Value::unsigned(7))]);
        let entries = v.into_object_entries().expect("object");
        assert_eq!(entries, vec![("b".to_string(), Value::bool(true)), ("a".to_string(), Value::unsigned(7))]);
    }
}