Como saber para qual commit uma tag aponta no Git?

Eu tenho um monte de tags não anotadas no repositório e quero descobrir para qual commit elas apontam. Existe um comando que apenas listará as tags e seus SHAs de confirmação? Verificando a etiqueta e olhando para a cabeça parece um pouco trabalhoso para mim.

Atualizar

Percebi, depois de analisar as respostas, que o que realmente queria era simplesmente olhar para o histórico que antecedeu a marca, o que git log <tagname>é suficiente.

A resposta marcada como resposta é útil para obter uma lista de tags e seus commits, que foi o que perguntei. Com um pouco de hackery de shell, tenho certeza de que é possível transformá-los em mensagem de confirmação do SHA +.

Uma maneira de fazer isso seria com git rev-list. A seguir, será exibida a confirmação para a qual uma tag aponta:

$ git rev-list -n 1 $TAG

Você pode adicioná-lo como um alias ~/.gitconfigse você o usa muito:

[alias]
  tagcommit = rev-list -n 1

E depois chame-o com:

$ git tagcommit $TAG

git show-ref --tags

Por exemplo, git show-ref --abbrev=7 --tagsmostrará algo como o seguinte:

f727215 refs/tags/v2.16.0
56072ac refs/tags/v2.17.0
b670805 refs/tags/v2.17.1
250ed01 refs/tags/v2.17.2

Apenas use git show <tag>

No entanto, também despeja diffs de confirmação. Para omitir essas diferenças, use git log -1 <tag>. (Obrigado a @DolphinDream e @demisx!)

No meu repositório, git show-ref TAGmostra o hash da tag, não o hash do commit para o qual aponta.

git show-ref --dereference TAG mostra, adicionalmente, o commit que está sendo apontado.

De Igor Zevaka :

Sumário

Como existem cerca de 4 respostas quase igualmente aceitáveis ​​e diferentes, irei resumir todas as maneiras diferentes de identificar uma etiqueta.

1. git rev-list -1 $TAG( resposta ) git rev-listproduz as confirmações que levam à $TAGsemelhante, git logmas apenas mostrando o SHA1 da confirmação. A -1limita a saída para a cometê-lo aponta.

2. git show-ref --tags( resposta ) mostrará todas as tags (locais e buscadas no controle remoto) e seus SHA1s.

3. git show-ref $TAG( resposta ) mostrará a tag e seu caminho junto com o SHA1.

4. git rev-parse $TAG( resposta ) mostrará o SHA1 de uma tag não anotada.

5. git rev-parse --verify $TAG^{commit}( resposta ) mostrará um SHA1 de tags anotadas e não anotadas. No Windows, use git rev-parse --verify %TAG%^^^^{commit}(quatro chapéus).

