Ability to merge any list of values that implement Eq + Hash

This makes this crate useful to apply 3-way merges on arbitrary data

Author: daladim

src/lib.rs

@@ -221,5 +221,5 @@ mod utils;
 
 pub use apply::{apply, apply_bytes, ApplyError};
 pub use diff::{create_patch, create_patch_bytes, DiffOptions};
-pub use merge::{merge, merge_bytes, ConflictStyle, MergeOptions};
+pub use merge::{merge, merge_bytes, merge_custom, ConflictStyle, MergeOptions, MergeConflicts};
 pub use patch::{Hunk, HunkRange, Line, ParsePatchError, Patch, PatchFormatter};

src/merge/mod.rs

@@ -4,6 +4,7 @@ use crate::{
     utils::Classifier,
 };
 use std::{cmp, fmt};
+use std::hash::Hash;
 
 #[cfg(test)]
 mod tests;
@@ -205,6 +206,34 @@ impl MergeOptions {
             self.style,
         )
     }
+
+    pub fn merge_custom<'a, T: Eq + Hash>(
+        &self,
+        ancestor: &'a [T],
+        ours: &'a [T],
+        theirs: &'a [T],
+    ) -> Result<Vec<&'a T>, MergeConflicts> {
+        let mut classifier = Classifier::default();
+        let (ancestor_lines, ancestor_ids) = classifier.classify(ancestor);
+        let (our_lines, our_ids) = classifier.classify(ours);
+        let (their_lines, their_ids) = classifier.classify(theirs);
+
+        let opts = DiffOptions::default();
+        let our_solution = opts.diff_slice(&ancestor_ids, &our_ids);
+        let their_solution = opts.diff_slice(&ancestor_ids, &their_ids);
+
+        let merged = merge_solutions(&our_solution, &their_solution);
+        let mut merge = diff3_range_to_merge_range(&merged);
+
+        cleanup_conflicts(&mut merge);
+
+        output_result_custom(
+            &ancestor_lines,
+            &our_lines,
+            &their_lines,
+            &merge,
+        )
+    }
 }
 
 impl Default for MergeOptions {
@@ -277,6 +306,30 @@ pub fn merge_bytes<'a>(
     MergeOptions::default().merge_bytes(ancestor, ours, theirs)
 }
 
+/// Infos about a merge that went wrong
+#[derive(Debug, Ord, PartialOrd, Eq, PartialEq)]
+pub struct MergeConflicts {
+    /// How many conflicts have occurred
+    pub count: usize
+}
+
+impl std::fmt::Display for MergeConflicts {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
+        write!(f, "{} merge conflicts", self.count)
+    }
+}
+
+impl std::error::Error for MergeConflicts {}
+
+/// Perform a 3-way merge between any list of values that support it
+pub fn merge_custom<'a, T: Eq + Hash>(
+    ancestor: &'a [T],
+    ours: &'a [T],
+    theirs: &'a [T],
+) -> Result<Vec<&'a T>, MergeConflicts> {
+    MergeOptions::default().merge_custom(ancestor, ours, theirs)
+}
+
 fn merge_solutions<'ancestor, 'ours, 'theirs, T: ?Sized + SliceLike>(
     our_solution: &[DiffRange<'ancestor, 'ours, T>],
     their_solution: &[DiffRange<'ancestor, 'theirs, T>],
@@ -631,3 +684,39 @@ fn add_conflict_marker_bytes(
     }
     output.push(b'\n');
 }
+
+fn output_result_custom<'a, T: Eq + Hash>(
+    ancestor: &[&'a T],
+    ours: &[&'a T],
+    theirs: &[&'a T],
+    merge: &[MergeRange<[u64]>],
+) -> Result<Vec<&'a T>, MergeConflicts> {
+    let mut conflicts = 0;
+    let mut output = Vec::new();
+
+    for merge_range in merge {
+        match merge_range {
+            MergeRange::Equal(range, ..) => {
+                output.extend(ancestor[range.range()].iter().copied());
+            }
+            MergeRange::Conflict(_ancestor_range, _ours_range, _theirs_range) => {
+                conflicts += 1;
+            }
+            MergeRange::Ours(range) => {
+                output.extend(ours[range.range()].iter().copied());
+            }
+            MergeRange::Theirs(range) => {
+                output.extend(theirs[range.range()].iter().copied());
+            }
+            MergeRange::Both(range, _) => {
+                output.extend(ours[range.range()].iter().copied());
+            }
+        }
+    }
+
+    if conflicts != 0 {
+        Err(MergeConflicts { count: conflicts })
+    } else {
+        Ok(output)
+    }
+}

src/merge/tests.rs

@@ -215,6 +215,18 @@ salt
     );
 }
 
+#[test]
+fn test_merge_arbitrary_type() {
+    let original = [1,2,3,4,5,    6];
+    let ours =     [1,2,3,4,5,100,6];
+    let theirs =   [1,  3,4,5,    6];
+    let expected = [1,  3,4,5,100,6];
+
+    let result = merge_custom(&original, &ours, &theirs).unwrap();
+    let result_owned: Vec<i32> = result.iter().map(|r| **r).collect();
+    assert_eq!(result_owned, expected);
+}
+
 #[test]
 fn myers_diffy_vs_git() {
     let original = "\

src/utils.rs

@@ -32,6 +32,14 @@ impl<'a, T: ?Sized + Text> Classifier<'a, T> {
     }
 }
 
+impl<'a, T: Eq + Hash> Classifier<'a, T> {
+    pub fn classify(&mut self, data: &'a [T]) -> (Vec<&'a T>, Vec<u64>) {
+        data.iter()
+            .map(|item| (item, self.classify_item(item)))
+            .unzip()
+    }
+}
+
 impl<T: Eq + Hash + ?Sized> Default for Classifier<'_, T> {
     fn default() -> Self {
         Self {
@@ -230,6 +238,14 @@ fn find_byte(haystack: &[u8], byte: u8) -> Option<usize> {
 mod test {
     use super::Classifier;
 
+    #[test]
+    fn classify() {
+        let input = vec![10, 11, 12, 13];
+        let mut classifier = Classifier::default();
+        let (lines, _ids) = classifier.classify(&input);
+        assert_eq!(lines, vec![&10, &11, &12, &13]);
+    }
+
     #[test]
     fn classify_string() {
         let input = "abc\ndef";