Add first baseline tests for merge-base support

Translate first tests from the Git test suite and set up expectations.

Author: Byron

Cargo.lock

@@ -15,11 +15,14 @@ rust-version = "1.65"
 doctest = false
 
 [features]
-default = ["describe"]
+default = ["describe", "merge_base"]
 
 ## `git describe` functionality
 describe = ["dep:gix-trace", "dep:gix-hashtable"]
 
+## `git merge-base` functionality
+merge_base = ["dep:gix-trace", "dep:bitflags"]
+
 ## Data structures implement `serde::Serialize` and `serde::Deserialize`.
 serde = ["dep:serde", "gix-hash/serde", "gix-object/serde"]
 
@@ -29,17 +32,18 @@ gix-object = { version = "^0.44.0", path = "../gix-object" }
 gix-date = { version = "^0.9.0", path = "../gix-date" }
 gix-hashtable = { version = "^0.5.2", path = "../gix-hashtable", optional = true }
 gix-revwalk = { version = "^0.15.0", path = "../gix-revwalk" }
+gix-commitgraph = { version = "0.24.3", path = "../gix-commitgraph" }
 gix-trace = { version = "^0.1.8", path = "../gix-trace", optional = true }
 
 bstr = { version = "1.3.0", default-features = false, features = ["std"] }
+bitflags = { version = "2", optional = true }
 thiserror = "1.0.26"
 serde = { version = "1.0.114", optional = true, default-features = false, features = ["derive"] }
 document-features = { version = "0.2.1", optional = true }
 
 [dev-dependencies]
 gix-odb = { path = "../gix-odb" }
 gix-testtools = { path = "../tests/tools" }
-gix-commitgraph = { path = "../gix-commitgraph" }
 
 [package.metadata.docs.rs]
 all-features = true

gix-revision/Cargo.toml

@@ -13,6 +13,11 @@
 pub mod describe;
 #[cfg(feature = "describe")]
 pub use describe::function::describe;
+///
+#[allow(clippy::empty_docs)]
+#[cfg(feature = "merge_base")]
+pub mod merge_base;
+pub use merge_base::function::merge_base;
 
 ///
 pub mod spec;

gix-revision/src/lib.rs

