Add baseline tests for tree-merges along with first plain merge.

That way, Git can indicate what we need to match, and we have enough infrastructure to perform
simple merges (seemingly) correctly.

Author: Byron

Cargo.lock

@@ -15,33 +15,34 @@ workspace = true
 doctest = false
 
 [features]
-default = ["blob"]
-## Enable diffing of blobs using imara-diff, which also allows for a generic rewrite tracking implementation.
-blob = ["dep:imara-diff", "dep:gix-filter", "dep:gix-worktree", "dep:gix-path", "dep:gix-fs", "dep:gix-command", "dep:gix-tempfile", "dep:gix-trace", "dep:gix-quote"]
 ## Data structures implement `serde::Serialize` and `serde::Deserialize`.
 serde = ["dep:serde", "gix-hash/serde", "gix-object/serde"]
 
 [dependencies]
 gix-hash = { version = "^0.14.2", path = "../gix-hash" }
 gix-object = { version = "^0.44.0", path = "../gix-object" }
-gix-filter = { version = "^0.13.0", path = "../gix-filter", optional = true }
-gix-worktree = { version = "^0.36.0", path = "../gix-worktree", default-features = false, features = ["attributes"], optional = true }
-gix-command = { version = "^0.3.9", path = "../gix-command", optional = true }
-gix-path = { version = "^0.10.11", path = "../gix-path", optional = true }
-gix-fs = { version = "^0.11.3", path = "../gix-fs", optional = true }
-gix-tempfile = { version = "^14.0.0", path = "../gix-tempfile", optional = true }
-gix-trace = { version = "^0.1.10", path = "../gix-trace", optional = true }
-gix-quote = { version = "^0.4.12", path = "../gix-quote", optional = true }
+gix-filter = { version = "^0.13.0", path = "../gix-filter" }
+gix-worktree = { version = "^0.36.0", path = "../gix-worktree", default-features = false, features = ["attributes"] }
+gix-command = { version = "^0.3.9", path = "../gix-command" }
+gix-path = { version = "^0.10.11", path = "../gix-path" }
+gix-fs = { version = "^0.11.3", path = "../gix-fs" }
+gix-tempfile = { version = "^14.0.0", path = "../gix-tempfile" }
+gix-trace = { version = "^0.1.10", path = "../gix-trace" }
+gix-quote = { version = "^0.4.12", path = "../gix-quote" }
+gix-revision = { version = "^0.29.0", path = "../gix-revision", default-features = false, features = ["merge_base"] }
+gix-revwalk = { version = "^0.15.0", path = "../gix-revwalk" }
+gix-diff = { version = "^0.46.0", path = "../gix-diff", default-features = false, features = ["blob"] }
 
 thiserror = "1.0.63"
-imara-diff = { version = "0.1.7", optional = true }
+imara-diff = { version = "0.1.7" }
 bstr = { version = "1.5.0", default-features = false }
 serde = { version = "1.0.114", optional = true, default-features = false, features = ["derive"] }
 
 document-features = { version = "0.2.0", optional = true }
 
 [dev-dependencies]
 gix-testtools = { path = "../tests/tools" }
+gix-odb = { path = "../gix-odb" }
 pretty_assertions = "1.4.0"
 
 [package.metadata.docs.rs]

gix-merge/Cargo.toml

