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
|
//! Serde helpers.
use serde_yaml::mapping::Mapping;
use serde_yaml::Value;
/// Merge two serde structures.
///
/// This will take all values from `replacement` and use `base` whenever a value isn't present in
/// `replacement`.
pub fn merge(base: Value, replacement: Value) -> Value {
match (base, replacement) {
(Value::Sequence(mut base), Value::Sequence(mut replacement)) => {
base.append(&mut replacement);
Value::Sequence(base)
},
(Value::Mapping(base), Value::Mapping(replacement)) => {
Value::Mapping(merge_mapping(base, replacement))
},
(value, Value::Null) => value,
(_, value) => value,
}
}
/// Merge two key/value mappings.
fn merge_mapping(mut base: Mapping, replacement: Mapping) -> Mapping {
for (key, value) in replacement {
let value = match base.remove(&key) {
Some(base_value) => merge(base_value, value),
None => value,
};
base.insert(key, value);
}
base
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn merge_primitive() {
let base = Value::Null;
let replacement = Value::Bool(true);
assert_eq!(merge(base, replacement.clone()), replacement);
let base = Value::Bool(false);
let replacement = Value::Bool(true);
assert_eq!(merge(base, replacement.clone()), replacement);
let base = Value::Number(0.into());
let replacement = Value::Number(1.into());
assert_eq!(merge(base, replacement.clone()), replacement);
let base = Value::String(String::new());
let replacement = Value::String(String::from("test"));
assert_eq!(merge(base, replacement.clone()), replacement);
let base = Value::Mapping(Mapping::new());
let replacement = Value::Null;
assert_eq!(merge(base.clone(), replacement), base);
}
#[test]
fn merge_sequence() {
let base = Value::Sequence(vec![Value::Null]);
let replacement = Value::Sequence(vec![Value::Bool(true)]);
let expected = Value::Sequence(vec![Value::Null, Value::Bool(true)]);
assert_eq!(merge(base, replacement), expected);
}
#[test]
fn merge_mapping() {
let mut base_mapping = Mapping::new();
base_mapping.insert(Value::String(String::from("a")), Value::Bool(true));
base_mapping.insert(Value::String(String::from("b")), Value::Bool(false));
let base = Value::Mapping(base_mapping);
let mut replacement_mapping = Mapping::new();
replacement_mapping.insert(Value::String(String::from("a")), Value::Bool(true));
replacement_mapping.insert(Value::String(String::from("c")), Value::Bool(false));
let replacement = Value::Mapping(replacement_mapping);
let merged = merge(base, replacement);
let mut expected_mapping = Mapping::new();
expected_mapping.insert(Value::String(String::from("b")), Value::Bool(false));
expected_mapping.insert(Value::String(String::from("a")), Value::Bool(true));
expected_mapping.insert(Value::String(String::from("c")), Value::Bool(false));
let expected = Value::Mapping(expected_mapping);
assert_eq!(merged, expected);
}
}
|
