Add baseline tests for tree-merges.

That way, Git can indicate what we need to match.

Author: Byron

Cargo.lock

@@ -15,33 +15,33 @@ 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" }
 
 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,90 @@
+/// 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,
+    },
+}
+
+/// 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};
+
+    /// 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.
+    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>>,
+        blob_merge: &mut crate::blob::Platform,
+        objects: &'a dyn gix_object::FindExt,
+        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_tree_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;
+        }
+
+        Ok(crate::tree(
+            &merge_base_tree_id,
+            &our_commit,
+            &their_commit,
+            labels,
+            objects,
+            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,45 @@
+/// The error returned by [`tree()`](crate::tree()).
+#[derive(Debug, thiserror::Error)]
+#[allow(missing_docs)]
+pub enum 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 {}
+
+pub(super) mod function {
+    use crate::tree::{Error, Options, Outcome};
+
+    /// 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.
+    /// `blob_merge` is a pre-configured platform to merge any content.
+    /// `options` are used to affect how the merge is performed.
+    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: &'a dyn gix_object::FindExt,
+        blob_merge: &mut crate::blob::Platform,
+        options: Options,
+    ) -> Result<Outcome<'a>, Error> {
+        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;