feat: Repository::merge_files() to trigger blob-merge directly.

Author: Byron

Cargo.lock

@@ -64,7 +64,8 @@ extras = [
     "credentials",
     "interrupt",
     "status",
-    "dirwalk"
+    "dirwalk",
+    "blob-merge"
 ]
 
 ## A collection of features that need a larger MSRV, and thus are disabled by default.
@@ -137,6 +138,9 @@ revparse-regex = ["regex", "revision"]
 ## which relies on line-by-line diffs in some cases.
 blob-diff = ["gix-diff/blob", "attributes"]
 
+## Add functions to specifically merge files, using the standard three-way merge that git offers.
+blob-merge = ["dep:gix-merge", "gix-merge/blob", "attributes"]
+
 ## Make it possible to turn a tree into a stream of bytes, which can be decoded to entries and turned into various other formats.
 worktree-stream = ["gix-worktree-stream", "attributes"]
 
@@ -337,6 +341,7 @@ gix-path = { version = "^0.10.11", path = "../gix-path" }
 gix-url = { version = "^0.27.5", path = "../gix-url" }
 gix-traverse = { version = "^0.41.0", path = "../gix-traverse" }
 gix-diff = { version = "^0.46.0", path = "../gix-diff", default-features = false }
+gix-merge = { version = "^0.0.0", path = "../gix-merge", default-features = false, optional = true }
 gix-mailmap = { version = "^0.24.0", path = "../gix-mailmap", optional = true }
 gix-features = { version = "^0.38.2", path = "../gix-features", features = [
     "progress",

gix/Cargo.toml

@@ -100,6 +100,51 @@ impl Cache {
         Ok(out)
     }
 
+    #[cfg(feature = "blob-merge")]
+    pub(crate) fn merge_drivers(&self) -> Result<Vec<gix_merge::blob::Driver>, config::merge::drivers::Error> {
+        let mut out = Vec::<gix_merge::blob::Driver>::new();
+        for section in self
+            .resolved
+            .sections_by_name("merge")
+            .into_iter()
+            .flatten()
+            .filter(|s| (self.filter_config_section)(s.meta()))
+        {
+            let Some(name) = section.header().subsection_name().filter(|n| !n.is_empty()) else {
+                continue;
+            };
+
+            let driver = match out.iter_mut().find(|d| d.name == name) {
+                Some(existing) => existing,
+                None => {
+                    out.push(gix_merge::blob::Driver {
+                        name: name.into(),
+                        display_name: name.into(),
+                        ..Default::default()
+                    });
+                    out.last_mut().expect("just pushed")
+                }
+            };
+
+            if let Some(command) = section.value(config::tree::Merge::DRIVER_COMMAND.name) {
+                driver.command = command.into_owned().into();
+            }
+            if let Some(recursive_name) = section.value(config::tree::Merge::DRIVER_RECURSIVE.name) {
+                driver.recursive = Some(recursive_name.into_owned().into());
+            }
+        }
+        Ok(out)
+    }
+
+    #[cfg(feature = "blob-merge")]
+    pub(crate) fn merge_pipeline_options(
+        &self,
+    ) -> Result<gix_merge::blob::pipeline::Options, config::merge::pipeline_options::Error> {
+        Ok(gix_merge::blob::pipeline::Options {
+            large_file_threshold_bytes: self.big_file_threshold()?,
+        })
+    }
+
     #[cfg(feature = "blob-diff")]
     pub(crate) fn diff_pipeline_options(
         &self,

gix/src/config/cache/access.rs

@@ -109,6 +109,31 @@ pub enum Error {
     },
 }
 
+///
+pub mod merge {
+    ///
+    pub mod pipeline_options {
+        /// The error produced when obtaining options needed to fill in [gix_merge::blob::pipeline::Options].
+        #[derive(Debug, thiserror::Error)]
+        #[allow(missing_docs)]
+        pub enum Error {
+            #[error(transparent)]
+            BigFileThreshold(#[from] crate::config::unsigned_integer::Error),
+        }
+    }
+
+    ///
+    pub mod drivers {
+        /// The error produced when obtaining a list of [Drivers](gix_merge::blob::Driver).
+        #[derive(Debug, thiserror::Error)]
+        #[allow(missing_docs)]
+        pub enum Error {
+            #[error(transparent)]
+            ConfigBoolean(#[from] crate::config::boolean::Error),
+        }
+    }
+}
+
 ///
 pub mod diff {
     ///

gix/src/config/mod.rs

@@ -29,6 +29,7 @@ impl Section for Merge {
     fn keys(&self) -> &[&dyn Key] {
         &[
             &Self::RENORMALIZE,
+            &Self::DEFAULT,
             &Self::DRIVER_NAME,
             &Self::DRIVER_COMMAND,
             &Self::DRIVER_RECURSIVE,

gix/src/config/tree/sections/merge.rs

@@ -0,0 +1,57 @@
+use crate::config::cache::util::ApplyLeniencyDefault;
+use crate::config::tree;
+use crate::repository::merge_resource_cache;
+use crate::Repository;
+
+/// Diff-utilities
+impl Repository {
+    /// Create a resource cache that can hold the three resources needed for a three-way merge. `worktree_roots`
+    /// determines which side of the merge is read from the worktree, or from which worktree.
+    ///
+    /// The platform can be used to setup resources and finally perform a merge.
+    pub fn merge_resource_cache(
+        &self,
+        worktree_roots: gix_merge::blob::pipeline::WorktreeRoots,
+    ) -> Result<gix_merge::blob::Platform, merge_resource_cache::Error> {
+        let index = self.index_or_load_from_head()?;
+        let mode = {
+            let renormalize = self
+                .config
+                .resolved
+                .boolean(&tree::Merge::RENORMALIZE)
+                .map(|res| {
+                    tree::Merge::RENORMALIZE
+                        .enrich_error(res)
+                        .with_lenient_default(self.config.lenient_config)
+                })
+                .transpose()?
+                .unwrap_or_default();
+            if renormalize {
+                gix_merge::blob::pipeline::Mode::Renormalize
+            } else {
+                gix_merge::blob::pipeline::Mode::ToGit
+            }
+        };
+        let attrs = self
+            .attributes_only(
+                &index,
+                if worktree_roots.is_unset() {
+                    gix_worktree::stack::state::attributes::Source::IdMapping
+                } else {
+                    gix_worktree::stack::state::attributes::Source::WorktreeThenIdMapping
+                },
+            )?
+            .inner;
+        let filter = gix_filter::Pipeline::new(self.command_context()?, crate::filter::Pipeline::options(self)?);
+        let filter = gix_merge::blob::Pipeline::new(worktree_roots, filter, self.config.merge_pipeline_options()?);
+        let options = gix_merge::blob::platform::Options {
+            default_driver: self
+                .config
+                .resolved
+                .string(&tree::Merge::DEFAULT)
+                .map(|name| name.into_owned()),
+        };
+        let drivers = self.config.merge_drivers()?;
+        Ok(gix_merge::blob::Platform::new(filter, mode, attrs, drivers, options))
+    }
+}

gix/src/repository/merge.rs

@@ -42,6 +42,9 @@ mod kind;
 mod location;
 #[cfg(feature = "mailmap")]
 mod mailmap;
+///
+#[cfg(feature = "blob-merge")]
+mod merge;
 mod object;
 #[cfg(feature = "attributes")]
 mod pathspec;
@@ -55,6 +58,30 @@ mod submodule;
 mod thread_safe;
 mod worktree;
 
+///
+#[cfg(feature = "blob-merge")]
+pub mod merge_resource_cache {
+    /// The error returned by [Repository::merge_resource_cache()](crate::Repository::merge_resource_cache()).
+    #[derive(Debug, thiserror::Error)]
+    #[allow(missing_docs)]
+    pub enum Error {
+        #[error(transparent)]
+        RenormalizeConfig(#[from] crate::config::boolean::Error),
+        #[error(transparent)]
+        PipelineOptions(#[from] crate::config::merge::pipeline_options::Error),
+        #[error(transparent)]
+        Index(#[from] crate::repository::index_or_load_from_head::Error),
+        #[error(transparent)]
+        AttributeStack(#[from] crate::config::attribute_stack::Error),
+        #[error(transparent)]
+        CommandContext(#[from] crate::config::command_context::Error),
+        #[error(transparent)]
+        FilterPipeline(#[from] crate::filter::pipeline::options::Error),
+        #[error(transparent)]
+        DriversConfig(#[from] crate::config::merge::drivers::Error),
+    }
+}
+
 ///
 #[cfg(feature = "tree-editor")]
 pub mod edit_tree {