json_plus 0.1.0

JSON helper functions beyond Serialization & Deserialization
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

use serde_json::map::Entry;
use serde_json::{Map, Value};

/// merges the `patch` Value on top of the `base`.
/// ``` rust
///use json_plus::merge;
///use serde_json::json;
///
///fn main() -> Result<(), Box<dyn std::error::Error>> {
///    let mut base = json!({"key":"old value", "arr":[]});
///    let patch = json!({"key2":"value 2"});
///
///    merge(&mut base, &patch);
///    println!("{}", base);
///    Ok(())
///}
/// ```
#[inline]
pub fn merge(base: &mut Value, patch: &Value) {
    match patch {
        Value::Object(p) => {
            match base {
                Value::Object(b) => {
                    merge_object(b, p);
                }
                _ => {
                    *base = patch.clone();
                }
            };
        }
        _ => {
            *base = patch.clone();
        }
    }
}

fn merge_object(base: &mut Map<String, Value>, patch: &Map<String, Value>) {
    for (k, v) in patch {
        match base.entry(k) {
            Entry::Vacant(e) => {
                e.insert(v.clone());
            }
            Entry::Occupied(mut e) => {
                merge(e.get_mut(), v);
            }
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use serde_json::json;

    #[test]
    fn different_values() {
        assert_eq!(merge_helper(Value::Bool(true), Value::Null), Value::Null);
        assert_eq!(
            merge_helper(Value::Bool(true), Value::Bool(false)),
            Value::Bool(false)
        );
        assert_eq!(
            merge_helper(Value::String("blah".into()), Value::Bool(false)),
            Value::Bool(false)
        );
        assert_eq!(
            merge_helper(json!({"a":"a"}), Value::Bool(false)),
            Value::Bool(false)
        );
        assert_eq!(
            merge_helper(Value::Bool(false), json!({"a":"a"})),
            json!({"a":"a"})
        );
        assert_eq!(
            merge_helper(Value::Null, json!({"a":"a", "b": null})),
            json!({"a":"a", "b": null})
        );
    }

    #[test]
    fn objects() {
        assert_eq!(
            merge_helper(json!({"a":"a"}), json!({"b":"b","c":"c"})),
            json!({"a":"a","b":"b","c":"c"})
        );
        assert_eq!(
            merge_helper(json!({"a":"a"}), json!({"b":"b","a":"c"})),
            json!({"a":"c","b":"b"})
        );
        assert_eq!(
            merge_helper(json!({"a":"a","arr":[1]}), json!({"b":"b","arr":[1,2,3]})),
            json!({"a":"a","b":"b","arr":[1,2,3]})
        );
        assert_eq!(
            merge_helper(
                json!({"a":{"b":{"c":"c"}}}),
                json!({"a":{"b":{"c":"q"},"d":1}})
            ),
            json!({"a":{"b":{"c":"q"},"d":1}})
        );
        assert_eq!(
            merge_helper(
                json!({"M":{"a":1,"b":"foo"},"A":["foo"],"B":true}),
                json!({"M":{"a":1,"b":"bar"},"A":["foo","bar"],"B":false})
            ),
            json!({"M":{"a":1,"b":"bar"},"A":["foo","bar"],"B":false})
        );
    }

    fn merge_helper(mut base: Value, patch: Value) -> Value {
        merge(&mut base, &patch);
        base
    }
}