@@ -0,0 +1,92 @@
+bitflags::bitflags! {
+    /// The flags used in the graph for finding [merge bases](crate::merge_base()).
+    #[derive(Debug, Default, Copy, Clone)]
+    pub struct Flags: u8 {
+        /// The commit belongs to the graph reachable by the first commit
+        const COMMIT1 = 1 << 0;
+        /// The commit belongs to the graph reachable by all other commits.
+        const COMMIT2 = 1 << 1;
+
+        /// Marks the commit as done, it's reachable by both COMMIT1 and COMMIT2.
+        const STALE = 1 << 2;
+        /// The commit was already put ontto the results list.
+        const RESULT = 1 << 3;
+    }
+}
+
+/// The error returned by the [`merge_base()`][function::describe()] function.
+#[derive(Debug, thiserror::Error)]
+#[allow(missing_docs)]
+pub enum Error {
+    #[error("A commit could not be decoded during traversal")]
+    Decode(#[from] gix_object::decode::Error),
+}
+
+pub(crate) mod function {
+    use gix_hash::ObjectId;
+    use std::cmp::Ordering;
+
+    use super::Error;
+    use crate::{merge_base::Flags, Graph, PriorityQueue};
+
+    /// Given a commit at `first` id, traverse the commit `graph` and return all possible merge-base between it and `others`,
+    /// sorted from best to worst. Returns `None` if there is no merge-base as `first` and `others` don't share history.
+    /// If `others` is empty, `Some(first)` is returned.
+    ///
+    /// Note that this function doesn't do any work if `first` is contained in `others`, which is when `first` will be returned
+    /// as only merge-base right away. This is even the case if some commits of `others` are disjoint.
+    pub fn merge_base<'name>(
+        first: ObjectId,
+        others: &[ObjectId],
+        graph: &mut Graph<'_, Flags>,
+    ) -> Result<Option<Vec<ObjectId>>, Error> {
+        let _span = gix_trace::coarse!(
+            "gix_revision::merge_base()",
+            %first,
+            %others,
+        );
+        if others.is_empty() || others.contains(&first) {
+            return Ok(Some(vec![first]));
+        }
+
+        graph.insert(first, Flags::COMMIT1);
+        let mut queue = PriorityQueue::from_iter(Some((GenThenTime::max(), first)));
+        Ok(None)
+    }
+
+    struct GenThenTime {
+        /// Note that the special [`GENERATION_NUMBER_INFINITY`](gix_commitgraph::GENERATION_NUMBER_INFINITY) is used to indicate
+        /// that no commitgraph is avaialble.
+        generation: gix_revwalk::graph::Generation,
+        time: gix_date::SecondsSinceUnixEpoch,
+    }
+
+    impl GenThenTime {
+        fn max() -> Self {
+            Self {
+                generation: gix_commitgraph::GENERATION_NUMBER_INFINITY,
+                time: gix_date::SecondsSinceUnixEpoch::MAX,
+            }
+        }
+    }
+
+    impl Eq for GenThenTime {}
+
+    impl PartialEq<Self> for GenThenTime {
+        fn eq(&self, other: &Self) -> bool {
+            self.cmp(other).is_eq()
+        }
+    }
+
+    impl PartialOrd<Self> for GenThenTime {
+        fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+            self.cmp(&other).into()
+        }
+    }
+
+    impl Ord for GenThenTime {
+        fn cmp(&self, other: &Self) -> Ordering {
+            self.generation.cmp(&other.generation).then(self.time.cmp(&other.time))
+        }
+    }
+}

gix-revision/src/merge_base.rs

@@ -0,0 +1,67 @@
+#!/usr/bin/env bash
+set -eu -o pipefail
+
+git init
+
+EMPTY_TREE=$(git mktree </dev/null)
+set -x
+function mkcommit () {
+  local OFFSET_SECONDS=$1
+  local COMMIT_NAME=$2
+  shift 2
+
+  PARENTS= 
+  for P; do
+    PARENTS="${PARENTS}-p $P "
+  done
+
+  GIT_COMMITTER_DATE="$((400403349 + OFFSET_SECONDS)) +0000"
+  GIT_AUTHOR_DATE=$GIT_COMMITTER_DATE
+  export GIT_COMMITTER_DATE GIT_AUTHOR_DATE
+
+  commit=$(echo $COMMIT_NAME | git commit-tree $EMPTY_TREE ${PARENTS:-})
+
+  git update-ref "refs/tags/$COMMIT_NAME" "$commit"
+  echo $commit
+}
+
+function baseline() {
+  echo "$@"
+  echo $(git rev-parse "$@")
+  git merge-base --all "$@" || :
+  echo
+}
+
+# Merge-bases adapted from Git test suite
+# No merge base
+mkcommit 0 DA
+mkcommit 100 DB
+{
+  echo "just-one-returns-one-in-code"
+  echo $(git rev-parse DA)
+  echo $(git rev-parse DA)
+  echo
+  baseline DA DB
+  baseline DA DA DB
+} > 1_disjoint.baseline
+
+# E---D---C---B---A
+# \"-_         \   \
+#  \  `---------G   \
+#   \                \
+#    F----------------H
+E=$(mkcommit 5 E)
+D=$(mkcommit 4 D $E)
+F=$(mkcommit 6 F $E)
+C=$(mkcommit 3 C $D)
+B=$(mkcommit 2 B $C)
+A=$(mkcommit 1 A $B)
+G=$(mkcommit 7 G $B $E)
+H=$(mkcommit 8 H $A $F)
+
+{
+  baseline G H
+} > 2_a.baseline
+
+git commit-graph write --no-progress --reachable
+git repack -adq

