feat!: Repository::merge_trees() now takes portable version of Options.

Author: Byron

gix/Cargo.toml

@@ -399,7 +399,7 @@ document-features = { version = "0.2.0", optional = true }
 
 [dev-dependencies]
 # For additional features that aren't enabled by default due to MSRV
-gix = { path = ".", default-features = false, features = ["tree-editor"] }
+gix = { path = ".", default-features = false, features = ["need-more-recent-msrv"] }
 pretty_assertions = "1.4.0"
 gix-testtools = { path = "../tests/tools" }
 is_ci = "1.1.1"

gix/src/merge.rs

@@ -4,6 +4,7 @@ pub use gix_merge::blob;
 
 ///
 pub mod tree {
+    use gix_merge::blob::builtin_driver;
     pub use gix_merge::tree::{Conflict, ContentMerge, Resolution, ResolutionFailure, UnresolvedConflict};
 
     /// The outcome produced by [`Repository::merge_trees()`](crate::Repository::merge_trees()).
@@ -31,4 +32,89 @@ pub mod tree {
             self.conflicts.iter().any(|c| c.is_unresolved(how))
         }
     }
+
+    /// A way to configure [`Repository::merge_trees()`](crate::Repository::merge_trees()).
+    #[derive(Default, Debug, Clone)]
+    pub struct Options {
+        inner: gix_merge::tree::Options,
+        file_favor: Option<FileFavor>,
+    }
+
+    impl From<gix_merge::tree::Options> for Options {
+        fn from(opts: gix_merge::tree::Options) -> Self {
+            Options {
+                inner: opts,
+                file_favor: None,
+            }
+        }
+    }
+
+    impl From<Options> for gix_merge::tree::Options {
+        fn from(value: Options) -> Self {
+            let mut opts = value.inner;
+            if let Some(file_favor) = value.file_favor {
+                let (resolve_binary, resolve_text) = match file_favor {
+                    FileFavor::Ours => (
+                        builtin_driver::binary::ResolveWith::Ours,
+                        builtin_driver::text::Conflict::ResolveWithOurs,
+                    ),
+                    FileFavor::Theirs => (
+                        builtin_driver::binary::ResolveWith::Theirs,
+                        builtin_driver::text::Conflict::ResolveWithTheirs,
+                    ),
+                };
+
+                opts.symlink_conflicts = Some(resolve_binary);
+                opts.blob_merge.resolve_binary_with = Some(resolve_binary);
+                opts.blob_merge.text.conflict = resolve_text;
+            }
+            opts
+        }
+    }
+
+    /// Identify how files should be resolved in case of conflicts.
+    ///
+    /// This works for…
+    ///
+    /// * content merges
+    /// * binary files
+    /// * symlinks (a form of file after all)
+    ///
+    /// Note that that union merges aren't available as they aren't available for binaries or symlinks.
+    #[derive(Debug, Copy, Clone)]
+    pub enum FileFavor {
+        /// Choose *our* side in case of a conflict.
+        /// Note that this choice is precise, so *ours* hunk will only be chosen if they conflict with *theirs*,
+        /// so *their* hunks may still show up in the merged result.
+        Ours,
+        /// Choose *their* side in case of a conflict.
+        /// Note that this choice is precise, so *ours* hunk will only be chosen if they conflict with *theirs*,
+        /// so *their* hunks may still show up in the merged result.
+        Theirs,
+    }
+
+    /// Builder
+    impl Options {
+        /// If *not* `None`, rename tracking will be performed when determining the changes of each side of the merge.
+        pub fn with_rewrites(mut self, rewrites: Option<gix_diff::Rewrites>) -> Self {
+            self.inner.rewrites = rewrites;
+            self
+        }
+
+        /// If `Some(what-is-unresolved)`, the first unresolved conflict will cause the entire merge to stop.
+        /// This is useful to see if there is any conflict, without performing the whole operation, something
+        /// that can be very relevant during merges that would cause a lot of blob-diffs.
+        pub fn with_fail_on_conflict(mut self, fail_on_conflict: Option<UnresolvedConflict>) -> Self {
+            self.inner.fail_on_conflict = fail_on_conflict;
+            self
+        }
+
+        /// When `None`, the default, both sides will be treated equally, and in case of conflict an unbiased representation
+        /// is chosen both for content and for trees, causing a conflict.
+        /// When `Some(favor)` one can choose a side to prefer in order to automatically resolve a conflict meaningfully.
+        pub fn with_file_favor(mut self, file_favor: Option<FileFavor>) -> Self {
+            self.file_favor = file_favor;
+            self
+        }
+    }
 }

gix/src/repository/merge.rs

@@ -83,7 +83,7 @@ impl Repository {
     }
 
     /// Read all relevant configuration options to instantiate options for use in [`merge_trees()`](Self::merge_trees).
-    pub fn tree_merge_options(&self) -> Result<gix_merge::tree::Options, tree_merge_options::Error> {
+    pub fn tree_merge_options(&self) -> Result<crate::merge::tree::Options, tree_merge_options::Error> {
         Ok(gix_merge::tree::Options {
             rewrites: crate::diff::utils::new_rewrites_inner(
                 &self.config.resolved,
@@ -97,7 +97,8 @@ impl Repository {
             marker_size_multiplier: 0,
             symlink_conflicts: None,
             allow_lossy_resolution: false,
-        })
+        }
+        .into())
     }
 
     /// Merge `our_tree` and `their_tree` together, assuming they have the same `ancestor_tree`, to yield a new tree
@@ -116,14 +117,13 @@ impl Repository {
     ///
     /// It's highly recommended to [set an object cache](crate::Repository::compute_object_cache_size_for_tree_diffs)
     /// to avoid extracting the same object multiple times.
-    // TODO: Use `crate::merge::Options` here and add niceties such as setting the resolution strategy.
     pub fn merge_trees(
         &self,
         ancestor_tree: impl AsRef<gix_hash::oid>,
         our_tree: impl AsRef<gix_hash::oid>,
         their_tree: impl AsRef<gix_hash::oid>,
         labels: gix_merge::blob::builtin_driver::text::Labels<'_>,
-        options: gix_merge::tree::Options,
+        options: crate::merge::tree::Options,
     ) -> Result<crate::merge::tree::Outcome<'_>, merge_trees::Error> {
         let mut diff_cache = self.diff_resource_cache_for_tree_diff()?;
         let mut blob_merge = self.merge_resource_cache(Default::default())?;
@@ -141,7 +141,7 @@ impl Repository {
             &mut Default::default(),
             &mut diff_cache,
             &mut blob_merge,
-            options,
+            options.into(),
         )?;
 
         let validate = self.config.protect_options()?;