show-ref: make --head always show the HEAD ref

The docs seem to say that doing

git show-ref --head --tags

would show both the HEAD ref and all the tag refs. However, doing
both --head and either of --tags or --heads would filter out the HEAD
ref.

Also update the documentation to describe the new behavior and add
tests for the show-ref command.

[jc: Doug did proofread the tests, but it was done by me and bugs in
it are mine].

Signed-off-by: Doug Bell <madcityzen@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/Documentation/git-show-ref.txt b/Documentation/git-show-ref.txt
index 5dbcd47fec3b605d0b4b3e6ed47c06cc57f1dd6d..8a628995cfca08b324f6bf1cf52037af31507bdf 100644 (file)
--- a/Documentation/git-show-ref.txt
+++ b/Documentation/git-show-ref.txt
@@ -21,6 +21,8 @@ commit IDs. Results can be filtered using a pattern and tags can be
 dereferenced into object IDs. Additionally, it can be used to test whether a
 particular ref exists.
 
+By default, shows the tags, heads, and remote refs.
+
 The --exclude-existing form is a filter that does the inverse, it shows the
 refs from stdin that don't exist in the local repository.
 
@@ -32,14 +34,14 @@ OPTIONS
 
 --head::
 
-       Show the HEAD reference.
+       Show the HEAD reference, even if it would normally be filtered out.
 
 --tags::
 --heads::
 
-       Limit to only "refs/heads" and "refs/tags", respectively.  These
-       options are not mutually exclusive; when given both, references stored
-       in "refs/heads" and "refs/tags" are displayed.
+       Limit to "refs/heads" and "refs/tags", respectively.  These options
+       are not mutually exclusive; when given both, references stored in
+       "refs/heads" and "refs/tags" are displayed.
 
 -d::
 --dereference::

