¿Cómo saber a qué punto apunta una etiqueta en Git?

Tengo un montón de etiquetas sin anotar en el repositorio y quiero averiguar a qué compromiso apuntan. ¿Hay un comando que solo enumere las etiquetas y sus SHA de confirmación? Revisar la etiqueta y mirar la CABEZA me parece un poco laborioso.

Actualizar

Después de leer las respuestas, me di cuenta de que lo que realmente quería era simplemente mirar el historial que llevaba a la etiqueta, para lo cual git log <tagname>es suficiente.

La respuesta que está marcada como respuesta es útil para obtener una lista de etiquetas y sus confirmaciones, que es lo que pregunté. Con un poco de piratería informática, estoy seguro de que es posible transformarlos en mensajes SHA + Commit.

Una forma de hacer esto sería con git rev-list. Lo siguiente generará la confirmación a la que apunta una etiqueta:

$ git rev-list -n 1 $TAG

Puede agregarlo como un alias ~/.gitconfigsi lo usa mucho:

[alias]
  tagcommit = rev-list -n 1

Y luego llámalo con:

$ git tagcommit $TAG

git show-ref --tags

Por ejemplo, git show-ref --abbrev=7 --tagsle mostrará algo como lo siguiente:

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

Solo usa git show <tag>

Sin embargo, también vuelca las diferencias de confirmación. Para omitir esas diferencias, use git log -1 <tag>. (¡Gracias a @DolphinDream y @demisx!)

En mi repositorio, git show-ref TAGmuestra el hash de la etiqueta, no el hash del commit al que apunta.

git show-ref --dereference TAG muestra, además, el commit al que se apunta.

De Igor Zevaka :

Resumen

Como hay alrededor de 4 respuestas casi igualmente aceptables pero diferentes, resumiré todas las diferentes formas de pelar una etiqueta.

1. git rev-list -1 $TAG( respuesta ) git rev-listgenera los commits que conducen al $TAGsimilar git logpero solo muestran el SHA1 del commit. El -1limita la salida a la confirmación tiene que apunta a.

2. git show-ref --tags( respuesta ) mostrará todas las etiquetas (locales y obtenidas de forma remota) y sus SHA1.

3. git show-ref $TAG( respuesta ) mostrará la etiqueta y su ruta junto con el SHA1.

4. git rev-parse $TAG( respuesta ) mostrará el SHA1 de una etiqueta sin anotar.

5. git rev-parse --verify $TAG^{commit}( respuesta ) mostrará un SHA1 de las etiquetas anotadas y no anotadas. En uso de Windows git rev-parse --verify %TAG%^^^^{commit}(cuatro sombreros).

6. cat .git/refs/tags/*o cat .git/packed-refs( respuesta ) dependiendo de si la etiqueta es local o no desde el remoto.

Utilizar

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

(que devolvería SHA-1 de una confirmación incluso para la etiqueta anotada).

git show-ref <tag>también funcionaría si <tag>no se anota. Y siempre hay git for-each-ref(ver documentación para más detalles).

Qué tal esto:

git log -1 $TAGNAME

O

git log -1 origin/$TAGNAME

Para obtener el sha / hash del commit al que se refiere una etiqueta (no el sha de la etiqueta):

git rev-list -1 <tag>

También me gustaría saber la forma "correcta", pero mientras tanto, puedes hacer esto:

git show mytag | head -1    

Aunque esto es bastante antiguo, pensé en señalar una característica interesante que acabo de encontrar para enumerar etiquetas con commits:

git log --decorate=full

Mostrará las ramas que terminan / comienzan en una confirmación, y las etiquetas para las confirmaciones.

También podría obtener una imagen más fácil de interpretar de dónde apuntan las etiquetas al uso

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

y luego desplácese hasta la etiqueta que está buscando a través de /.

Una vista más compacta ( --pretty=oneline) más todas las cabezas ( -a) también podría ayudar:

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

Parece un poco aterrador, pero también podría ser alias ~/.gitconfigsi es necesario.

~/.gitconfig

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

Respuesta corta post-Git-2

Sé que esta pregunta ha estado aquí por bastante tiempo. Y la respuesta de CB Bailey es 100% correcta:git show-ref --tags --abbrev

Este me gusta más porque usa git tag:

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

Simple. Corto.

PS alias como git taglistcon este comando:

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

Desde la lista de correo de git , esta es la forma de obtener la lista de hashes de confirmación para etiquetas con desreferencia automática para etiquetas anotadas:

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

Esto no muestra los nombres de archivo, pero al menos tiene una idea del repositorio.

cat .git/refs/tags/*

Cada archivo en ese directorio contiene una confirmación SHA que apunta a una confirmación.

También me gustaría saber la forma correcta , pero siempre puedes echar un vistazo a:

$ cat .git/packed-refs 

o:

$ cat .git/refs/tags/*

Esto te dará el hash SHA1 actual

Hash de confirmación abreviado

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

Commit Hash

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

Si desea ver los detalles de la etiqueta SOMETAG (etiquetador, fecha, etc.), el hash del compromiso al que apunta y un poco de información sobre el compromiso, pero sin la diferencia completa, intente

git show --name-status SOMETAG

Salida de ejemplo:

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

Así que tengo una gran cantidad de carpetas de lanzamiento, donde esas carpetas pueden extraerse de uno de los pocos repositorios diferentes, y pueden ser dev, qa o ramas maestras o pueden ser lanzamientos de producción, retirados de una etiqueta, y la etiqueta puede ser anotado o no. Tengo un script que buscará en la carpeta de destino y recibirá una respuesta en el formulario -. El problema es que las diferentes versiones de git devuelven un estado diferente 'para el pago de una etiqueta.

Entonces encontré que git show-ref --tagsfuncionó inicialmente, excepto por las etiquetas anotadas. Sin embargo, agregar -d agregó una entrada separada a la lista de etiquetas, una para la etiqueta y la otra para la anotación (la confirmación de anotación se identificó como ^ {} que eliminé con sed).

Este es el núcleo de mi script, para cualquiera que lo quiera:

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

Se puede usar a continuación, le dará el hash de confirmación
git show -s --format=%H <tag>^{commit}

Si se requiere un hash abreviado de commit, git show -s --format=%h <tag>^{commit}