name-rev: favor describing with tags and use committer date to tiebreak

"git name-rev" assigned a phony "far in the future" date to tips of
refs that are not pointing at tag objects, and favored names based
on a ref with the oldest date.  This made it almost impossible for
an unannotated tags and branches to be counted as a viable base,
which was especially problematic when the command is run with the
"--tags" option.  If an unannotated tag that points at an ancient
commit and an annotated tag that points at a much newer commit
reaches the commit that is being named, the old unannotated tag was
ignored.

Update the "taggerdate" field of the rev-name structure, which is
initialized from the tip of ref, to have the committer date if the
object at the tip of ref is a commit, not a tag, so that we can
optionally take it into account when doing "is this name better?"
comparison logic.

When "name-rev" is run without the "--tags" option, the general
expectation is still to name the commit based on a tag if possible,
but use non-tag refs as fallback, and tiebreak among these non-tag
refs by favoring names with shorter hops from the tip.  The use of a
phony "far in the future" date in the original code was an effective
way to ensure this expectation is held: a non-tag tip gets the same
"far in the future" timestamp, giving precedence to tags, and among
non-tag tips, names with shorter hops are preferred over longer
hops, without taking the "taggerdate" into account.  As we are
taking over the "taggerdate" field to store the committer date for
tips with commits:

(1) keep the original logic when comparing names based on two refs
both of which are from refs/tags/;

(2) favoring a name based on a ref in refs/tags/ hierarchy over
a ref outside the hierarchy;

(3) between two names based on a ref both outside refs/tags/, give
precedence to a name with shorter hops and use "taggerdate"
only to tie-break.

A change to t4202 is a natural consequence.  The test creates a
commit on a branch "side" and points at it with an unannotated tag
"refs/tags/side-2".  The original code couldn't decide which one to
favor at all, and gave a name based on a branch (simply because
refs/heads/side sorts earlier than refs/tags/side-2).  Because the
updated logic is taught to favor refs in refs/tags/ hierarchy, the
the test is updated to expect to see tags/side-2 instead.

[mjg: open-coded the comparisons in is_better_name(), dropping a
helper macro used in the original]

Signed-off-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Michael J Gruber <git@grubix.eu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/builtin/name-rev.c b/builtin/name-rev.c
index 7890f826ce7f061d31e0009660d01da18e5f83db..bf7ed015aebc07d2dd410745786fec269c28091f 100644 (file)
--- a/builtin/name-rev.c
+++ b/builtin/name-rev.c
@@ -13,6 +13,7 @@ typedef struct rev_name {
        unsigned long taggerdate;
        int generation;
        int distance;
        unsigned long taggerdate;
        int generation;
        int distance;

+       int from_tag;

 } rev_name;
 
 static long cutoff = LONG_MAX;
 } rev_name;
 
 static long cutoff = LONG_MAX;


@@ -24,16 +25,43 @@ static int is_better_name(struct rev_name *name,
                          const char *tip_name,
                          unsigned long taggerdate,
                          int generation,
                          const char *tip_name,
                          unsigned long taggerdate,
                          int generation,

-                         int distance)
+                         int distance,
+                         int from_tag)

 {
 {

-       return (name->taggerdate > taggerdate ||
-               (name->taggerdate == taggerdate &&
-                name->distance > distance));
+       /*
+        * When comparing names based on tags, prefer names
+        * based on the older tag, even if it is farther away.
+        */
+       if (from_tag && name->from_tag)
+               return (name->taggerdate > taggerdate ||
+                       (name->taggerdate == taggerdate &&
+                        name->distance > distance));
+
+       /*
+        * We know that at least one of them is a non-tag at this point.
+        * favor a tag over a non-tag.
+        */
+       if (name->from_tag != from_tag)
+               return from_tag;
+
+       /*
+        * We are now looking at two non-tags.  Tiebreak to favor
+        * shorter hops.
+        */
+       if (name->distance != distance)
+               return name->distance > distance;
+
+       /* ... or tiebreak to favor older date */
+       if (name->taggerdate != taggerdate)
+               return name->taggerdate > taggerdate;
+
+       /* keep the current one if we cannot decide */
+       return 0;

 }
 
 static void name_rev(struct commit *commit,
                const char *tip_name, unsigned long taggerdate,
 }
 
 static void name_rev(struct commit *commit,
                const char *tip_name, unsigned long taggerdate,

-               int generation, int distance,
+               int generation, int distance, int from_tag,

                int deref)
 {
        struct rev_name *name = (struct rev_name *)commit->util;
                int deref)
 {
        struct rev_name *name = (struct rev_name *)commit->util;


@@ -57,12 +85,13 @@ static void name_rev(struct commit *commit,
                commit->util = name;
                goto copy_data;
        } else if (is_better_name(name, tip_name, taggerdate,
                commit->util = name;
                goto copy_data;
        } else if (is_better_name(name, tip_name, taggerdate,

-                                 generation, distance)) {
+                                 generation, distance, from_tag)) {

 copy_data:
                name->tip_name = tip_name;
                name->taggerdate = taggerdate;
                name->generation = generation;
                name->distance = distance;
 copy_data:
                name->tip_name = tip_name;
                name->taggerdate = taggerdate;
                name->generation = generation;
                name->distance = distance;

+               name->from_tag = from_tag;

        } else
                return;
 
        } else
                return;
 


@@ -82,10 +111,12 @@ static void name_rev(struct commit *commit,
                                                   parent_number);
 
                        name_rev(parents->item, new_name, taggerdate, 0,
                                                   parent_number);
 
                        name_rev(parents->item, new_name, taggerdate, 0,

-                               distance + MERGE_TRAVERSAL_WEIGHT, 0);
+                                distance + MERGE_TRAVERSAL_WEIGHT,
+                                from_tag, 0);

                } else {
                        name_rev(parents->item, tip_name, taggerdate,
                } else {
                        name_rev(parents->item, tip_name, taggerdate,

-                               generation + 1, distance + 1, 0);
+                                generation + 1, distance + 1,
+                                from_tag, 0);

                }
        }
 }
                }
        }
 }


@@ -216,9 +247,13 @@ static int name_ref(const char *path, const struct object_id *oid, int flags, vo
        }
        if (o && o->type == OBJ_COMMIT) {
                struct commit *commit = (struct commit *)o;
        }
        if (o && o->type == OBJ_COMMIT) {
                struct commit *commit = (struct commit *)o;

+               int from_tag = starts_with(path, "refs/tags/");

 
 

+               if (taggerdate == ULONG_MAX)
+                       taggerdate = ((struct commit *)o)->date;

                path = name_ref_abbrev(path, can_abbreviate_output);
                path = name_ref_abbrev(path, can_abbreviate_output);

-               name_rev(commit, xstrdup(path), taggerdate, 0, 0, deref);
+               name_rev(commit, xstrdup(path), taggerdate, 0, 0,
+                        from_tag, deref);

        }
        return 0;
 }
        }
        return 0;
 }

diff --git a/t/t4202-log.sh b/t/t4202-log.sh
index 48b55bfd274a7adffe18af13489a54a7d92707a4..038911f2304ac056c74af75a991224a9f54fa08e 100755 (executable)
--- a/t/t4202-log.sh
+++ b/t/t4202-log.sh
@@ -398,7 +398,7 @@ cat > expect <<\EOF
 | |
 | |     Merge branch 'side'
 | |
 | |
 | |     Merge branch 'side'
 | |

-| * commit side
+| * commit tags/side-2

 | | Author: A U Thor <author@example.com>
 | |
 | |     side-2
 | | Author: A U Thor <author@example.com>
 | |
 | |     side-2