gix-revision/tests/fixtures/generated-archives/make_merge_base_repos.tar

@@ -0,0 +1,80 @@
+mod baseline {
+    use bstr::ByteSlice;
+    use gix_hash::ObjectId;
+    use gix_revision::merge_base;
+    use std::ffi::OsStr;
+    use std::path::{Path, PathBuf};
+
+    #[test]
+    fn validate() -> crate::Result {
+        let root = gix_testtools::scripted_fixture_read_only("make_merge_base_repos.sh")?;
+        let mut count = 0;
+        let odb = gix_odb::at(&root.join(".git/objects"))?;
+        for baseline_path in expectation_paths(&root)? {
+            count += 1;
+            for use_commitgraph in [false, true] {
+                for expected in parse_expectations(&baseline_path)? {
+                    let cache = use_commitgraph
+                        .then(|| gix_commitgraph::Graph::from_info_dir(&odb.store_ref().path().join("info")).unwrap());
+                    let mut graph = gix_revision::Graph::new(&odb, cache);
+
+                    let actual = merge_base(expected.first, &expected.others, &mut graph)?;
+                    assert_eq!(
+                        actual,
+                        expected.bases,
+                        "sample {file:?}:{input}",
+                        file = baseline_path.with_extension("").file_name(),
+                        input = expected.plain_input
+                    );
+                }
+            }
+        }
+        assert_ne!(count, 0, "there must be at least one baseline");
+        Ok(())
+    }
+
+    /// The expectation as produced by Git itself
+    #[derive(Debug)]
+    struct Expectation {
+        plain_input: String,
+        first: ObjectId,
+        others: Vec<ObjectId>,
+        bases: Option<Vec<ObjectId>>,
+    }
+
+    fn parse_expectations(baseline: &Path) -> std::io::Result<Vec<Expectation>> {
+        let lines = std::fs::read(baseline)?;
+        let mut lines = lines.lines();
+        let mut out = Vec::new();
+        while let Some(plain_input) = lines.next() {
+            let plain_input = plain_input.to_str_lossy().into_owned();
+            let mut input = lines
+                .next()
+                .expect("second line is resolved input objects")
+                .split(|b| *b == b' ');
+            let first = ObjectId::from_hex(input.next().expect("at least one object")).unwrap();
+            let others = input.map(|hex_id| ObjectId::from_hex(hex_id).unwrap()).collect();
+            let bases: Vec<_> = lines
+                .by_ref()
+                .take_while(|l| !l.is_empty())
+                .map(|hex_id| ObjectId::from_hex(hex_id).unwrap())
+                .collect();
+            out.push(Expectation {
+                plain_input,
+                first,
+                others,
+                bases: if bases.is_empty() { None } else { Some(bases) },
+            })
+        }
+        Ok(out)
+    }
+
+    fn expectation_paths(root: &Path) -> std::io::Result<Vec<PathBuf>> {
+        let mut out: Vec<_> = std::fs::read_dir(root)?
+            .map(Result::unwrap)
+            .filter_map(|e| (e.path().extension() == Some(OsStr::new("baseline"))).then(|| e.path()))
+            .collect();
+        out.sort();
+        Ok(out)
+    }
+}

gix-revision/tests/fixtures/make_merge_base_repos.sh

@@ -1,7 +1,10 @@
 #[cfg(feature = "describe")]
 mod describe;
+#[cfg(feature = "merge_base")]
+mod merge_base;
 mod spec;
-pub type Result<T = ()> = std::result::Result<T, Box<dyn std::error::Error + 'static>>;
+
+pub use gix_testtools::Result;
 
 fn hex_to_id(hex: &str) -> gix_hash::ObjectId {
     gix_hash::ObjectId::from_hex(hex.as_bytes()).expect("40 bytes hex")