feat: support for 'generation v2' format for overlow correction in generations.

This leads to greater correctness of generation numbers when dealing with certain kinds of commit-graphs.

Author: Byron

Cargo.lock

@@ -31,6 +31,7 @@ document-features = { version = "0.2.0", optional = true }
 
 [dev-dependencies]
 gix-testtools = { path = "../tests/tools" }
+gix-date = { path = "../gix-date" }
 
 [package.metadata.docs.rs]
 all-features = true

gix-commitgraph/Cargo.toml

@@ -1,25 +1,78 @@
-use gix_commitgraph::Graph;
-
-use crate::{check_common, inspect_refs, make_readonly_repo};
+use crate::{check_common, graph_and_expected, graph_and_expected_named};
 
 #[test]
-fn single_parent() -> crate::Result {
-    let repo_dir = make_readonly_repo("single_parent.sh");
-    let refs = inspect_refs(&repo_dir, &["parent", "child"]);
-    let cg = Graph::from_info_dir(repo_dir.join(".git").join("objects").join("info"))?;
+fn single_parent() {
+    let (cg, refs) = graph_and_expected("single_parent.sh", &["parent", "child"]);
     check_common(&cg, &refs);
 
     assert_eq!(cg.commit_at(refs["parent"].pos()).generation(), 1);
     assert_eq!(cg.commit_at(refs["child"].pos()).generation(), 2);
+}
+
+#[test]
+fn single_commit_huge_dates_generation_v2_also_do_not_allow_huge_dates() {
+    let (cg, refs) = graph_and_expected_named("single_commit_huge_dates.sh", "v2", &["HEAD"]);
+    let info = &refs["HEAD"];
+    let actual = cg.commit_by_id(info.id).expect("present");
+    assert_eq!(
+        actual.committer_timestamp(),
+        1,
+        "overflow happened, can't represent huge dates"
+    );
+    assert_eq!(
+        info.time.seconds, 68719476737,
+        "this is the value we would want to see, but it's not possible in V2 either, as that is just about generations"
+    );
+    assert_eq!(actual.generation(), 1, "generations are fine though");
+}
 
-    Ok(())
+#[test]
+fn single_commit_huge_dates_overflow_v1() {
+    let (cg, refs) = graph_and_expected_named("single_commit_huge_dates.sh", "v1", &["HEAD"]);
+    let info = &refs["HEAD"];
+    let actual = cg.commit_by_id(info.id).expect("present");
+    assert_eq!(actual.committer_timestamp(), 1, "overflow happened");
+    assert_eq!(
+        info.time.seconds, 68719476737,
+        "this is the value we would want to see, but it's not possible in V1"
+    );
+    assert_eq!(actual.generation(), 1, "generations are fine though");
 }
 
 #[test]
-fn octupus_merges() -> crate::Result {
-    let repo_dir = make_readonly_repo("octopus_merges.sh");
-    let refs = inspect_refs(
-        &repo_dir,
+fn single_commit_future_64bit_dates_work() {
+    let (cg, refs) = graph_and_expected_named("single_commit_huge_dates.sh", "max-date", &["HEAD"]);
+    let info = &refs["HEAD"];
+    let actual = cg.commit_by_id(info.id).expect("present");
+    assert_eq!(
+        actual.committer_timestamp(),
+        info.time.seconds,
+        "this is close the the highest representable value in the graph, like year 2500, so we are good for longer than I should care about"
+    );
+    assert_eq!(actual.generation(), 1);
+}
+
+#[test]
+fn generation_numbers_overflow_is_handled() {
+    let names = ["extra", "old-2", "future-2", "old-1", "future-1"];
+    let (cg, mut refs) = graph_and_expected("generation_number_overflow.sh", &names);
+    for (r, expected) in names
+        .iter()
+        .map(|n| refs.remove(n.to_owned()).expect("present"))
+        .zip((1..=5).rev())
+    {
+        assert_eq!(
+            cg.commit_at(r.pos).generation(),
+            expected,
+            "actually, this test seems to have valid generation numbers from the get-go. How to repro the actual issue?"
+        );
+    }
+}
+
+#[test]
+fn octupus_merges() {
+    let (cg, refs) = graph_and_expected(
+        "octopus_merges.sh",
         &[
             "root",
             "parent1",
@@ -30,7 +83,6 @@ fn octupus_merges() -> crate::Result {
             "four_parents",
         ],
     );
-    let cg = Graph::at(repo_dir.join(".git").join("objects").join("info"))?;
     check_common(&cg, &refs);
 
     assert_eq!(cg.commit_at(refs["root"].pos()).generation(), 1);
@@ -40,32 +92,22 @@ fn octupus_merges() -> crate::Result {
     assert_eq!(cg.commit_at(refs["parent4"].pos()).generation(), 2);
     assert_eq!(cg.commit_at(refs["three_parents"].pos()).generation(), 3);
     assert_eq!(cg.commit_at(refs["four_parents"].pos()).generation(), 3);
-
-    Ok(())
 }
 
 #[test]
-fn single_commit() -> crate::Result {
-    let repo_dir = make_readonly_repo("single_commit.sh");
-    let refs = inspect_refs(&repo_dir, &["commit"]);
-    let cg = gix_commitgraph::at(repo_dir.join(".git").join("objects").join("info"))?;
+fn single_commit() {
+    let (cg, refs) = graph_and_expected("single_commit.sh", &["commit"]);
     check_common(&cg, &refs);
 
     assert_eq!(cg.commit_at(refs["commit"].pos()).generation(), 1);
-
-    Ok(())
 }
 
 #[test]
-fn two_parents() -> crate::Result {
-    let repo_dir = make_readonly_repo("two_parents.sh");
-    let refs = inspect_refs(&repo_dir, &["parent1", "parent2", "child"]);
-    let cg = Graph::from_info_dir(repo_dir.join(".git").join("objects").join("info"))?;
+fn two_parents() {
+    let (cg, refs) = graph_and_expected("two_parents.sh", &["parent1", "parent2", "child"]);
     check_common(&cg, &refs);
 
     assert_eq!(cg.commit_at(refs["parent1"].pos()).generation(), 1);
     assert_eq!(cg.commit_at(refs["parent2"].pos()).generation(), 1);
     assert_eq!(cg.commit_at(refs["child"].pos()).generation(), 2);
-
-    Ok(())
 }

gix-commitgraph/tests/access/mod.rs

@@ -8,12 +8,13 @@ use std::{
 };
 
 use gix_commitgraph::{Graph, Position as GraphPosition};
-
-type Result = std::result::Result<(), Box<dyn std::error::Error>>;
+use gix_testtools::scripted_fixture_read_only;
 
 mod access;
 
 pub fn check_common(cg: &Graph, expected: &HashMap<String, RefInfo, impl BuildHasher>) {
+    cg.verify_integrity(|_| Ok::<_, std::convert::Infallible>(()))
+        .expect("graph is valid");
     assert_eq!(
         usize::try_from(cg.num_commits()).expect("an architecture able to hold 32 bits of integer"),
         expected.len()
@@ -39,6 +40,7 @@ pub fn check_common(cg: &Graph, expected: &HashMap<String, RefInfo, impl BuildHa
 
         let commit = cg.commit_at(ref_info.pos());
         assert_eq!(commit.id(), ref_info.id());
+        assert_eq!(commit.committer_timestamp(), ref_info.time.seconds);
         assert_eq!(commit.root_tree_id(), ref_info.root_tree_id());
         assert_eq!(
             commit.parent1().expect("failed to access commit's parent1"),
@@ -59,13 +61,29 @@ pub fn check_common(cg: &Graph, expected: &HashMap<String, RefInfo, impl BuildHa
     );
 }
 
-use gix_testtools::scripted_fixture_read_only;
-pub fn make_readonly_repo(script_path: &str) -> std::path::PathBuf {
-    scripted_fixture_read_only(script_path).expect("script succeeds all the time")
+pub fn graph_and_expected(
+    script_path: &str,
+    refs: &[&'static str],
+) -> (gix_commitgraph::Graph, HashMap<String, RefInfo>) {
+    graph_and_expected_named(script_path, "", refs)
+}
+
+pub fn graph_and_expected_named(
+    script_path: &str,
+    name: &str,
+    refs: &[&'static str],
+) -> (gix_commitgraph::Graph, HashMap<String, RefInfo>) {
+    let repo_dir = scripted_fixture_read_only(script_path)
+        .expect("script succeeds all the time")
+        .join(name);
+    let expected = inspect_refs(&repo_dir, refs);
+    let cg = Graph::from_info_dir(repo_dir.join(".git").join("objects").join("info")).expect("graph present and valid");
+    (cg, expected)
 }
 
 pub struct RefInfo {
     id: gix_hash::ObjectId,
+    pub time: gix_date::Time,
     parent_ids: Vec<gix_hash::ObjectId>,
     pos: GraphPosition,
     root_tree_id: gix_hash::ObjectId,
@@ -89,13 +107,13 @@ impl RefInfo {
     }
 }
 
-pub fn inspect_refs(repo_dir: impl AsRef<Path>, refs: &[&'static str]) -> HashMap<String, RefInfo> {
+fn inspect_refs(repo_dir: impl AsRef<Path>, refs: &[&'static str]) -> HashMap<String, RefInfo> {
     let output = Command::new("git")
         .arg("-C")
         .arg(repo_dir.as_ref())
         .arg("show")
         .arg("--no-patch")
-        .arg("--pretty=format:%S %H %T %P")
+        .arg("--pretty=format:%S %H %T %ct %P")
         .args(refs)
         .arg("--")
         .env_remove("GIT_DIR")
@@ -111,7 +129,8 @@ pub fn inspect_refs(repo_dir: impl AsRef<Path>, refs: &[&'static str]) -> HashMa
                 parts[0].to_string(),
                 gix_hash::ObjectId::from_hex(parts[1].as_bytes()).expect("40 bytes hex"),
                 gix_hash::ObjectId::from_hex(parts[2].as_bytes()).expect("40 bytes hex"),
-                parts[3..]
+                gix_date::Time::new(parts[3].parse().expect("valid stamp"), 0),
+                parts[4..]
                     .iter()
                     .map(|x| gix_hash::ObjectId::from_hex(x.as_bytes()).expect("40 bytes hex"))
                     .collect(),
@@ -132,13 +151,14 @@ pub fn inspect_refs(repo_dir: impl AsRef<Path>, refs: &[&'static str]) -> HashMa
     infos
         .iter()
         .cloned()
-        .map(|(name, id, root_tree_id, parent_ids)| {
+        .map(|(name, id, root_tree_id, time, parent_ids)| {
             (
                 name,
                 RefInfo {
                     id,
                     parent_ids,
                     root_tree_id,
+                    time,
                     pos: get_pos(&id),
                 },
             )

gix-commitgraph/tests/commitgraph.rs

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0e73018aa525514bba10850e1ddd8f7a9d190cd4a1f9faed5d4ab44cc32b78ad
+size 12204

gix-commitgraph/tests/fixtures/generated-archives/generation_number_overflow.tar.xz

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:fdb7b214315cabdf81173aed5530c2030d3d4f5f2888ebc194f6d1268fca685a
-size 11028
+oid sha256:e52a2e28465e3ac6b64cc7d9dac2486a216a9d99175e4ade52f68ff2602ea108
+size 11104

gix-commitgraph/tests/fixtures/generated-archives/octopus_merges.tar.xz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:39cd8603f0e58ff9cf05173f2edcd9446128461bb647d8045e6d73c86205b141
+size 10900

gix-commitgraph/tests/fixtures/generated-archives/single_commit_huge_dates.tar.xz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:466157da5dcaae21d46aa5a1aa09e72e0c545eafae1c4513cfa75ad94115062f
+size 10128

gix-commitgraph/tests/fixtures/generated-archives/single_parent_huge_dates.tar.xz

@@ -0,0 +1,47 @@
+#!/bin/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
+}
+
+tick
+function commit() {
+  local message=${1:?first argument is the commit message}
+  local date=${2:-}
+  local file="$message.t"
+  echo "$1" > "$file"
+  git add -- "$file"
+  if [ -n "$date" ]; then
+    export GIT_COMMITTER_DATE="$date"
+  else
+    tick
+  fi
+  git commit -m "$message"
+  git tag "$message"
+}
+
+# adapted from git/t/t5318 'lower layers have overflow chunk'
+UNIX_EPOCH_ZERO="@0 +0000"
+FUTURE_DATE="@4147483646 +0000"
+
+git init
+git config commitGraph.generationVersion 2
+
+commit future-1 "$FUTURE_DATE"
+commit old-1 "$UNIX_EPOCH_ZERO"
+git commit-graph write --reachable
+commit future-2 "$FUTURE_DATE"
+commit old-2 "$UNIX_EPOCH_ZERO"
+git commit-graph write --reachable --split=no-merge
+commit extra
+git commit-graph write --reachable --split=no-merge
+git commit-graph write --reachable

gix-commitgraph/tests/fixtures/generation_number_overflow.sh

@@ -0,0 +1,20 @@
+#!/bin/bash
+set -eu -o pipefail
+
+function setup_repo() {
+  local version=${1:?need generation version}
+  local time=${2:?timestamp seconds since unix epoch}
+  git init -q
+
+  # one past the max 32bit date git can represent
+  export GIT_COMMITTER_DATE="@${time} +0000"
+  git config commitGraph.generationVersion ${version}
+
+  git commit -q --allow-empty -m c1
+
+  git commit-graph write --no-progress --reachable
+}
+
+(mkdir v1 && cd v1 && setup_repo 1 68719476737) # the year 4000 something (overflows in graph)
+(mkdir v2 && cd v2 && setup_repo 2 68719476737)
+(mkdir max-date && cd max-date && setup_repo 1 17147483646) # the year 2500ish