1 files changed, 89 insertions, 0 deletions
diff --git a/alacritty/src/config/serde_utils.rs b/alacritty/src/config/serde_utils.rs
new file mode 100644
index 00000000..ecf1c858
--- /dev/null
+++ b/alacritty/src/config/serde_utils.rs
@@ -0,0 +1,89 @@
+//! 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,
+    }
+}
+
+/// 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);
+    }
+
+    #[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);
+    }
+}