Implement text and binary merge algorithms, also with baseline tests for correctness.

Author: Byron

Cargo.lock

@@ -324,19 +324,23 @@ Check out the [performance discussion][gix-diff-performance] as well.
     * [x] prepare invocation of external diff program
         - [ ] pass meta-info
 * [ ] working with hunks of data
+* [ ] diff-heuristics match Git perfectly
 * [x] API documentation
     * [ ] Examples
 
+[gix-diff-performance]: https://github.com/Byron/gitoxide/discussions/74
+
 ### gix-merge
 
-* [ ] three-way merge analysis of blobs with choice of how to resolve conflicts
+* [x] three-way merge analysis of blobs with choice of how to resolve conflicts
     - [ ] choose how to resolve conflicts on the data-structure
     - [ ] produce a new blob based on data-structure containing possible resolutions
-        - [ ] `merge` style
-        - [ ] `diff3` style
-        - [ ] `zdiff` style
-    
-[gix-diff-performance]: https://github.com/Byron/gitoxide/discussions/74
+        - [x] `merge` style
+        - [x] `diff3` style
+        - [x] `zdiff` style
+* [ ] diff-heuristics match Git perfectly
+* [x] API documentation
+    * [ ] Examples
 
 ### gix-traverse
 

crate-status.md

@@ -39,6 +39,10 @@ serde = { version = "1.0.114", optional = true, default-features = false, featur
 
 document-features = { version = "0.2.0", optional = true }
 
+[dev-dependencies]
+gix-testtools = { path = "../tests/tools" }
+pretty_assertions = "1.4.0"
+
 [package.metadata.docs.rs]
 all-features = true
 features = ["document-features"]

gix-merge/Cargo.toml

@@ -0,0 +1,43 @@
+/// What to do when having to pick a side to resolve a conflict.
+#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub enum ResolveWith {
+    /// Chose the ancestor to resolve a conflict.
+    Ancestor,
+    /// Chose our side to resolve a conflict.
+    Ours,
+    /// Chose their side to resolve a conflict.
+    Theirs,
+}
+
+/// Tell the caller of [`merge()`](function::merge) which side was picked.
+#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub enum Pick {
+    /// Chose the ancestor.
+    Ancestor,
+    /// Chose our side.
+    Ours,
+    /// Chose their side.
+    Theirs,
+}
+
+pub(super) mod function {
+    use crate::blob::builtin_driver::binary::{Pick, ResolveWith};
+    use crate::blob::Resolution;
+
+    /// As this algorithm doesn't look at the actual data, it returns a choice solely based on logic.
+    ///
+    /// It always results in a conflict with `current` being picked unless `on_conflict` is not `None`.
+    pub fn merge(on_conflict: Option<ResolveWith>) -> (Pick, Resolution) {
+        match on_conflict {
+            None => (Pick::Ours, Resolution::Conflict),
+            Some(resolve) => (
+                match resolve {
+                    ResolveWith::Ours => Pick::Ours,
+                    ResolveWith::Theirs => Pick::Theirs,
+                    ResolveWith::Ancestor => Pick::Ancestor,
+                },
+                Resolution::Complete,
+            ),
+        }
+    }
+}

gix-merge/src/blob/builtin_driver.rs

@@ -0,0 +1,30 @@
+use crate::blob::BuiltinDriver;
+
+impl BuiltinDriver {
+    /// Return the name of this instance.
+    pub fn as_str(&self) -> &str {
+        match self {
+            BuiltinDriver::Text => "text",
+            BuiltinDriver::Binary => "binary",
+            BuiltinDriver::Union => "union",
+        }
+    }
+
+    /// Get all available built-in drivers.
+    pub fn all() -> &'static [Self] {
+        &[BuiltinDriver::Text, BuiltinDriver::Binary, BuiltinDriver::Union]
+    }
+
+    /// Try to match one of our variants to `name`, case-sensitive, and return its instance.
+    pub fn by_name(name: &str) -> Option<Self> {
+        Self::all().iter().find(|variant| variant.as_str() == name).copied()
+    }
+}
+
+///
+pub mod binary;
+pub use binary::function::merge as binary;
+
+///
+pub mod text;
+pub use text::function::merge as text;