Re: [PATCH] find_unique_abbrev(): honor caller-supplied "len" better

Junio C Hamano [off-list ref] writes:

So let's scrap the abbrevguard thing.  I somehow thought that I already
took your "make DEFAULT_ABBREV tweakable" patch, but apparently I didn't.
That one is the real fix to the issue of futureproofing.

In return for a free education last night, I now owe you your patch from
October last year, resurrected from the list archive, and here it is.

With a forged sign-off from you, as I know that everything you write is
supposed to be open source.

 - I do not think making minimum configurable is worth it, but I left it in
   (there is no UI to tweak it anyway).

 - I somewhat tweaked "describe" and "describe --abbrev" implementation.
   OPT__ABBREV() uses DEFAULT_ABBREV in its callback, so we need to read
   from the configuration before calling parse_options().  As it won't
   make any sense to call "git describe" outside repository where you
   cannot get to your configuration, I think it is safe to add a call to
   git_config() in this codepath. Other users of OPT__ABBREV() may need to
   be audited.

By the way, I've already reverted the abbrevguard thing away.

-- >8 --
From: Linus Torvalds <torvalds@linux-foundation.org>
Date: Thu, 28 Oct 2010 11:28:04 -0700
Subject: [PATCH] Make the default abbrev length configurable

The default of 7 comes from fairly early in git development, when
seven hex digits was a lot (it covers about 250+ million hash
values). Back then I thought that 65k revisions was a lot (it was what
we were about to hit in BK), and each revision tends to be about 5-10
new objects or so, so a million objects was a big number.

These days, the kernel isn't even the largest git project, and even
the kernel has about 220k revisions (_much_ bigger than the BK tree
ever was) and we are approaching two million objects. At that point,
seven hex digits is still unique for a lot of them, but when we're
talking about just two orders of magnitude difference between number
of objects and the hash size, there _will_ be collisions in truncated
hash values. It's no longer even close to unrealistic - it happens all
the time.

We should both increase the default abbrev that was unrealistically
small, _and_ add a way for people to set their own default per-project
in the git config file.

This is the first step to first make it configurable; the default of 7
is not raised yet.

Signed-off-by: Junio C Hamano <redacted>
---
 Documentation/config.txt |    6 ++++++
 builtin/describe.c       |    6 +++++-
 cache.h                  |    5 +++--
 config.c                 |    8 ++++++++
 environment.c            |    1 +
 5 files changed, 23 insertions(+), 3 deletions(-)

diff --git a/Documentation/config.txt b/Documentation/config.txt
index c5e1835..30afde9 100644
--- a/Documentation/config.txt
+++ b/Documentation/config.txt

@@ -567,6 +567,12 @@ core.sparseCheckout::
 	Enable "sparse checkout" feature. See section "Sparse checkout" in
 	linkgit:git-read-tree[1] for more information.
 
+core.abbrevLength::
+	Set the length object names are abbreviated to.  If unspecified,
+	many commands abbreviate to 7 hexdigits, which may not be enough
+	for abbreviated object names to stay unique for sufficiently long
+	time.
+
 add.ignore-errors::
 add.ignoreErrors::
 	Tells 'git add' to continue adding files when some files cannot be

diff --git a/builtin/describe.c b/builtin/describe.c
index 342129f..9591596 100644
--- a/builtin/describe.c
+++ b/builtin/describe.c

@@ -21,7 +21,7 @@ static int debug;	/* Display lots of verbose info */
 static int all;	/* Any valid ref can be used */
 static int tags;	/* Allow lightweight tags */
 static int longformat;
-static int abbrev = DEFAULT_ABBREV;
+static int abbrev = -1; /* unspecified */
 static int max_candidates = 10;
 static struct hash_table names;
 static int have_util;

@@ -420,7 +420,11 @@ int cmd_describe(int argc, const char **argv, const char *prefix)
 		OPT_END(),
 	};
 
+	git_config(git_default_config, NULL);
 	argc = parse_options(argc, argv, prefix, options, describe_usage, 0);
+	if (abbrev < 0)
+		abbrev = DEFAULT_ABBREV;
+
 	if (max_candidates < 0)
 		max_candidates = 0;
 	else if (max_candidates > MAX_TAGS)

diff --git a/cache.h b/cache.h
index d83d68c..8d73d88 100644
--- a/cache.h
+++ b/cache.h

@@ -540,6 +540,7 @@ extern int trust_executable_bit;
 extern int trust_ctime;
 extern int quote_path_fully;
 extern int has_symlinks;
+extern int minimum_abbrev, default_abbrev;
 extern int ignore_case;
 extern int assume_unchanged;
 extern int prefer_symlink_refs;

@@ -758,8 +759,8 @@ static inline unsigned int hexval(unsigned char c)
 }
 
 /* Convert to/from hex/sha1 representation */
-#define MINIMUM_ABBREV 4
-#define DEFAULT_ABBREV 7
+#define MINIMUM_ABBREV minimum_abbrev
+#define DEFAULT_ABBREV default_abbrev
 
 struct object_context {
 	unsigned char tree[20];

diff --git a/config.c b/config.c
index 625e051..e8a6e56 100644
--- a/config.c
+++ b/config.c

@@ -531,6 +531,14 @@ static int git_default_core_config(const char *var, const char *value)
 		return 0;
 	}
 
+	if (!strcmp(var, "core.abbrevlength")) {
+		int abbrev = git_config_int(var, value);
+		if (abbrev < minimum_abbrev || abbrev > 40)
+			return -1;
+		default_abbrev = abbrev;
+		return 0;
+	}
+
 	if (!strcmp(var, "core.loosecompression")) {
 		int level = git_config_int(var, value);
 		if (level == -1)

diff --git a/environment.c b/environment.c
index 9564475..f2d90a8 100644
--- a/environment.c
+++ b/environment.c

@@ -15,6 +15,7 @@ int user_ident_explicitly_given;
 int trust_executable_bit = 1;
 int trust_ctime = 1;
 int has_symlinks = 1;
+int minimum_abbrev = 4, default_abbrev = 7;
 int ignore_case;
 int assume_unchanged;
 int prefer_symlink_refs;

-- 
1.7.4.1.404.g62d316