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

411

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.

Igor Zevaka
fuente
3
Quiero señalar que git show-refmuestra sha de la etiqueta, no sha de la revisión del repositorio. $ git show-ref test 08b9c774ab20e5bdb638339cf4ea2c124b0dae54 refs / tags / test $ git checkout test HEAD ahora está en c7f8831 ... $ git checkout 08b9c77 HEAD ahora está en c7f8831 ...
Konstantin Pelepelin
si sus etiquetas están anotadas, entonces necesita--dereference
Trevor Boyd Smith

Respuestas:

348

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
mipadi
fuente
30
¿Por qué no usar git rev-parse <tag>? O git rev-list -1 <tag>?
Jakub Narębski, el
52
@ Jakub: git rev-parse $TAGdevuelve el SHA1 del objeto de etiqueta, no el commit al que apunta. git rev-list -1funciona, sin embargo.
mipadi
11
@mipadi: para las etiquetas no anotadas no tiene importancia; para las etiquetas anotadas puede utilizar git rev-parse $TAG^{commit}o git rev-parse $TAG^{}eliminar la referencia anotada / etiqueta firmada
Jakub Narębski
55
Puede usar:git rev-list $TAG --max-count=1
b73
44
@RobinHsu: si tiene etiquetas anotadas , eso se crea con git tag -ao git tag -s, entonces git rev-parse <tag>le daría SHA-1 de un objeto de etiqueta en sí mismo, mientras git rev-list -1 <tag>le daría SHA-1 de commit (revisión) al que apunta, igual que git rev-parse <tag>^{commit}. HTH.
Jakub Narębski
240
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
CB Bailey
fuente
Gracias por eso, en realidad esto oculta la semántica de mirar a ninguno .git/packed-refso.git/refs/tags/*
Igor Zevaka
3
hmmm tiene un comportamiento extraño en mi repositorio: git tag -a v0.1.1-alpha a9dcc1f24cacde535523bddc22f4c69467428550; git show-ref --tags -> b784145a9a71478337f5ceae30aaac4e1b955ee5 refs / tags / v0.1.1-alpha; ver la respuesta de Jakub Narebski
NickSoft
66
esto funciona, aunque me pregunto ¿no tendría sentido git tag --verbosemostrarlos también?
nonopolaridad
34
Esto mostrará la referencia de la etiqueta en sí, no el compromiso al que apunta la etiqueta. Debe agregar el -dindicador para obtener el compromiso referenciado (en una segunda línea).
Old Pro
44
@CharlesBailey, bastante justo, pero la pregunta y las respuestas se han transformado para incluir etiquetas anotadas y el hecho de que se git show-refcomporta de manera diferente en los dos tipos diferentes de etiquetas no es obvio o de conocimiento común.
Old Pro
104

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

Hlung
fuente
77
En SO, cuando una pregunta tiene muchas respuestas posibles diferentes, las respuestas que se publican primero se votan primero, colocándolas en la parte superior de la lista y obteniendo así más votos positivos más adelante. Este es un ciclo de retroalimentación parcial basado en la velocidad de respuesta sobre la calidad de la respuesta. Con suficiente imaginación, este problema podría solucionarse.
samthebest
66
¿"La mejor solución" para qué? Si el interés está en descubrir el SHA de un commit, los puntos de etiqueta al "git show <mytag>" NO son la mejor solución. Este comando mostrará todo el diff que introduce el commit. Para enumerar solo el SHA del commit, la etiqueta apunta a "git rev-list <mytag> -n 1" es la solución correcta.
DolphinDream
Esta no es la respuesta a la pregunta del OP. git show <tag>muestra el diff, no el commit al que apunta la etiqueta.
demisx
@demisx ¿De qué estás hablando? Definitivamente muestra el hash de confirmación, junto con el etiquetador, la fecha y otra información. Intentalo.
Hlung
44
@Hlung Como señaló @DolphinDream, git showarroja muchas más cosas en la pantalla que no necesitan estar allí. Oscurece el hash de confirmación real que uno está buscando. Un mejor comando es git log -1 [tag-name]o git log -1 --pretty=oneline [tag-name]si quieres oneliners.
Demisx
40

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.

orip
fuente
34

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.

usuario456814
fuente
33

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

Jakub Narębski
fuente
11
Prefiero lo git rev-parse <tag>~0que también parece funcionar y no requiere un escape especial en Windows (en el que se necesitan cuatro sombreros (^) en lugar de uno). El sufijo ~<number>da el <número> commit padre, por lo tanto, ~0produce el compromiso en sí. Por cierto, ^0también es una abreviatura válida para el ^{commit}sufijo de revisión.
Attila
15

Qué tal esto:

git log -1 $TAGNAME

O

git log -1 origin/$TAGNAME
Tuong Le
fuente
10

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

git rev-list -1 <tag>

Daniel Little
fuente
8

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

git show mytag | head -1    
gahooa
fuente
Con el título de compromisogit show --oneline mytag | head -1
Stphane
7

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.

Terrence Reilly
fuente
4

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
Antony Hatchkins
fuente
4

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)'"
Jesper Rønn-Jensen
fuente
3

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
anatoly techtonik
fuente
2

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.

Peter Stuifzand
fuente
Esto no funcionó ya que, creo, saqué las etiquetas del control remoto. .git/packed-refsfuncionó sin embargo.
Igor Zevaka
2

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/*
miku
fuente
Correcto, por lo que el comportamiento de las referencias empaquetadas y las referencias / etiquetas es algo diferente, las referencias empaquetadas es un archivo de texto que contiene etiquetas y SHA, mientras que las referencias / etiquetas / es un directorio con archivos de texto con el nombre de una etiqueta que contiene el SHA. De hecho, creo que la forma correcta de hacerlo es con git rev-list.
Igor Zevaka
2

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
Louis
fuente
1
no parece funcionar en la versión que tengo, pero git log <tag> -n 1 --pretty=%H
Andy
2

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) .....
Avy Sharell
fuente
0

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
sibaz
fuente
0

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}

Reddysekhar Gaduputi
fuente