Come dire a quale commit punta un tag in Git?

Ho un sacco di tag non annotati nel repository e voglio capire a quale commit fanno riferimento. Esiste un comando che elencherà solo i tag e i loro SHA di commit? Controllare il tag e guardare HEAD mi sembra un po 'troppo laborioso.

Aggiornare

Mi sono reso conto dopo aver esaminato le risposte che quello che volevo veramente era semplicemente guardare la storia che portava al tag, per cui git log <tagname>è sufficiente.

La risposta contrassegnata come risposta è utile per ottenere un elenco di tag e relativi commit, che è quello che ho chiesto. Con un po 'di hacker di shell sono sicuro che è possibile trasformarli in messaggio SHA + Commit.

Un modo per farlo sarebbe con git rev-list. Di seguito verrà generato il commit a cui punta un tag:

$ git rev-list -n 1 $TAG

Puoi aggiungerlo come alias ~/.gitconfigse lo usi molto:

[alias]
  tagcommit = rev-list -n 1

E poi chiamalo con:

$ git tagcommit $TAG

git show-ref --tags

Ad esempio, git show-ref --abbrev=7 --tagsti mostrerà qualcosa di simile al seguente:

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

Basta usare git show <tag>

Tuttavia, scarica anche le differenze di commit. Per omettere quelle differenze, usa git log -1 <tag>. (Grazie a @DolphinDream e @demisx!)

Sul mio repository, git show-ref TAGmostra l'hash del tag, non l'hash del commit a cui punta.

git show-ref --dereference TAG mostra, inoltre, il commit indicato.

Da Igor Zevaka :

Sommario

Dal momento che ci sono circa 4 risposte quasi ugualmente accettabili ma diverse, riassumerò tutti i diversi modi di scuoiare un tag.

1. git rev-list -1 $TAG( risposta ). git rev-listgenera i commit che portano al $TAGsimile git logma mostrano solo SHA1 del commit. L' -1limita l'uscita al commit punta a.

2. git show-ref --tags( risposta ) mostrerà tutti i tag (locali e recuperati da remoto) e i loro SHA1.

3. git show-ref $TAG( risposta ) mostrerà il tag e il suo percorso insieme a SHA1.

4. git rev-parse $TAG( risposta ) mostrerà SHA1 di un tag non annotato.

5. git rev-parse --verify $TAG^{commit}( risposta ) mostrerà un SHA1 di tag sia annotati che non annotati. Su Windows usa git rev-parse --verify %TAG%^^^^{commit}(quattro cappelli).

6. cat .git/refs/tags/*o cat .git/packed-refs( risposta ) a seconda che il tag sia locale o recuperato da remoto.

Uso

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

(che restituirebbe SHA-1 di un commit anche per tag annotato).

git show-ref <tag>funzionerebbe anche se <tag>non fosse annotato. E c'è sempre git for-each-ref(vedere la documentazione per i dettagli).

Cosa ne pensi di questo:

git log -1 $TAGNAME

O

git log -1 origin/$TAGNAME

Per ottenere lo sha / hash del commit a cui fa riferimento un tag (non lo sha del tag):

git rev-list -1 <tag>

Mi piacerebbe anche conoscere il modo "giusto", ma nel frattempo puoi farlo:

git show mytag | head -1    

Anche se questo è piuttosto vecchio, ho pensato di sottolineare una caratteristica interessante che ho appena trovato per elencare i tag con commit:

git log --decorate=full

Mostrerà i rami che terminano / iniziano a un commit e i tag per i commit.

Potresti anche ottenere un'immagine più facile da interpretare di dove i tag puntano a utilizzare

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

e quindi scorrere fino al tag che stai cercando tramite /.

Una vista più compatta ( --pretty=oneline) più tutte le teste ( -a) potrebbe anche aiutare:

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

Sembra un po 'terrificante, ma potrebbe anche essere aliasato ~/.gitconfigse necessario.

~/.gitconfig

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

Breve risposta post-Git-2

So che questa domanda è in discussione da un po 'di tempo. E la risposta di CB Bailey è corretta al 100%:git show-ref --tags --abbrev

Mi piace di più perché utilizza git tag:

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

Semplice. Corto.

PS alias come git taglistcon questo comando:

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

Dalla mailing list di git , ecco il modo per ottenere l'elenco di hash di commit per tag con dereferenziazione automatica per tag con annotazioni:

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

Questo non mostra i nomi dei file, ma almeno hai un'idea del repository.

cat .git/refs/tags/*

Ogni file in quella directory contiene un SHA di commit che punta a un commit.

Mi piacerebbe anche sapere nel modo giusto , ma puoi sempre dare un'occhiata anche a:

$ cat .git/packed-refs 

o:

$ cat .git/refs/tags/*

Questo ti porterà l'attuale hash SHA1

Abbreviato Commit Hash

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

Commit Hash

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

Se desideri vedere i dettagli del tag SOMETAG (tagger, data, ecc.), L'hash del commit a cui punta e un po 'di informazioni sul commit ma senza il diff completo, prova

git show --name-status SOMETAG

Esempio di output:

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) .....

Quindi ho un sacco di cartelle di rilascio, in cui quelle cartelle possono essere estratte da uno di alcuni repository diversi e possono essere dev, qa o rami master o possono essere versioni di produzione, estratte da un tag e il tag può essere annotato o no. Ho uno script che guarderà la cartella di destinazione e tornerà una risposta nel modulo -. Il problema è che versioni diverse di git restituiscono uno stato diverso 'per un checkout di tag.

Così ho trovato git show-ref --tags funzionato inizialmente, ad eccezione dei tag annotati. Tuttavia aggiungendo -d è stata aggiunta una voce separata all'elenco dei tag, uno per il tag, l'altro per l'annotazione (il commit delle annotazioni è stato identificato come ^ {} che ho eliminato con sed).

Quindi questo è il nocciolo della mia sceneggiatura, per chiunque lo voglia: -

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

Può usare sotto, darà l'hash di commit
git show -s --format=%H <tag>^{commit}

Se è richiesto l'hash di commit abbreviato, git show -s --format=%h <tag>^{commit}