6. cat .git/refs/tags/*ou cat .git/packed-refs( resposta ), dependendo de a etiqueta ser local ou buscada remotamente.

Usar

git rev-parse --verify <tag>^{commit}

(que retornaria o SHA-1 de uma confirmação mesmo para a tag anotada).

git show-ref <tag>também funcionaria se <tag>não estiver anotado. E sempre existe git for-each-ref(consulte a documentação para obter detalhes).

Que tal agora:

git log -1 $TAGNAME

OU

git log -1 origin/$TAGNAME

Para obter o sha / hash do commit ao qual uma tag se refere (não o sha da tag):

git rev-list -1 <tag>

Eu também gostaria de saber o caminho "certo", mas, enquanto isso, você pode fazer o seguinte:

git show mytag | head -1    

Embora isso seja bastante antigo, pensei em apontar um recurso interessante que acabei de encontrar para listar tags com commits:

git log --decorate=full

Ele mostrará os ramos que terminam / iniciam em uma confirmação e as tags para confirmações.

Você também pode obter uma imagem mais fácil de interpretar de onde as tags apontam para o uso

git log --graph |git name-rev --stdin --tags |less

e depois vá até a tag que você está procurando /.

Uma visão mais compacta ( --pretty=oneline) e todas as cabeças ( -a) também podem ajudar:

git log -a --pretty=oneline --graph |git name-rev --stdin --tags |less

Parece um pouco assustador, mas também pode ser alternativo, ~/.gitconfigse necessário.

~/.gitconfig

[alias]
ls-tags = !git log -a --pretty=oneline --graph |git name-rev --stdin --tags |less

Resposta curta pós-Git-2

Eu sei que essa pergunta está aqui há um bom tempo. E a resposta do CB Bailey é 100% correta:git show-ref --tags --abbrev

Eu gosto mais deste, pois usa git tag:

git tag --list --format '%(refname:short) %(objectname:short)'

Simples. Baixo.

PS alias isso como git taglistcom este comando:

git config --global alias.taglist "tag --list --format '%(refname:short) %(objectname:short)'"

Na lista de discussão git , eis a maneira de obter a lista de hashes de confirmação para tags com desreferenciação automática para tags anotadas:

git for-each-ref --format='%(if)%(*objectname)%(then)%(*objectname)%(else)%(objectname)%(end) %(refname)' refs/tags

Isso não mostra os nomes dos arquivos, mas pelo menos você percebe o repositório.

cat .git/refs/tags/*

Cada arquivo nesse diretório contém um SHA de confirmação apontando para uma confirmação.

eu também gostaria de saber o caminho certo , mas você sempre pode espiar:

$ cat .git/packed-refs 

ou:

$ cat .git/refs/tags/*

Isso fornecerá o hash SHA1 atual

Hash de confirmação abreviado

git show <tag> --format="%h" --> 42e646e

Confirmar hash

git show <tag> --format="%H" --> 42e646ea3483e156c58cf68925545fffaf4fb280

Se você deseja ver os detalhes da tag SOMETAG (tagger, date, etc), o hash do commit para o qual ele aponta e um pouco de informações sobre o commit, mas sem o diff completo, tente

git show --name-status SOMETAG

Exemplo de saída:

tag SOMETAG
Tagger: ....
Date:   Thu Jan 26 17:40:53 2017 +0100

 .... tag message .......

commit 9f00ce27c924c7e972e96be7392918b826a3fad9
Author: .............
Date:   Thu Jan 26 17:38:35 2017 +0100

 .... commit message .......

..... list of changed files with their change-status (like git log --name-status) .....

Portanto, eu tenho um monte de pastas de lançamento, nas quais essas pastas podem ser retiradas de um de alguns repositórios diferentes e podem ser dev, qa ou ramificações principais ou podem ser liberações de produção, retiradas de uma tag, e a tag pode ser anotado ou não. Eu tenho um script que irá olhar para a pasta de destino e voltar uma resposta no formulário -. O problema é que versões diferentes do git retornam status diferente 'para uma verificação de tags.

Por isso, achei que git show-ref --tagsfuncionou inicialmente, exceto pelas tags anotadas. No entanto, a adição de -d adicionou uma entrada separada à lista de tags, uma para a tag e a outra para a anotação (o commit da anotação foi identificado como ^ {}, que eu retirei com o sed).

Portanto, este é o núcleo do meu script, para quem quiser: -

REPO=`git --git-dir=${TARGET} remote show origin -n | \
         grep "Fetch URL:" | \
         sed -E "s/^.*\/(.*)$/\1/" | \
         sed "s/.git$//"`

TAG=`git --git-dir=${TARGET} show-ref -d --tags | \
         grep \`git --git-dir=${TARGET} show --quiet --format=format:%H HEAD\` | \
         cut -d\  -f2 | \
         cut -d/ -f3 | \
         sed "s/\^{}$//"`

if [ "${TAG}" == "" ] ; then 
  BRANCH=`git --git-dir=${TARGET} show-ref --heads | \
         grep \`git --git-dir=${TARGET} show --quiet --format=format:%H HEAD\` | \
         cut -d\  -f2 | \
         cut -d/ -f3`
  TAG=${BRANCH}
fi

Pode usar abaixo, ele dará o hash de confirmação
git show -s --format=%H <tag>^{commit}

Se o hash de confirmação abreviado for necessário, git show -s --format=%h <tag>^{commit}