feat: add gix merge tree to merge trees similarly to git merge-tree.

Author: Byron

gitoxide-core/src/repository/merge.rs renamed to gitoxide-core/src/repository/merge/file.rs

@@ -0,0 +1,5 @@
+mod file;
+pub use file::file;
+
+mod tree;
+pub use tree::tree;

gitoxide-core/src/repository/merge/mod.rs

@@ -0,0 +1,74 @@
+use crate::OutputFormat;
+use anyhow::{anyhow, bail, Context};
+use gix::bstr::BString;
+use gix::bstr::ByteSlice;
+use gix::merge::blob::builtin_driver::binary;
+use gix::merge::blob::builtin_driver::text::Conflict;
+use gix::merge::tree::UnresolvedConflict;
+use gix::prelude::Write;
+
+#[allow(clippy::too_many_arguments)]
+pub fn tree(
+    mut repo: gix::Repository,
+    out: &mut dyn std::io::Write,
+    err: &mut dyn std::io::Write,
+    format: OutputFormat,
+    resolve_content_merge: Option<gix::merge::blob::builtin_driver::text::Conflict>,
+    base: BString,
+    ours: BString,
+    theirs: BString,
+) -> anyhow::Result<()> {
+    if format != OutputFormat::Human {
+        bail!("JSON output isn't implemented yet");
+    }
+    repo.object_cache_size_if_unset(repo.compute_object_cache_size_for_tree_diffs(&**repo.index_or_empty()?));
+    let (base_ref, base_id) = refname_and_tree(&repo, base)?;
+    let (ours_ref, ours_id) = refname_and_tree(&repo, ours)?;
+    let (theirs_ref, theirs_id) = refname_and_tree(&repo, theirs)?;
+
+    let mut options = repo.tree_merge_options()?;
+    if let Some(resolve) = resolve_content_merge {
+        options.blob_merge.text.conflict = resolve;
+        options.blob_merge.resolve_binary_with = match resolve {
+            Conflict::Keep { .. } => None,
+            Conflict::ResolveWithOurs => Some(binary::ResolveWith::Ours),
+            Conflict::ResolveWithTheirs => Some(binary::ResolveWith::Theirs),
+            Conflict::ResolveWithUnion => None,
+        };
+    }
+
+    let labels = gix::merge::blob::builtin_driver::text::Labels {
+        ancestor: base_ref.as_ref().map(|n| n.as_bstr()),
+        current: ours_ref.as_ref().map(|n| n.as_bstr()),
+        other: theirs_ref.as_ref().map(|n| n.as_bstr()),
+    };
+    let mut res = repo.merge_trees(base_id, ours_id, theirs_id, labels, options)?;
+    let tree_id = res
+        .tree
+        .write(|tree| repo.objects.write(tree))
+        .map_err(|err| anyhow!("{err}"))?;
+    writeln!(out, "{tree_id}")?;
+
+    if !res.conflicts.is_empty() {
+        writeln!(err, "{} possibly resolved conflicts", res.conflicts.len())?;
+    }
+    if res.has_unresolved_conflicts(UnresolvedConflict::Renames) {
+        bail!("Tree conflicted")
+    }
+    Ok(())
+}
+
+fn refname_and_tree(
+    repo: &gix::Repository,
+    revspec: BString,
+) -> anyhow::Result<(Option<BString>, gix::hash::ObjectId)> {
+    let spec = repo.rev_parse(revspec.as_bstr())?;
+    let tree_id = spec
+        .single()
+        .context("Expected revspec to expand to a single rev only")?
+        .object()?
+        .peel_to_tree()?
+        .id;
+    let refname = spec.first_reference().map(|r| r.name.shorten().as_bstr().to_owned());
+    Ok((refname, tree_id))
+}

gitoxide-core/src/repository/merge/tree.rs

@@ -164,17 +164,32 @@ pub fn main() -> Result<()> {
                         repository(Mode::Lenient)?,
                         out,
                         format,
-                        resolve_with.map(|c| match c {
-                            merge::ResolveWith::Union => {
-                                gix::merge::blob::builtin_driver::text::Conflict::ResolveWithUnion
-                            }
-                            merge::ResolveWith::Ours => {
-                                gix::merge::blob::builtin_driver::text::Conflict::ResolveWithOurs
-                            }
-                            merge::ResolveWith::Theirs => {
-                                gix::merge::blob::builtin_driver::text::Conflict::ResolveWithTheirs
-                            }
-                        }),
+                        resolve_with.map(Into::into),
+                        base,
+                        ours,
+                        theirs,
+                    )
+                },
+            ),
+            merge::SubCommands::Tree {
+                resolve_content_with,
+                ours,
+                base,
+                theirs,
+            } => prepare_and_run(
+                "merge-tree",
+                trace,
+                verbose,
+                progress,
+                progress_keep_open,
+                None,
+                move |_progress, out, err| {
+                    core::repository::merge::tree(
+                        repository(Mode::Lenient)?,
+                        out,
+                        err,
+                        format,
+                        resolve_content_with.map(Into::into),
                         base,
                         ours,
                         theirs,

src/plumbing/main.rs

@@ -357,6 +357,16 @@ pub mod merge {
         Theirs,
     }
 
+    impl From<ResolveWith> for gix::merge::blob::builtin_driver::text::Conflict {
+        fn from(value: ResolveWith) -> Self {
+            match value {
+                ResolveWith::Union => gix::merge::blob::builtin_driver::text::Conflict::ResolveWithUnion,
+                ResolveWith::Ours => gix::merge::blob::builtin_driver::text::Conflict::ResolveWithOurs,
+                ResolveWith::Theirs => gix::merge::blob::builtin_driver::text::Conflict::ResolveWithTheirs,
+            }
+        }
+    }
+
     #[derive(Debug, clap::Parser)]
     #[command(about = "perform merges of various kinds")]
     pub struct Platform {
@@ -382,6 +392,23 @@ pub mod merge {
             #[clap(value_name = "OURS", value_parser = crate::shared::AsBString)]
             theirs: BString,
         },
+
+        /// Merge a tree by specifying ours, base and theirs, writing it to the object database.
+        Tree {
+            /// Decide how to resolve content conflicts. If unset, write conflict markers and fail.
+            #[clap(long, short = 'c')]
+            resolve_content_with: Option<ResolveWith>,
+
+            /// A revspec to our treeish.
+            #[clap(value_name = "OURS", value_parser = crate::shared::AsBString)]
+            ours: BString,
+            /// A revspec to the base as treeish for both ours and theirs.
+            #[clap(value_name = "BASE", value_parser = crate::shared::AsBString)]
+            base: BString,
+            /// A revspec to their treeish.
+            #[clap(value_name = "OURS", value_parser = crate::shared::AsBString)]
+            theirs: BString,
+        },
     }
 }