@@ -0,0 +1,105 @@
+/// The error returned by [`commit()`](crate::commit()).
+#[derive(Debug, thiserror::Error)]
+#[allow(missing_docs)]
+pub enum Error {
+    #[error(transparent)]
+    MergeBase(#[from] gix_revision::merge_base::Error),
+    #[error(transparent)]
+    MergeTree(#[from] crate::tree::Error),
+    #[error("No common ancestor between {our_commit_id} and {their_commit_id}")]
+    NoMergeBase {
+        /// The commit on our side that was to be merged.
+        our_commit_id: gix_hash::ObjectId,
+        /// The commit on their side that was to be merged.
+        their_commit_id: gix_hash::ObjectId,
+    },
+    #[error("Could not find ancestor, our or their commit to extract tree from")]
+    FindCommit(#[from] gix_object::find::existing_object::Error),
+}
+
+/// A way to configure [`commit()`](crate::commit()).
+#[derive(Default, Debug, Copy, Clone)]
+pub struct Options {
+    /// If `true`, merging unrelated commits is allowed, with the merge-base being assumed as empty tree.
+    pub allow_missing_merge_base: bool,
+    /// Options to define how trees should be merged.
+    pub tree_merge: crate::tree::Options,
+    /// Options to define how to merge blobs.
+    ///
+    /// Note that these are temporarily overwritten if multiple merge-bases are merged into one.
+    pub blob_merge: crate::blob::platform::merge::Options,
+}
+
+pub(super) mod function {
+    use crate::commit::{Error, Options};
+    use gix_object::FindExt;
+
+    /// Like [`tree()`](crate::tree()), but it takes only two commits, `our_commit` and `their_commit` to automatically
+    /// compute the merge-bases among them.
+    /// If there are multiple merge bases, these will be auto-merged into one, recursively, if
+    /// [`allow_missing_merge_base`](Options::allow_missing_merge_base) is `true`.
+    ///
+    /// `labels` are names where [`current`](crate::blob::builtin_driver::text::Labels::current) is a name for `our_commit`
+    /// and [`other`](crate::blob::builtin_driver::text::Labels::other) is a name for `their_commit`.
+    /// If [`ancestor`](crate::blob::builtin_driver::text::Labels::ancestor) is unset, it will be set by us based on the
+    /// merge-bases of `our_commit` and `their_commit`.
+    ///
+    /// The `graph` is used to find the merge-base between `our_commit` and `their_commit`, and can also act as cache
+    /// to speed up subsequent merge-base queries.
+    ///
+    /// ### Performance
+    ///
+    /// Note that `objects` *should* have an object cache to greatly accelerate tree-retrieval.
+    pub fn commit<'a>(
+        our_commit: gix_hash::ObjectId,
+        their_commit: gix_hash::ObjectId,
+        mut labels: crate::blob::builtin_driver::text::Labels<'_>,
+        graph: &mut gix_revwalk::Graph<'_, '_, gix_revwalk::graph::Commit<gix_revision::merge_base::Flags>>,
+        diff_resource_cache: &mut gix_diff::blob::Platform,
+        blob_merge: &mut crate::blob::Platform,
+        objects: &impl gix_object::FindObjectOrHeader,
+        options: Options,
+    ) -> Result<crate::tree::Outcome<'a>, Error> {
+        let merge_bases_commit_ids = gix_revision::merge_base(our_commit, &[their_commit], graph)?;
+        let (merge_base_commit_id, ancestor_name) = match merge_bases_commit_ids {
+            Some(base_commit) if base_commit.len() == 1 => (base_commit[0], None),
+            Some(_base_commits) => {
+                todo!("merge multiple bases into one");
+                (our_commit.kind().null(), Some("merged common ancestors".into()))
+            }
+            None => {
+                if options.allow_missing_merge_base {
+                    (
+                        gix_hash::ObjectId::empty_tree(our_commit.kind()),
+                        Some("empty tree".into()),
+                    )
+                } else {
+                    return Err(Error::NoMergeBase {
+                        our_commit_id: our_commit,
+                        their_commit_id: their_commit,
+                    });
+                }
+            }
+        };
+        if labels.ancestor.is_none() {
+            labels.ancestor = ancestor_name;
+        }
+
+        let mut state = gix_diff::tree::State::default();
+        let merge_base_tree_id = objects.find_commit(&merge_base_commit_id, &mut state.buf1)?.tree();
+        let our_tree_id = objects.find_commit(&our_commit, &mut state.buf1)?.tree();
+        let their_tree_id = objects.find_commit(&their_commit, &mut state.buf1)?.tree();
+
+        Ok(crate::tree(
+            &merge_base_tree_id,
+            &our_tree_id,
+            &their_tree_id,
+            labels,
+            objects,
+            &mut state,
+            diff_resource_cache,
+            blob_merge,
+            options.tree_merge,
+        )?)
+    }
+}

gix-merge/src/commit.rs

@@ -2,5 +2,10 @@
 #![forbid(unsafe_code)]
 
 ///
-#[cfg(feature = "blob")]
 pub mod blob;
+///
+pub mod commit;
+pub use commit::function::commit;
+///
+pub mod tree;
+pub use tree::function::tree;

gix-merge/src/lib.rs

@@ -0,0 +1,116 @@
+use gix_diff::Rewrites;
+
+/// The error returned by [`tree()`](crate::tree()).
+#[derive(Debug, thiserror::Error)]
+#[allow(missing_docs)]
+pub enum Error {
+    #[error("Could not find ancestor, our or their tree to get started")]
+    FindTree(#[from] gix_object::find::existing_object::Error),
+    #[error("Could not find ancestor, our or their tree to get started")]
+    FindTree2(#[from] gix_object::find::existing_iter::Error),
+    #[error("Failed to diff our side or their side")]
+    DiffTree(#[from] gix_diff::tree_with_rewrites::Error),
+}
+
+/// The outcome produced by [`tree()`](crate::tree()).
+pub struct Outcome<'a> {
+    /// The ready-made (but unwritten) tree if `conflicts` is empty, or the best-possible tree when facing `conflicts`.
+    ///
+    /// The tree may contain blobs with conflict markers, and will be missing directories or files that were conflicting
+    /// without a resolution strategy.
+    tree: gix_object::tree::Editor<'a>,
+    /// The set of conflicts we encountered. Can be empty to indicate there was no conflict.
+    conflicts: Vec<Conflict>,
+}
+
+/// A description of a conflict (i.e. merge issue without an auto-resolution) as seen during a [tree-merge](crate::tree()).
+pub struct Conflict;
+
+/// A way to configure [`tree()`](crate::tree()).
+#[derive(Default, Debug, Copy, Clone)]
+pub struct Options {
+    /// If not `None`, rename tracking will be performed when determining the changes of each side of the merge.
+    pub rewrites: Option<Rewrites>,
+    // TODO(Perf) add a flag to allow parallelizing the tree-diff itself.
+}
+
+pub(super) mod function {
+    use crate::tree::{Error, Options, Outcome};
+    use gix_diff::tree::recorder::Location;
+    use gix_object::FindExt;
+    use std::convert::Infallible;
+
+    /// Perform a merge between `our_tree` and `their_tree`, using `base_tree` as merge-base.
+    /// Note that `base_tree` can be an empty tree to indicate 'no common ancestor between the two sides'.
+    ///
+    /// `labels` are relevant for text-merges and will be shown in conflicts.
+    /// `objects` provides access to trees when diffing them.
+    /// `diff_state` is state used for diffing trees.
+    /// `diff_resource_cache` is used for similarity checks.
+    /// `blob_merge` is a pre-configured platform to merge any content.
+    /// `options` are used to affect how the merge is performed.
+    ///
+    /// ### Performance
+    ///
+    /// Note that `objects` *should* have an object cache to greatly accelerate tree-retrieval.
+    pub fn tree<'a>(
+        base_tree: &gix_hash::oid,
+        our_tree: &gix_hash::oid,
+        their_tree: &gix_hash::oid,
+        labels: crate::blob::builtin_driver::text::Labels<'_>,
+        objects: &impl gix_object::FindObjectOrHeader,
+        diff_state: &mut gix_diff::tree::State,
+        diff_resource_cache: &mut gix_diff::blob::Platform,
+        blob_merge: &mut crate::blob::Platform,
+        options: Options,
+    ) -> Result<Outcome<'a>, Error> {
+        let (mut base_buf, mut side_buf) = (Vec::new(), Vec::new());
+        let ancestor_tree = objects.find_tree_iter(base_tree, &mut base_buf)?;
+        let our_tree = objects.find_tree_iter(our_tree, &mut side_buf)?;
+
+        let mut our_changes = Vec::new();
+        gix_diff::tree_with_rewrites(
+            ancestor_tree,
+            our_tree,
+            diff_resource_cache,
+            diff_state,
+            objects,
+            |change| -> Result<_, Infallible> {
+                our_changes.push(change.into_owned());
+                Ok(gix_diff::tree_with_rewrites::Action::Continue)
+            },
+            gix_diff::tree_with_rewrites::Options {
+                location: Some(Location::Path),
+                rewrites: options.rewrites,
+            },
+        )?;
+
+        let mut their_changes = Vec::new();
+        let their_tree = objects.find_tree_iter(their_tree, &mut side_buf)?;
+        gix_diff::tree_with_rewrites(
+            ancestor_tree,
+            their_tree,
+            diff_resource_cache,
+            diff_state,
+            objects,
+            |change| -> Result<_, Infallible> {
+                their_changes.push(change.into_owned());
+                Ok(gix_diff::tree_with_rewrites::Action::Continue)
+            },
+            gix_diff::tree_with_rewrites::Options {
+                location: Some(Location::Path),
+                rewrites: options.rewrites,
+            },
+        )?;
+
+        dbg!(&our_changes, &their_changes);
+        let mut editor = gix_object::tree::Editor::new(
+            gix_object::TreeRef::from_bytes(&base_buf)
+                .expect("ancestor was decoded before")
+                .into(),
+            &objects,
+            base_tree.kind(),
+        );
+        todo!()
+    }
+}

gix-merge/src/tree.rs

@@ -0,0 +1,90 @@
+#!/usr/bin/env bash
+set -eu -o pipefail
+
+function tick () {
+  if test -z "${tick+set}"
+  then
+    tick=1112911993
+  else
+    tick=$(($tick + 60))
+  fi
+  GIT_COMMITTER_DATE="$tick -0700"
+  GIT_AUTHOR_DATE="$tick -0700"
+  export GIT_COMMITTER_DATE GIT_AUTHOR_DATE
+}
+
+function write_lines () {
+	printf "%s\n" "$@"
+}
+
+function baseline () (
+  local dir=${1:?the directory to enter}
+  local output_name=${2:?the basename of the output of the merge}
+  local our_committish=${3:?our side from which a commit can be derived}
+  local their_committish=${4:?Their side from which a commit can be derived}
+
+  cd "$dir"
+  local our_commit_id
+  local their_commit_id
+
+  our_commit_id="$(git rev-parse "$our_committish")"
+  their_commit_id="$(git rev-parse "$their_committish")"
+
+  local merge_info="${output_name}.merge-info"
+  git merge-tree -z --write-tree "$our_commit_id" "$their_commit_id" > "$merge_info" || :
+  echo "$dir" "$our_commit_id" "$their_commit_id" "$merge_info" >> ../baseline.cases
+)
+
+git init simple
+(cd simple
+  rm -Rf .git/hooks
+  write_lines 1 2 3 4 5 >numbers
+  echo hello >greeting
+  echo foo >whatever
+  git add numbers greeting whatever
+  tick
+  git commit -m initial
+
+  git branch side1
+  git branch side2
+  git branch side3
+  git branch side4
+
+  git checkout side1
+  write_lines 1 2 3 4 5 6 >numbers
+  echo hi >greeting
+  echo bar >whatever
+  git add numbers greeting whatever
+  tick
+  git commit -m modify-stuff
+
+  git checkout side2
+  write_lines 0 1 2 3 4 5 >numbers
+  echo yo >greeting
+  git rm whatever
+  mkdir whatever
+  >whatever/empty
+  git add numbers greeting whatever/empty
+  tick
+  git commit -m other-modifications
+
+  git checkout side3
+  git mv numbers sequence
+  tick
+  git commit -m rename-numbers
+
+  git checkout side4
+  write_lines 0 1 2 3 4 5 >numbers
+  echo yo >greeting
+  git add numbers greeting
+  tick
+  git commit -m other-content-modifications
+
+  git switch --orphan unrelated
+  >something-else
+  git add something-else
+  tick
+  git commit -m first-commit
+)
+
+baseline simple without-conflict side1 side3

gix-merge/tests/fixtures/generated-archives/tree-baseline.tar

@@ -1,6 +1,6 @@
 extern crate core;
 
-#[cfg(feature = "blob")]
 mod blob;
+mod tree;
 
 pub use gix_testtools::Result;