On Sun, Mar 17, 2013 at 01:01:44PM -0700, Junio C Hamano wrote:
+ * All references in the file that can be peeled are peeled.
+ * Inversely (and this is more important, any references in the
A missing closing paren after more important. Also the e-mail
quote reveals there is some inconsistent indentation (HTs vs runs of
SPs) here.
Thanks, will fix (the whitespace damage is due to me cutting and pasting
from Michael's commit).
+ * file for which no peeled value is recorded is not peelable. This
+ * trait should typically be written alongside fully-peeled for
Alongside peeled, no?
Urgh, yes. Will fix.
[...]
I am not sure why you find this any more readable.
I was trying to avoid the set PEELED globally, but sometimes unset it
for specific refs pattern which I think is confusing to the reader. But
I think what you wrote is even better. I used an enum rather than two
variables to make it clear that only ones takes effect. I had wanted to
use a switch, also, but you end up either repeating yourself, or doing
this gross fall-through:
switch (peeled) {
case PEELED_TAGS:
if (prefixcmp(refname, refs/tags/))
break;
/* fall-through */
case PEELED_FULLY:
last-ref |= REF_KNOWS_PEELED;
break;
default:
/* we know nothing */
}
So I just stuck with the conditional.
Here's the re-roll.
-- 8 --
From: Michael Haggerty mhag...@alum.mit.edu
Subject: [PATCH] pack-refs: add fully-peeled trait
Older versions of pack-refs did not write peel lines for
refs outside of refs/tags. This meant that on reading the
pack-refs file, we might set the REF_KNOWS_PEELED flag for
such a ref, even though we do not know anything about its
peeled value.
The previous commit updated the writer to always peel, no
matter what the ref is. That means that packed-refs files
written by newer versions of git are fine to be read by both
old and new versions of git. However, we still have the
problem of reading packed-refs files written by older
versions of git, or by other implementations which have not
yet learned the same trick.
The simplest fix would be to always unset the
REF_KNOWS_PEELED flag for refs outside of refs/tags that do
not have a peel line (if it has a peel line, we know it is
valid, but we cannot assume a missing peel line means
anything). But that loses an important optimization, as
upload-pack should not need to load the object pointed to by
refs/heads/foo to determine that it is not a tag.
Instead, we add a fully-peeled trait to the packed-refs
file. If it is set, we know that we can trust a missing peel
line to mean that a ref cannot be peeled. Otherwise, we fall
back to assuming nothing.
[commit message and tests by Jeff King p...@peff.net]
Signed-off-by: Michael Haggerty mhag...@alum.mit.edu
Signed-off-by: Jeff King p...@peff.net
---
pack-refs.c | 2 +-
refs.c | 49 -
t/t3211-peel-ref.sh | 22 ++
3 files changed, 67 insertions(+), 6 deletions(-)
diff --git a/pack-refs.c b/pack-refs.c
index ebde785..4461f71 100644
--- a/pack-refs.c
+++ b/pack-refs.c
@@ -128,7 +128,7 @@ int pack_refs(unsigned int flags)
die_errno(unable to create ref-pack file structure);
/* perhaps other traits later as well */
- fprintf(cbdata.refs_file, # pack-refs with: peeled \n);
+ fprintf(cbdata.refs_file, # pack-refs with: peeled fully-peeled \n);
for_each_ref(handle_one_ref, cbdata);
if (ferror(cbdata.refs_file))
diff --git a/refs.c b/refs.c
index 175b9fc..e2b760d 100644
--- a/refs.c
+++ b/refs.c
@@ -803,11 +803,38 @@ static void read_packed_refs(FILE *f, struct ref_dir *dir)
return line;
}
+/*
+ * Read f, which is a packed-refs file, into dir.
+ *
+ * A comment line of the form # pack-refs with: may contain zero or
+ * more traits. We interpret the traits as follows:
+ *
+ * No traits:
+ *
+ * Probably no references are peeled. But if the file contains a
+ * peeled value for a reference, we will use it.
+ *
+ * peeled:
+ *
+ * References under refs/tags/, if they *can* be peeled, *are*
+ * peeled in this file. References outside of refs/tags/ are
+ * probably not peeled even if they could have been, but if we find
+ * a peeled value for such a reference we will use it.
+ *
+ * fully-peeled:
+ *
+ * All references in the file that can be peeled are peeled.
+ * Inversely (and this is more important), any references in the
+ * file for which no peeled value is recorded is not peelable. This
+ * trait should typically be written alongside peeled for
+ * compatibility with older clients, but we do not require it
+ * (i.e., peeled is a no-op if fully-peeled is set).
+ */
static void read_packed_refs(FILE *f, struct ref_dir *dir)
{
struct ref_entry *last = NULL;
char refline[PATH_MAX];
-
