refs: move is_pseudoref_syntax() earlier in the file
PATCH v2 1/2 refs: move is_pseudoref_syntax() earlier in the file
This move is needed by a subsequent change to the expand_ref() function, which will make use of these functions.
--- refs.c | 38 +++++++++++++++++++------------------- 1 file changed, 19 insertions(+), 19 deletions(-)
refs.c +19 -19
@@ -630,6 +630,25 @@ int repo_dwim_ref(struct repository *r, const char *str, int len,return refs_found; } +static int is_pseudoref_syntax (const char *refname) +{ +const char *c; + +for (c = refname; *c; c++) { +if (!isupper (*c) && *c !='-' && *c !='_' ) +return 0 ; + } + +return 1 ; +} + +static int is_main_pseudoref_syntax (const char *refname) +{ +return skip_prefix (refname,"main-worktree/" , &refname) && + *refname && +is_pseudoref_syntax (refname); +} +int expand_ref (struct repository *repo,const char *str,int len,struct object_id *oid,char **ref) {
@@ -716,25 +735,6 @@ static int is_per_worktree_ref(const char *refname)starts_with (refname,"refs/rewritten/" ); } -static int is_pseudoref_syntax (const char *refname) -{ -const char *c; - -for (c = refname; *c; c++) { -if (!isupper (*c) && *c !='-' && *c !='_' ) -return 0 ; - } - -return 1 ; -} - -static int is_main_pseudoref_syntax (const char *refname) -{ -return skip_prefix (refname,"main-worktree/" , &refname) && - *refname && -is_pseudoref_syntax (refname); -} -static int is_other_pseudoref_syntax (const char *refname) {if (!skip_prefix (refname,"worktrees/" , &refname))
Signature · 1 line
2.29.2.222.g5d2a92d10f8
PATCH v2 2/2 refs: warn on non-pseudoref looking .git/<file> refs
The refs parsing machinery will first try to parse arbitrary .git/<name> for a given <name>, before moving onto refs/<name>, refs/tags/<name> etc. See "ref_rev_parse_rules" in refs.c, but e.g. "for-each-ref" and other things that list references ignore these ancient-style refs.
Thus if you end up in a repository that contains e.g. .git/master the likes of "checkout" can emit seemingly nonsensical error messages. E.g. I happened to have a .git/master with a non-commit SHA-1:
$ git checkout master
fatal: Cannot switch branch to a non-commit 'master'Running "for-each-ref" yields only commits that could match "master", until I realized I'd ended up with a .git/master file. Before this we'd ignore it under a general rule that tries to ignore .git/HEAD, .git/MERGE_HEAD and other non-pseudoref looking refs at the top-level.
Let's help the user in this case by doing a very loose check for whether the ref name looks like a pseudoref such as "HEAD" (i.e. only has upper case, dashes, underbars), and if not issue a warning:
$ git rev-parse master
warning: matched ref .git/master doesn't look like a pseudoref
c87c83a2e9eb6d309913a0f59389f808024a58f9I think it's conservative enough to just turn this on by default, but place it under a configurable option similar to the existing core.warnAmbiguousRefs. Running the entire test suite with "die" instead of "warning" passes with this approach.
Our own test suite makes use of a few refs in .git/ that aren't produced by git itself, e.g. "FOO", "TESTSYMREFTWO" etc, external tools probably rely on this as well, so I don't think it's viable to e.g. have a whitelist of "HEAD", "MERGE_HEAD" etc. As an aside that list is quite large, I counted 12 names used in the C code before I abandoned that approach.
This approach of checking the case of e.g. "master" is not an issue on case-insensitive filesystems, since we're not checking against the fs's version of the name, but what the user provided to git on the command-line.
We are going to match "git rev-parse master" to e.g. .git/MASTER on those systems, but I think that's also a case the user would like to be warned about. I once helped a user on OSX with an issue where they couldn't repeat a merge command on Linux, and it turned out they'd referred to "HEAD" as "head", which we'd happily resolve to .git/HEAD without warning on that system. Now we'll warn about that.
--- Documentation/config/core.txt | 11 ++++++++++ cache.h | 1 + config.c | 5 +++++ environment.c | 1 + refs.c | 20 +++++++++++++++++ t/t1430-bad-ref-name.sh | 41 +++++++++++++++++++++++++++++++++++ 6 files changed, 79 insertions(+)
Documentation/config/core.txt +11 -0
@@ -355,6 +355,17 @@ core.warnAmbiguousRefs:: If true, Git will warn you if the ref name you passed it is ambiguous and might match multiple refs in the repository. True by default. +core.warnNonPseudoRefs:: + If true, Git will warn you if the `<ref>` you passed + unexpectedly resolves to a top-level ref stored in + `.git/<file>` but doesn't look like a pseudoref such as + `HEAD`, `MERGE_HEAD` etc. True by default. ++ +These references are ignored by linkgit:for-each-ref[1], but resolved +by linkgit:git-show[1], linkgit:git-rev-parse[1] etc. So it can be +confusing to have e.g. an errant `.git/master` being confused with +`.git/refs/heads/master`. + core.compression:: An integer -1..9, indicating a default compression level. -1 is the zlib default. 0 means no compression,
cache.h +1 -0
@@ -920,6 +920,7 @@ extern int ignore_case;extern int assume_unchanged;extern int prefer_symlink_refs;extern int warn_ambiguous_refs; +extern int warn_non_pseudo_refs;extern int warn_on_object_refname_ambiguity;extern char *apply_default_whitespace;extern char *apply_default_ignorewhitespace;
config.c +5 -0
@@ -1212,6 +1212,11 @@ static int git_default_core_config(const char *var, const char *value, void *cb)return 0 ; } +if (!strcmp (var,"core.warnnonpseudorefs" )) { + warn_non_pseudo_refs =git_config_bool (var, value); +return 0 ; + } +if (!strcmp (var,"core.abbrev" )) {if (!value)return config_error_nonbool (var);
environment.c +1 -0
@@ -29,6 +29,7 @@ int assume_unchanged;int prefer_symlink_refs;int is_bare_repository_cfg =-1 ;/* unspecified */ int warn_ambiguous_refs =1 ; +int warn_non_pseudo_refs =1 ;int warn_on_object_refname_ambiguity =1 ;int ref_paranoia =-1 ;int repository_format_precious_objects;
refs.c +20 -0
@@ -649,12 +649,19 @@ static int is_main_pseudoref_syntax(const char *refname)is_pseudoref_syntax (refname); } +static int is_any_pseudoref_syntax (const char *refname) +{ +return is_main_pseudoref_syntax (refname) || +is_pseudoref_syntax (refname); +} +int expand_ref (struct repository *repo,const char *str,int len,struct object_id *oid,char **ref) {const char **p, *r;int refs_found =0 ;struct strbuf fullref =STRBUF_INIT ; +static int warned_on_non_pseudo_ref; *ref =NULL ;for (p = ref_rev_parse_rules; *p; p++) {
@@ -669,6 +676,19 @@ int expand_ref(struct repository *repo, const char *str, int len, fullref.buf,RESOLVE_REF_READING , this_result, &flag);if (r) { +if (warn_non_pseudo_refs && + !starts_with (fullref.buf,"refs/" ) && + !starts_with (r,"refs/" ) && + !strchr (r,'/' ) && + !is_any_pseudoref_syntax (r) && + !warned_on_non_pseudo_ref++) { +/* +* TRANSLATORS: The 1st argument is +* e.g. "master", and the 2nd can be +* e.g. "master~10". +*/ +warning (_ ("matched ref name .git/%s doesn't look like a pseudoref" ), r); + }if (!refs_found++) *ref =xstrdup (r);if (!warn_ambiguous_refs)
t/t1430-bad-ref-name.sh +41 -0
45 lines not on this page · raw message
Signature · 1 line
2.29.2.222.g5d2a92d10f8
Re: [PATCH 2/2] refs: warn on non-pseudoref looking .git/<file> refs
Quoted 9 lines · Ævar Arnfjörð Bjarmason
[...]
Let's help the user in this case by doing a very loose check for whether the ref name looks like a pseudoref such as "HEAD" (i.e. only has upper case, dashes, underbars), and if not issue a warning:[...]Signed-off-by Ævar Arnfjörð Bjarmason <[email protected]>---
Documentation/config/core.txt core.warnAmbiguousRefs:: · line 364
Quoted 10 lines
Documentation/config/core.txt +10
-0@@ -355,6 +355,17 @@ core.warnAmbiguousRefs:: +core.warnNonPseudoRefs:: + If true, Git will warn you if the `<ref>` you passed + unexpectedly resolves to a top-level ref stored in + `.git/<file>` but doesn't look like a pseudoref such as + `HEAD`, `MERGE_HEAD` etc. True by default. ++ +These references are ignored by linkgit:for-each-ref[1], but resolved +by linkgit:git-show[1], linkgit:git-rev-parse[1] etc. So it can be +confusing to have e.g. an errant `.git/master` being confused with +`.git/refs/heads/master`.
Dscho has been submitting patches lately to eradicate the word "master" from the project source.
Quoted 5 lines
refs.c +2
-0@@ -669,6 +676,19 @@ int expand_ref(struct repository *repo, const char *str, int len,if (r) { + if (warn_non_pseudo_refs && + !starts_with(fullref.buf, "refs/") &&
refs.c int expand_ref(struct repository *repo, const char *str, int len, · line 688
Quoted 10 lines
refs.c +10
-0+ !starts_with(r, "refs/") && + !strchr(r, '/') && + !is_any_pseudoref_syntax(r) && + !warned_on_non_pseudo_ref++) { +/* +* TRANSLATORS: The 1st argument is +* e.g. "master", and the 2nd can be +* e.g. "master~10". +*/ +warning (_ ("matched ref name .git/%s doesn't look like a pseudoref" ), r);
The TRANSLATORS comment talks about two arguments, but I see only one.
Does the "matched ref name" part add any value? I would find the warning just as helpful without it:
.git/blork doesn't look like a pseudoref
t/t1430-bad-ref-name.sh test_expect_success 'branch -m can rename refs/heads/-dash' ' · line 380
Quoted 9 lines
t/t1430-bad-ref-name.sh +7
-0@@ -374,4 +374,45 @@ test_expect_success 'branch -m can rename refs/heads/-dash' ' +test_expect_success 'warn on non-pseudoref syntax refs in .git/' ' + test_when_finished " + rm -f .git/mybranch && + rm -rf .git/a-dir && + rm -rf .git/MY-BRANCH_NAME && + rm -rf .git/MY-branch_NAME + " &&
Nit: These could all be removed with a single rm -rf:
rm -rf .git/mybranch .git/a-dir ...
t/t1430-bad-ref-name.sh test_expect_success 'branch -m can rename refs/heads/-dash' ' · line 411
Quoted 5 lines
t/t1430-bad-ref-name.sh +5
-0+ # We do not ignore lower-case + cp expect .git/mybranch && + git rev-parse mybranch >hash 2>err && + test_cmp expect hash && + GIT_TEST_GETTEXT_POISON=false grep "like a pseudoref" err &&
What is the purpose of assigning GIT_TEST_GETTEXT_POISON here?
Quoted 5 lines
t/t1430-bad-ref-name.sh +5
-0+ git -c core.warnNonPseudoRefs=false rev-parse mybranch >hash 2>err && + test_cmp expect hash && + test_must_be_empty err && + rm .git/mybranch +'
Re: [PATCH 2/2] refs: warn on non-pseudoref looking .git/<file> refs
Quoted 16 lines · Eric Sunshine
Quoted 14 lines · Ævar Arnfjörð Bjarmason
[...]
Let's help the user in this case by doing a very loose check for whether the ref name looks like a pseudoref such as "HEAD" (i.e. only has upper case, dashes, underbars), and if not issue a warning:[...]Signed-off-by Ævar Arnfjörð Bjarmason <[email protected]>---
Documentation/config/core.txt +5
-0@@ -355,6 +355,17 @@ core.warnAmbiguousRefs:: +core.warnNonPseudoRefs:: + If true, Git will warn you if the `<ref>` you passed + unexpectedly resolves to a top-level ref stored in + `.git/<file>` but doesn't look like a pseudoref such as + `HEAD`, `MERGE_HEAD` etc. True by default.
Quoted 8 lines
Documentation/config/core.txt core.warnAmbiguousRefs:: · line 367
Quoted 5 lines
Documentation/config/core.txt +5
-0++ +These references are ignored by linkgit:for-each-ref[1], but resolved +by linkgit:git-show[1], linkgit:git-rev-parse[1] etc. So it can be +confusing to have e.g. an errant `.git/master` being confused with +`.git/refs/heads/master`.Dscho has been submitting patches lately to eradicate the word "master" from the project source.
Muscle memory dies hard, will fix it in the reroll.
Quoted 18 lines
Quoted 5 lines
refs.c +2
-0@@ -669,6 +676,19 @@ int expand_ref(struct repository *repo, const char *str, int len,if (r) { + if (warn_non_pseudo_refs && + !starts_with(fullref.buf, "refs/") &&refs.c int expand_ref(struct repository *repo, const char *str, int len, · line 688
Quoted 10 lines
refs.c +10
-0+ !starts_with(r, "refs/") && + !strchr(r, '/') && + !is_any_pseudoref_syntax(r) && + !warned_on_non_pseudo_ref++) { +/* +* TRANSLATORS: The 1st argument is +* e.g. "master", and the 2nd can be +* e.g. "master~10". +*/ +warning (_ ("matched ref name .git/%s doesn't look like a pseudoref" ), r);The TRANSLATORS comment talks about two arguments, but I see only one.
Quoted 4 lines
Does the "matched ref name" part add any value? I would find the warning just as helpful without it:
.git/blork doesn't look like a pseudoref
Yeah that's much better, the TRANSLATORS comment is incorrect, rebased out an earlier version where it took two, didn't notice...
Quoted 12 lines
t/t1430-bad-ref-name.sh test_expect_success 'branch -m can rename refs/heads/-dash' ' · line 380
Quoted 9 lines
t/t1430-bad-ref-name.sh +7
-0@@ -374,4 +374,45 @@ test_expect_success 'branch -m can rename refs/heads/-dash' ' +test_expect_success 'warn on non-pseudoref syntax refs in .git/' ' + test_when_finished " + rm -f .git/mybranch && + rm -rf .git/a-dir && + rm -rf .git/MY-BRANCH_NAME && + rm -rf .git/MY-branch_NAME + " &&Nit: These could all be removed with a single
rm -rf:
Quoted 1 line
rm -rf .git/mybranch .git/a-dir ...
Will fix.
Quoted 7 lines
t/t1430-bad-ref-name.sh test_expect_success 'branch -m can rename refs/heads/-dash' ' · line 411
Quoted 5 lines
t/t1430-bad-ref-name.sh +5
-0+ # We do not ignore lower-case + cp expect .git/mybranch && + git rev-parse mybranch >hash 2>err && + test_cmp expect hash && + GIT_TEST_GETTEXT_POISON=false grep "like a pseudoref" err &&What is the purpose of assigning
GIT_TEST_GETTEXT_POISONhere?
Since 6cdccfce1e0 (i18n: make GETTEXT_POISON a runtime option, 2018-11-08) we haven't needed to use the C_LOCALE_OUTPUT prerequisite for any new code, since we can just turn the poisoning off.
I think we should just slowly refactor things away from that prerequisite and test_i18ngrep, which were only needed because it used to be a compile-time switch, but I haven't gotter around to that refactoring.
In liue of that I think it makes more sense to always run the full test if possible, no matter what the GIT_TEST_* mode is.
Quoted 5 lines
Quoted 5 lines
t/t1430-bad-ref-name.sh +5
-0+ git -c core.warnNonPseudoRefs=false rev-parse mybranch >hash 2>err && + test_cmp expect hash && + test_must_be_empty err && + rm .git/mybranch +'
Re: [PATCH 2/2] refs: warn on non-pseudoref looking .git/<file> refs
Quoted 11 lines · Ævar Arnfjörð Bjarmason
Quoted 5 lines · Eric Sunshine
Quoted 1 line · Ævar Arnfjörð Bjarmason
+ GIT_TEST_GETTEXT_POISON=false grep "like a pseudoref" err &&
What is the purpose of assigning
GIT_TEST_GETTEXT_POISONhere?Since
6cdccfce1e0(i18n: makeGETTEXT_POISONa runtime option, 2018-11-08) we haven't needed to use theC_LOCALE_OUTPUTprerequisite for any new code, since we can just turn the poisoning off.
Quoted 7 lines
I think we should just slowly refactor things away from that prerequisite and
test_i18ngrep, which were only needed because it used to be a compile-time switch, but I haven't gotter around to that refactoring.In liue of that I think it makes more sense to always run the full test if possible, no matter what the GIT_TEST_* mode is.
I must be missing something. I've looked at 6cdccfce1e0 but I still don't see how or why GIT_TEST_GETTEXT_POISON=false could affect the simple grep invocation being done by this test. I could understand if GIT_TEST_GETTEXT_POISON was applied to the invocation of a Git command, but that's not the case here.
(I also notice that 6cdccfce1e0 only checks whether GIT_TEST_GETTEXT_POISON is empty or not -- and the changes in 6cdccfce1e0 set GIT_TEST_GETTEXT_POISON to an empty value rather than to "false", so I find myself doubly confused by this application of GIT_TEST_GETTEXT_POISON to grep.)
Re: [PATCH 2/2] refs: warn on non-pseudoref looking .git/<file> refs
Quoted 27 lines · Eric Sunshine
Quoted 11 lines · Ævar Arnfjörð Bjarmason
Quoted 5 lines · Eric Sunshine
Quoted 1 line · Ævar Arnfjörð Bjarmason
+ GIT_TEST_GETTEXT_POISON=false grep "like a pseudoref" err &&
What is the purpose of assigning
GIT_TEST_GETTEXT_POISONhere?Since
6cdccfce1e0(i18n: makeGETTEXT_POISONa runtime option, 2018-11-08) we haven't needed to use theC_LOCALE_OUTPUTprerequisite for any new code, since we can just turn the poisoning off.Quoted 7 lines
I think we should just slowly refactor things away from that prerequisite and
test_i18ngrep, which were only needed because it used to be a compile-time switch, but I haven't gotter around to that refactoring.In liue of that I think it makes more sense to always run the full test if possible, no matter what the GIT_TEST_* mode is.
I must be missing something. I've looked at
6cdccfce1e0but I still don't see how or whyGIT_TEST_GETTEXT_POISON=falsecould affect the simplegrepinvocation being done by this test. I could understand ifGIT_TEST_GETTEXT_POISONwas applied to the invocation of a Git command, but that's not the case here.
Quoted 5 lines
(I also notice that
6cdccfce1e0only checks whetherGIT_TEST_GETTEXT_POISONis empty or not -- and the changes in6cdccfce1e0setGIT_TEST_GETTEXT_POISONto an empty value rather than to "false", so I find myself doubly confused by this application ofGIT_TEST_GETTEXT_POISONtogrep.)
You're not missing something, but it seems I need to step away from the computer for the day. I managed to write this & reply to your E-Mail without noticing I'd put the GIT_TEST[...] env variable in front of the wrong command. It should indeed be in front of the rev-parse above.
PATCH v2 1/2 refs: move is_pseudoref_syntax() earlier in the file
In reply to Ævar Arnfjörð BjarmasonThis move is needed by a subsequent change to the expand_ref() function, which will make use of these functions.
--- refs.c | 38 +++++++++++++++++++------------------- 1 file changed, 19 insertions(+), 19 deletions(-)
refs.c +19 -19
@@ -630,6 +630,25 @@ int repo_dwim_ref(struct repository *r, const char *str, int len,return refs_found; } +static int is_pseudoref_syntax (const char *refname) +{ +const char *c; + +for (c = refname; *c; c++) { +if (!isupper (*c) && *c !='-' && *c !='_' ) +return 0 ; + } + +return 1 ; +} + +static int is_main_pseudoref_syntax (const char *refname) +{ +return skip_prefix (refname,"main-worktree/" , &refname) && + *refname && +is_pseudoref_syntax (refname); +} +int expand_ref (struct repository *repo,const char *str,int len,struct object_id *oid,char **ref) {
@@ -716,25 +735,6 @@ static int is_per_worktree_ref(const char *refname)starts_with (refname,"refs/rewritten/" ); } -static int is_pseudoref_syntax (const char *refname) -{ -const char *c; - -for (c = refname; *c; c++) { -if (!isupper (*c) && *c !='-' && *c !='_' ) -return 0 ; - } - -return 1 ; -} - -static int is_main_pseudoref_syntax (const char *refname) -{ -return skip_prefix (refname,"main-worktree/" , &refname) && - *refname && -is_pseudoref_syntax (refname); -} -static int is_other_pseudoref_syntax (const char *refname) {if (!skip_prefix (refname,"worktrees/" , &refname))
Signature · 1 line
2.29.2.222.g5d2a92d10f8
PATCH v2 2/2 refs: warn on non-pseudoref looking .git/<file> refs
In reply to Ævar Arnfjörð BjarmasonThe refs parsing machinery will first try to parse arbitrary .git/<name> for a given <name>, before moving onto refs/<name>, refs/tags/<name> etc. See "ref_rev_parse_rules" in refs.c. Things that list references such as "for-each-ref" ignore these on the assumption that they're pseudorefs such as "HEAD".
Thus if you end up in a repository that contains e.g. .git/master the likes of "checkout" can emit seemingly nonsensical error messages. E.g. I happened to have a .git/master with a non-commit SHA-1:
$ git checkout master
fatal: Cannot switch branch to a non-commit 'master'Running "for-each-ref" yields only commits that could match "master", until I realized I'd ended up with a .git/master file. Before this we'd ignore it under a general rule that tries to ignore .git/HEAD, .git/MERGE_HEAD and other non-pseudoref looking refs at the top-level.
Let's help the user in this case by doing a very loose check for whether the ref name looks like a special pseudoref such as "HEAD" (i.e. only has upper case, dashes, underbars), and if not issue a warning:
$ git rev-parse master
warning: matched ref .git/master doesn't look like a pseudoref
c87c83a2e9eb6d309913a0f59389f808024a58f9I think it's conservative enough to just turn this on by default, but place it under a configurable option similar to the existing core.warnAmbiguousRefs. Running the entire test suite with "die" instead of "warning" passes with this approach.
Our own test suite makes use of a few refs in .git/ that aren't produced by git itself, e.g. "FOO", "TESTSYMREFTWO" etc. External tools probably rely on this as well, so I don't think it's viable to e.g. have a whitelist of them. That list is quite large just fr git.git, I counted 12 names used in the C code before I abandoned that approach.
This approach of checking the case of e.g. "master" is not an issue on case-insensitive filesystems, since we're not checking against the fs's version of the name, but what the user provided to git on the command-line.
We are going to match "git rev-parse master" to e.g. .git/MASTER on those systems, but I think that's also a case the user would like to be warned about. I once helped a user on OSX with an issue where they couldn't repeat a merge command on Linux, and it turned out they'd referred to "HEAD" as "head", which we'd happily resolve to .git/HEAD without warning on that system. Now we'll warn about that.
--- Documentation/config/core.txt | 11 ++++++++++ cache.h | 1 + config.c | 5 +++++ environment.c | 1 + refs.c | 12 ++++++++++ t/t1430-bad-ref-name.sh | 41 +++++++++++++++++++++++++++++++++++ 6 files changed, 71 insertions(+)
Documentation/config/core.txt +11 -0
@@ -355,6 +355,17 @@ core.warnAmbiguousRefs:: If true, Git will warn you if the ref name you passed it is ambiguous and might match multiple refs in the repository. True by default. +core.warnNonPseudoRefs:: + If true, Git will warn you if the `<ref>` you passed + unexpectedly resolves to a top-level ref stored in + `.git/<file>` but doesn't look like a pseudoref such as + `HEAD`, `MERGE_HEAD` etc. True by default. ++ +These references are ignored by linkgit:for-each-ref[1], but resolved +by linkgit:git-show[1], linkgit:git-rev-parse[1] etc. So it can be +confusing to have e.g. an errant `.git/mybranch` being confused with +`.git/refs/heads/mybranch`. + core.compression:: An integer -1..9, indicating a default compression level. -1 is the zlib default. 0 means no compression,
cache.h +1 -0
@@ -920,6 +920,7 @@ extern int ignore_case;extern int assume_unchanged;extern int prefer_symlink_refs;extern int warn_ambiguous_refs; +extern int warn_non_pseudo_refs;extern int warn_on_object_refname_ambiguity;extern char *apply_default_whitespace;extern char *apply_default_ignorewhitespace;
config.c +5 -0
@@ -1212,6 +1212,11 @@ static int git_default_core_config(const char *var, const char *value, void *cb)return 0 ; } +if (!strcmp (var,"core.warnnonpseudorefs" )) { + warn_non_pseudo_refs =git_config_bool (var, value); +return 0 ; + } +if (!strcmp (var,"core.abbrev" )) {if (!value)return config_error_nonbool (var);
environment.c +1 -0
@@ -29,6 +29,7 @@ int assume_unchanged;int prefer_symlink_refs;int is_bare_repository_cfg =-1 ;/* unspecified */ int warn_ambiguous_refs =1 ; +int warn_non_pseudo_refs =1 ;int warn_on_object_refname_ambiguity =1 ;int ref_paranoia =-1 ;int repository_format_precious_objects;
refs.c +12 -0
@@ -649,12 +649,19 @@ static int is_main_pseudoref_syntax(const char *refname)is_pseudoref_syntax (refname); } +static int is_any_pseudoref_syntax (const char *refname) +{ +return is_main_pseudoref_syntax (refname) || +is_pseudoref_syntax (refname); +} +int expand_ref (struct repository *repo,const char *str,int len,struct object_id *oid,char **ref) {const char **p, *r;int refs_found =0 ;struct strbuf fullref =STRBUF_INIT ; +static int warned_on_non_pseudo_ref; *ref =NULL ;for (p = ref_rev_parse_rules; *p; p++) {
@@ -669,6 +676,11 @@ int expand_ref(struct repository *repo, const char *str, int len, fullref.buf,RESOLVE_REF_READING , this_result, &flag);if (r) { +if (warn_non_pseudo_refs && + !strchr (r,'/' ) && + !is_any_pseudoref_syntax (r) && + !warned_on_non_pseudo_ref++) +warning (_ (".git/%s doesn't look like a pseudoref" ), r);if (!refs_found++) *ref =xstrdup (r);if (!warn_ambiguous_refs)
t/t1430-bad-ref-name.sh +41 -0
45 lines not on this page · raw message
Signature · 1 line
2.29.2.222.g5d2a92d10f8
Re: [PATCH v2 2/2] refs: warn on non-pseudoref looking .git/<file> refs
Quoted 5 lines · Ævar Arnfjörð Bjarmason
[...]
Our own test suite makes use of a few refs in .git/ that aren't produced by git itself, e.g. "FOO", "TESTSYMREFTWO" etc. External tools probably rely on this as well, so I don't think it's viable to e.g. have a whitelist of them. That list is quite large just fr
You want a s/fr/from/ here or something?
Quoted 5 lines
git.git, I counted 12 names used in the C code before I abandoned that approach.
[...]Signed-off-by Ævar Arnfjörð Bjarmason <[email protected]>Modified-by Ævar Arnfjörð Bjarmason <[email protected]>
Is the Modified-by: footer intentional?
Re: [PATCH v2 2/2] refs: warn on non-pseudoref looking .git/<file> refs
In reply to Ævar Arnfjörð BjarmasonQuoted 6 lines · Ævar Arnfjörð Bjarmason
The refs parsing machinery will first try to parse arbitrary .git/<name> for a given <name>, before moving onto refs/<name>, refs/tags/<name> etc. See "
ref_rev_parse_rules" inrefs.c. Things that list references such as "for-each-ref" ignore these on the assumption that they're pseudorefs such as "HEAD".
Quoted 7 lines
Thus if you end up in a repository that contains e.g. .git/master the likes of "checkout" can emit seemingly nonsensical error messages. E.g. I happened to have a .git/master with a non-commit SHA-1:
$ git checkout master fatal: Cannot switch branch to a non-commit 'master'
Or, without even any funny files created in .git to make it misbehave, "git checkout config" would already give you
$ git checkout config
error: pathspec 'config' did not match any file(s) known to git
$ git checkout config --
fatal: invalid reference: configYou were unlucky enough to have 40-hex in that garbage file. How did you end up with it, I wonder, but anyway, a move to make it easier to diagnose the situation is very welcome.
Quoted 8 lines
Let's help the user in this case by doing a very loose check for whether the ref name looks like a special pseudoref such as "HEAD" (i.e. only has upper case, dashes, underbars), and if not issue a warning:
$ git rev-parse master warning: matched ref .git/master doesn't look like a pseudoref c87c83a2e9eb6d309913a0f59389f808024a58f9
With the problem this patch addressed solved, what should happen if you did this?
$ git rev-parse refs/heads/master~4 >.git/master
$ git checkout masterMy knee-jerk reaction to the question is that we should still give the same warning, even though the "checkout" should successfully detach the HEAD at the commit, to remind you that the name you used came from may have been resolved to something you did not expect, and the value you used may not be what you wanted to use.
Quoted 4 lines
I think it's conservative enough to just turn this on by default, but place it under a configurable option similar to the existing core.warnAmbiguousRefs. Running the entire test suite with "die" instead of "warning" passes with this approach.
Sounds sensible.
Quoted 2 lines
Signed-off-by Ævar Arnfjörð Bjarmason <[email protected]>Modified-by Ævar Arnfjörð Bjarmason <[email protected]>
Huh?
Documentation/config/core.txt core.warnAmbiguousRefs:: · line 362
Quoted 5 lines
Documentation/config/core.txt +5
-0+core.warnNonPseudoRefs:: + If true, Git will warn you if the `<ref>` you passed + unexpectedly resolves to a top-level ref stored in + `.git/<file>` but doesn't look like a pseudoref such as + `HEAD`, `MERGE_HEAD` etc. True by default.
I'd really prefer to see us to think, design and describe in terms of a more generic ref API, when we do not have to limit us to the behaviour only with files backend. Reading the file .git/<ref> on the filesystem happens to be one way to resolve a ref to its value (i.e. reference to an object), but even with different ref backends, we want 'master' that sits next to 'refs/heads/master' to trigger this warning. So
... if the <ref> you passed refers to a <ref> outside the refs/{heads,tags,...}/ hierarchy but does not look like
...
or something like that, perhaps.
Documentation/config/core.txt core.warnAmbiguousRefs:: · line 367
Quoted 5 lines
++
Documentation/config/core.txt +4
-0+These references are ignored by linkgit:for-each-ref[1], but resolved +by linkgit:git-show[1], linkgit:git-rev-parse[1] etc. So it can be +confusing to have e.g. an errant `.git/mybranch` being confused with +`.git/refs/heads/mybranch`.
Here, ".git/mybranch" and ".git/refs/heads/mybranch" are good as examples. I just want to avoid tying the main description to the files backend.
refs.c static int is_main_pseudoref_syntax(const char *refname) · line 656
Quoted 13 lines
refs.c +5
-0@@ -649,12 +649,19 @@ static int is_main_pseudoref_syntax(const char *refname)is_pseudoref_syntax (refname); } +static int is_any_pseudoref_syntax (const char *refname) +{ +return is_main_pseudoref_syntax (refname) || +is_pseudoref_syntax (refname); +}
Hmph, why is this needed, I wonder.
"git show main-worktree/master" is specific enough to tell us that the user did not mean "git show main-worktree/refs/heads/master", no? If so, then wouldn't it be sufficient to check only with is_pseudoref_syntax() and nothing else? I may probably missing something to make me convince is_main_pseudoref_syntax() matters here.
Quoted 11 lines
refs.c +1
-0int expand_ref (struct repository *repo,const char *str,int len,struct object_id *oid,char **ref) {const char **p, *r;int refs_found =0 ;struct strbuf fullref =STRBUF_INIT ; +static int warned_on_non_pseudo_ref; *ref =NULL ;for (p = ref_rev_parse_rules; *p; p++) {
refs.c int expand_ref(struct repository *repo, const char *str, int len, · line 683
Quoted 8 lines
refs.c +5
-0@@ -669,6 +676,11 @@ int expand_ref(struct repository *repo, const char *str, int len, fullref.buf,RESOLVE_REF_READING , this_result, &flag);if (r) { +if (warn_non_pseudo_refs && + !strchr (r,'/' ) && + !is_any_pseudoref_syntax (r) && + !warned_on_non_pseudo_ref++) +warning (_ (".git/%s doesn't look like a pseudoref" ), r);
I do not see much point in reporting only the first one.
Isn't the conditional "if (r)" sufficiently limiting the ref only to those that the user showed immediate interest in? In other words, even if there were .git/foo and .git/bar, both of which happens to contain something that looks like an object name, "git show foo" would cause this code to warn only about .git/foo and .git/bar, no?
If there are more than one hits, why shouldn't we report all of them?
Or is this some performance thing (i.e. there only can be one hit, so repeated calls to strchr() and is_any_pseudoref_syntax() after seeing one hit would all be wasteful)? If so, "have we warned? if so skip the remainder of checking, as we won't warn" should be the first in the &&-chain.
Puzzled.
Thanks.
Re: [PATCH v2 2/2] refs: warn on non-pseudoref looking .git/<file> refs
Quoted 4 lines · Junio C Hamano
Quoted 2 lines
Signed-off-by Ævar Arnfjörð Bjarmason <[email protected]>Modified-by Ævar Arnfjörð Bjarmason <[email protected]>Huh?
I think I was using that to test my %(trailers) patches & didn't notice. Sorry.
As for the rest of the feedback thanks & I'll address it.
I'm planning to re-roll this but given that we're in the rc window & the time I have to re-roll this in the coming week(s) let's put this series on hold/eject it (in case you were planning to put it into "seen") until we start post-v2.30 work.
v2 cover warn on non-pseudoref looking .git/<file> refs
In reply to Ævar Arnfjörð BjarmasonNow with a cover letter to show the range-diff. I addressed all of Eric's comments, and found some other minor issues myself. The check for whether we need to warn has also been simplified, we just needed to check if we have "/" in the resolved "r" variable.
Ævar Arnfjörð Bjarmason (2):
refs: move is_pseudoref_syntax() earlier in the file
refs: warn on non-pseudoref looking .git/<file> refs
Documentation/config/core.txt | 11 ++++++++ cache.h | 1 + config.c | 5 ++++ environment.c | 1 + refs.c | 50 ++++++++++++++++++++++------------- t/t1430-bad-ref-name.sh | 41 ++++++++++++++++++++++++++++ 6 files changed, 90 insertions(+), 19 deletions(-)
Range-diff:
-: ----------- > 1: e86e55f2828 refs: move is_pseudoref_syntax() earlier in the file 1: cad73aba664 ! 2: 0573da1d381 refs: warn on non-pseudoref looking .git/<file> refs
@@ Commit message
The refs parsing machinery will first try to parse arbitrary .git/<name> for a given <name>, before moving onto refs/<name>,
- refs/tags/<name> etc. See "ref_rev_parse_rules" in refs.c, but
- e.g. "for-each-ref" and other things that list references ignore these
- ancient-style refs.
+ refs/tags/<name> etc. See "ref_rev_parse_rules" in refs.c. Things that
+ list references such as "for-each-ref" ignore these on the assumption
+ that they're pseudorefs such as "HEAD".
Thus if you end up in a repository that contains e.g. .git/master the likes of "checkout" can emit seemingly nonsensical error
@@ Commit message
.git/MERGE_HEAD and other non-pseudoref looking refs at the top-level.
Let's help the user in this case by doing a very loose check for
- whether the ref name looks like a pseudoref such as "HEAD" (i.e. only
- has upper case, dashes, underbars), and if not issue a warning:
+ whether the ref name looks like a special pseudoref such as
+ "HEAD" (i.e. only has upper case, dashes, underbars), and if not issue
+ a warning:
$ git rev-parse master
warning: matched ref .git/master doesn't look like a pseudoref
@@ Commit message
instead of "warning" passes with this approach.
Our own test suite makes use of a few refs in .git/ that aren't
- produced by git itself, e.g. "FOO", "TESTSYMREFTWO" etc, external
+ produced by git itself, e.g. "FOO", "TESTSYMREFTWO" etc. External
tools probably rely on this as well, so I don't think it's viable to
- e.g. have a whitelist of "HEAD", "MERGE_HEAD" etc. As an aside that
- list is quite large, I counted 12 names used in the C code before I
- abandoned that approach.
+ e.g. have a whitelist of them. That list is quite large just fr
+ git.git, I counted 12 names used in the C code before I abandoned that
+ approach.
This approach of checking the case of e.g. "master" is not an issue on case-insensitive filesystems, since we're not checking against the
@@ Commit message
without warning on that system. Now we'll warn about that.
+ Modified-by: Ævar Arnfjörð Bjarmason <[email protected]>
## Documentation/config/core.txt ##
@@ Documentation/config/core.txt: core.warnAmbiguousRefs::
@@ Documentation/config/core.txt: core.warnAmbiguousRefs::
++
+These references are ignored by linkgit:for-each-ref[1], but resolved +by linkgit:git-show[1], linkgit:git-rev-parse[1] etc. So it can be
-+confusing to have e.g. an errant .git/master being confused with -+.git/refs/heads/master.
++confusing to have e.g. an errant .git/mybranch being confused with ++.git/refs/heads/mybranch.
+
core.compression::
An integer -1..9, indicating a default compression level.
@@ refs.c: int expand_ref(struct repository *repo, const char *str, int len,
this_result, &flag);
if (r) {
+ if (warn_non_pseudo_refs &&
-+ !starts_with(fullref.buf, "refs/") &&
-+ !starts_with(r, "refs/") &&
+ !strchr(r, '/') &&
+ !is_any_pseudoref_syntax(r) &&
-+ !warned_on_non_pseudo_ref++) {
-+ /*
-+ * TRANSLATORS: The 1st argument is
-+ * e.g. "master", and the 2nd can be
-+ * e.g. "master~10".
-+ */
-+ warning(_("matched ref name .git/%s doesn't look like a pseudoref"), r);
-+ }
++ !warned_on_non_pseudo_ref++)
++ warning(_(".git/%s doesn't look like a pseudoref"), r);
if (!refs_found++)
*ref = xstrdup(r);
if (!warn_ambiguous_refs)
@@ t/t1430-bad-ref-name.sh: test_expect_success 'branch -m can rename refs/heads/-d
+test_expect_success 'warn on non-pseudoref syntax refs in .git/' '
+ test_when_finished "
-+ rm -f .git/mybranch &&
-+ rm -rf .git/a-dir &&
-+ rm -rf .git/MY-BRANCH_NAME &&
-+ rm -rf .git/MY-branch_NAME
++ rm -rf .git/mybranch \
++ .git/a-dir \
++ .git/MY-BRANCH_NAME \
++ .git/MY-branch_NAME
+ " &&
+
+ # Setup
-+ git rev-parse master >expect &&
++ git rev-parse HEAD >expect &&
++ mkdir .git/a-dir &&
+
+ # We ignore anything with slashes
-+ mkdir .git/a-dir &&
+ cp expect .git/a-dir/mybranch &&
+ git rev-parse a-dir/mybranch >hash 2>err &&
+ test_must_be_empty err &&
@@ t/t1430-bad-ref-name.sh: test_expect_success 'branch -m can rename refs/heads/-d
+
+ # We do not ignore lower-case
+ cp expect .git/mybranch &&
-+ git rev-parse mybranch >hash 2>err &&
++ env GIT_TEST_GETTEXT_POISON=false \
++ git rev-parse mybranch >hash 2>err &&
+ test_cmp expect hash &&
-+ GIT_TEST_GETTEXT_POISON=false grep "like a pseudoref" err &&
++ grep "like a pseudoref" err &&
+ git -c core.warnNonPseudoRefs=false rev-parse mybranch >hash 2>err &&
+ test_cmp expect hash &&
-+ test_must_be_empty err &&
-+ rm .git/mybranch
++ test_must_be_empty err
+'
+
test_done
Signature · 1 line
2.29.2.222.g5d2a92d10f8