diff --git a/builtin/show-ref.c b/builtin/show-ref.c
index 8d9b76a02fd115c0285216c27c5232f345d0582d..099c2a45577166748ceb6438e3c4a838f4b3cba3 100644 (file)
--- a/builtin/show-ref.c
+++ b/builtin/show-ref.c
@@ -31,6 +31,9 @@ static int show_ref(const char *refname, const unsigned char *sha1, int flag, vo
        const char *hex;
        unsigned char peeled[20];
 
+       if (show_head && !strcmp(refname, "HEAD"))
+               goto match;
+
        if (tags_only || heads_only) {
                int match;
 
@@ -167,9 +170,10 @@ static const struct option show_ref_options[] = {
        OPT_BOOLEAN(0, "verify", &verify, N_("stricter reference checking, "
                    "requires exact ref path")),
        { OPTION_BOOLEAN, 'h', NULL, &show_head, NULL,
-         N_("show the HEAD reference"),
+         N_("show the HEAD reference, even if it would be filtered out"),
          PARSE_OPT_NOARG | PARSE_OPT_HIDDEN },
-       OPT_BOOLEAN(0, "head", &show_head, N_("show the HEAD reference")),
+       OPT_BOOLEAN(0, "head", &show_head,
+         N_("show the HEAD reference, even if it would be filtered out")),
        OPT_BOOLEAN('d', "dereference", &deref_tags,
                    N_("dereference tags into object IDs")),
        { OPTION_CALLBACK, 's', "hash", &abbrev, N_("n"),

diff --git a/t/t1403-show-ref.sh b/t/t1403-show-ref.sh
new file mode 100755 (executable)
index 0000000..3e500ed
--- /dev/null
+++ b/t/t1403-show-ref.sh
@@ -0,0 +1,167 @@
+#!/bin/sh
+
+test_description='show-ref'
+. ./test-lib.sh
+
+test_expect_success setup '
+       test_commit A &&
+       git tag -f -a -m "annotated A" A &&
+       git checkout -b side &&
+       test_commit B &&
+       git tag -f -a -m "annotated B" B &&
+       git checkout master &&
+       test_commit C &&
+       git branch B A^0
+'
+
+test_expect_success 'show-ref' '
+       echo $(git rev-parse refs/tags/A) refs/tags/A >expect &&
+
+       git show-ref A >actual &&
+       test_cmp expect actual &&
+
+       git show-ref tags/A >actual &&
+       test_cmp expect actual &&
+
+       git show-ref refs/tags/A >actual &&
+       test_cmp expect actual &&
+
+       >expect &&
+
+       test_must_fail git show-ref D >actual
+       test_cmp expect actual
+'
+
+test_expect_success 'show-ref -q' '
+       >expect &&
+
+       git show-ref -q A >actual &&
+       test_cmp expect actual &&
+
+       git show-ref -q tags/A >actual &&
+       test_cmp expect actual &&
+
+       git show-ref -q refs/tags/A >actual &&
+       test_cmp expect actual &&
+
+       test_must_fail git show-ref -q D >actual &&
+       test_cmp expect actual
+'
+
+test_expect_success 'show-ref --verify' '
+       echo $(git rev-parse refs/tags/A) refs/tags/A >expect &&
+
+       git show-ref --verify refs/tags/A >actual &&
+       test_cmp expect actual &&
+
+       >expect &&
+
+       test_must_fail git show-ref --verify A >actual &&
+       test_cmp expect actual &&
+
+       test_must_fail git show-ref --verify tags/A >actual &&
+       test_cmp expect actual &&
+
+       test_must_fail git show-ref --verify D >actual
+       test_cmp expect actual
+'
+
+test_expect_success 'show-ref --verify -q' '
+       >expect &&
+
+       git show-ref --verify -q refs/tags/A >actual &&
+       test_cmp expect actual &&
+
+       test_must_fail git show-ref --verify -q A >actual &&
+       test_cmp expect actual &&
+
+       test_must_fail git show-ref --verify -q tags/A >actual &&
+       test_cmp expect actual &&
+
+       test_must_fail git show-ref --verify -q D >actual
+       test_cmp expect actual
+'
+
+test_expect_success 'show-ref -d' '
+       {
+               echo $(git rev-parse refs/tags/A) refs/tags/A &&
+               echo $(git rev-parse refs/tags/A^0) "refs/tags/A^{}"
+               echo $(git rev-parse refs/tags/C) refs/tags/C
+       } >expect &&
+       git show-ref -d A C >actual &&
+       test_cmp expect actual &&
+
+       git show-ref -d tags/A tags/C >actual &&
+       test_cmp expect actual &&
+
+       git show-ref -d refs/tags/A refs/tags/C >actual &&
+       test_cmp expect actual &&
+
+       echo $(git rev-parse refs/heads/master) refs/heads/master >expect &&
+       git show-ref -d master >actual &&
+       test_cmp expect actual &&
+
+       git show-ref -d heads/master >actual &&
+       test_cmp expect actual &&
+
+       git show-ref -d refs/heads/master >actual &&
+       test_cmp expect actual
+
+       git show-ref -d --verify refs/heads/master >actual &&
+       test_cmp expect actual
+
+       >expect &&
+
+       test_must_fail git show-ref -d --verify master >actual &&
+       test_cmp expect actual &&
+
+       test_must_fail git show-ref -d --verify heads/master >actual &&
+       test_cmp expect actual
+
+'
+
+test_expect_success 'show-ref --heads, --tags, --head, pattern' '
+       for branch in B master side
+       do
+               echo $(git rev-parse refs/heads/$branch) refs/heads/$branch
+       done >expect.heads &&
+       git show-ref --heads >actual &&
+       test_cmp expect.heads actual &&
+
+       for tag in A B C
+       do
+               echo $(git rev-parse refs/tags/$tag) refs/tags/$tag
+       done >expect.tags &&
+       git show-ref --tags >actual &&
+       test_cmp expect.tags actual &&
+
+       cat expect.heads expect.tags >expect &&
+       git show-ref --heads --tags >actual &&
+       test_cmp expect actual &&
+
+       {
+               echo $(git rev-parse HEAD) HEAD &&
+               cat expect.heads expect.tags
+       } >expect &&
+       git show-ref --heads --tags --head >actual &&
+       test_cmp expect actual &&
+
+       {
+               echo $(git rev-parse HEAD) HEAD &&
+               echo $(git rev-parse refs/heads/B) refs/heads/B
+               echo $(git rev-parse refs/tags/B) refs/tags/B
+       } >expect &&
+       git show-ref --head B >actual &&
+       test_cmp expect actual &&
+
+       {
+               echo $(git rev-parse HEAD) HEAD &&
+               echo $(git rev-parse refs/heads/B) refs/heads/B
+               echo $(git rev-parse refs/tags/B) refs/tags/B
+               echo $(git rev-parse refs/tags/B^0) "refs/tags/B^{}"
+       } >expect &&
+       git show-ref --head -d B >actual &&
+       test_cmp expect actual
+'
+
+test_done