¿Cómo obtener el último nombre de la etiqueta en la rama actual en Git?

Para obtener la etiqueta más reciente:

git describe --tags

Para obtener la etiqueta más reciente anotada:

git describe --abbrev=0 --tags

Mostrará la etiqueta de la última confirmación etiquetada en todas las ramas

git describe --tags $(git rev-list --tags --max-count=1)

Para obtener la etiqueta más reciente, puedes hacer:

$ git for-each-ref refs/tags --sort=-taggerdate --format='%(refname)' --count=1

Por supuesto, puede cambiar el argumento count o el campo sort como desee. Parece que usted puede haber querido hacer una pregunta ligeramente diferente, pero esto responde a la pregunta como yo la interpreto.

¿Qué tal esto?

TAG=$(git describe $(git rev-list --tags --max-count=1))

Técnicamente, no necesariamente obtendrás la última etiqueta, sino la última confirmación que está etiquetada, que puede o no ser lo que estás buscando.

git describe --tags

Devuelve la última etiqueta que puede ser vista por la rama actual

"Más reciente" podría tener dos significados en términos de git.

Podría significar, "qué etiqueta tiene la fecha de creación más reciente en el tiempo", y la mayoría de las respuestas aquí son para esa pregunta. En términos de su pregunta, le gustaría devolver tag c.

O podría significar "qué etiqueta es la más cercana en el historial de desarrollo a alguna rama con nombre", generalmente la rama en la que se encuentra, HEAD. En su pregunta, esto devolvería tag a.

Estos pueden ser diferentes de curso:

A->B->C->D->E->F (HEAD)
       \     \
        \     X->Y->Z (v0.2)
         P->Q (v0.1)

Imagine que el desarrollador etiqueta Z como v0.2 el lunes, y luego etiqueta Q como v0.1 el martes. v0.1 es el más reciente, pero v0.2 está más cerca en la historia del desarrollo de la CABEZA, en el sentido de que el camino en el que está comienza en un punto más cercano a la CABEZA.

Creo que normalmente quieres esta segunda respuesta, más cercana en la historia del desarrollo. Puedes averiguarlo usando git log v0.2..HEAD etc para cada etiqueta. Esto le da el número de confirmaciones en HEAD desde que la ruta termina en v0.2 se apartó del camino seguido por HEAD.

Aquí hay un script de Python que lo hace iterando a través de todas las etiquetas que ejecutan esta comprobación, y luego imprimiendo la etiqueta con menos confirmaciones en HEAD desde que la ruta de la etiqueta divergió:

Https://github.com/MacPython/terryfy/blob/master/git-closest-tag

git describe hace algo ligeramente diferente, ya que rastrea desde (por ejemplo) HEAD para encontrar la primera etiqueta que está en un camino de regreso en la historia de HEAD. En git términos, git describe busca etiquetas que son "accesibles" desde HEAD. Por lo tanto, no encontrará etiquetas como v0.2 que no están en el camino de regreso desde la CABEZA, sino un camino que divergió desde allí.

git log --tags --no-walk --pretty="format:%d" | sed 2q | sed 's/[()]//g' | sed s/,[^,]*$// | sed  's ......  '

SI NECESITA MÁS DE UNA ÚLTIMA ETIQUETA

(git describe tags tags a veces da hashes incorrectos, no sé por qué, pero para mí max max-count 2 no funciona)

Así es como puedes obtener una lista con los últimos 2 nombres de etiquetas en orden cronológico inverso, funciona perfectamente en git 1.8.4. Para versiones anteriores de git(como la 1.7.* ), no hay una cadena "tag:" en la salida - simplemente elimine la última llamada sed

Si desea más de 2 últimas etiquetas - cambie este "sed 2q" a "sed 5q" o lo que necesites

Entonces puede analizar fácilmente cada nombre de etiqueta a variable o algo así.

git tag -l ac* | tail -n1

Obtiene la última etiqueta con el prefijo "ac". Por ejemplo, etiqueta nombrada con ac1.0.0, o ac1.0.5. Otras etiquetas nombradas 1.0.0, 1.1.0 será ignorado.

git tag -l [0-9].* | tail -n1

Obtiene la última etiqueta, cuyo primer carácter es 0-9. Por lo tanto, esas etiquetas con el primer char a-z serán ignoradas.

Más información

git tag --help # Help for `git tag`

git tag -l <pattern>

Listar etiquetas con nombres que coinciden con el patrón dado (o todos si no patrón se da). Ejecutar "git tag" sin argumentos también enumera todas las etiquetas. El patrón es un comodín de shell (es decir, emparejado usando fnmatch (3)). Se pueden dar múltiples patrones; si alguno de ellos coincidencias, se muestra la etiqueta.

tail -n <number> # display the last part of a file
tail -n1 # Display the last item 

Actualización

Con git tag --help, sobre el argumento sort. Usará lexicorgraphic order por defecto, si la propiedad tag.sort no existe.

Orden de clasificación el valor predeterminado es el valor configurado para la etiqueta.ordenar variable si existe, o orden lexicográfico de lo contrario. Vea git-config(1).

Después de Google, alguien dijo soporte de git 2.8.0 siguiente sintaxis.

git tag --sort=committerdate

git describe --abbrev=0 --tags

Si no ves la última etiqueta, asegúrate de obtener origin antes de ejecutarla:

git remote update

¿Qué es incorrecto con todas las sugerencias (excepto Matthew Brett explicación, hasta la fecha de este post de respuesta)?

Simplemente ejecute cualquier comando proporcionado por otro en el historial de Git de jQuery cuando esté en un punto diferente del historial y verifique el resultado con visual tagging history representation (I did es por eso que ve este post):{[16]]}

$ git log --graph --all --decorate --oneline --simplify-by-decoration

Hoy en día muchos proyectos realizan lanzamientos (y así etiquetar) en rama separada de mainline .

Hay una razón fuerte para esto. Basta con mirar a cualquier proyecto JS/CSS bien establecido. Para las convenciones de usuario, llevan archivos de liberación binarios / minificados en DVCS. Naturalmente, como mantenedor del proyecto, no desea que su línea principal diff historia con blobs binarios inútiles y realice commit de artefactos de compilación fuera de la línea principal.

Debido a que Git usa DAG y no un historial lineal, es difícil definir la métrica de distancia, por lo que podemos decir-oh que rev es más cercano a mi HEAD!

Comienzo mi propio viaje en (mira dentro, no copié imágenes de prueba de lujo a este largo post):

¿Cuál es la etiqueta más cercana en el pasado con respecto a la ramificación en Git?

Actualmente tengo 4 definición razonable de distancia entre tag y revisión con disminución de utilidad:

• longitud del camino más corto desde HEAD hasta combinar la base con tag
• date of merge base between HEAD and tag
• número de revoluciones que se pueden alcanzar desde la CABEZA pero no desde la etiqueta
• date of tag regardless merge base

No se cómo calcular la longitud del camino más corto.

Script que ordena las etiquetas de acuerdo con fecha de combinar la base entre HEAD y la etiqueta:

$ git tag \
     | while read t; do \
         b=`git merge-base HEAD $t`; \
         echo `git log -n 1 $b --format=%ai` $t; \
       done | sort

Se puede utilizar en la mayoría de proyecto.

Script que ordena las etiquetas según número de revoluciones que se pueden alcanzar desde la CABEZA pero no desde la etiqueta:

$ git tag \
    | while read t; do echo `git rev-list --count $t..HEAD` $t; done \
    | sort -n

Si el historial de tu proyecto tiene fechas extrañas en las confirmaciones (debido a rebases u otra reescritura del historial o algún idiota se olvida de reemplazar la batería del BIOS u otras magias que haces en el historial) usa el script anterior.

Para la última opción ( date of tag regardless merge base ) para obtener la lista de etiquetas ordenadas por fecha uso:

$ git log --tags --simplify-by-decoration --pretty="format:%ci %d" | sort -r

Para conocer la fecha de revisión actual use:

$ git log --max-count=1

Tenga en cuenta que git describe --tagstiene uso en sus propios casos, pero no para encontrar la etiqueta humana más cercana esperada en el historial del proyecto.

NOTA Puede usar las recetas anteriores en cualquier revisión, simplemente reemplace HEAD con lo que desee!

Lo siguiente funciona para mí en caso de que necesite las últimas dos etiquetas (por ejemplo, para generar un registro de cambios entre la etiqueta actual y la etiqueta anterior). Lo he probado solo en situaciones en las que la última etiqueta era HEAD.

PreviousAndCurrentGitTag=`git describe --tags \`git rev-list --tags --abbrev=0 --max-count=2\` --abbrev=0`
PreviousGitTag=`echo $PreviousAndCurrentGitTag | cut -f 2 -d ' '`
CurrentGitTag=`echo $PreviousAndCurrentGitTag | cut -f 1 -d ' '`

GitLog=`git log ${PreviousGitTag}..${CurrentGitTag} --pretty=oneline | sed "s_.\{41\}\(.*\)_; \1_"`

Se adapta a mis necesidades, pero como no soy un asistente de git, estoy seguro de que podría mejorarse aún más. También sospecho que se romperá en caso de que el historial de confirmaciones avance. Sólo estoy compartiendo en caso de que ayude a alguien.

Puede ejecutar: git describe --tags $(git rev-list --tags --max-count=1) hablado aquí: ¿Cómo obtener el último nombre de la etiqueta?

Mi primer pensamiento es que podría usar git rev-list HEAD, que enumera todas las revoluciones en orden cronológico inverso, en combinación con git tag --contains. Cuando encuentras una referencia donde git tag --contains produce una lista no vacía, has encontrado la(s) etiqueta (s) más reciente (s).

Si desea encontrar la última etiqueta que se aplicó en una rama específica, puede intentar lo siguiente:

git describe --tag $(git rev-parse --verify refs/remotes/origin/"branch_name")

Este es un hilo antiguo, pero parece que a mucha gente le falta la respuesta más simple, fácil y correcta a la pregunta de OP: para obtener la última etiqueta para la rama actual , usa git describe HEAD. Terminado.

Editar: también puede proporcionar cualquier nombre de referencia válido, incluso controles remotos; es decir, git describe origin/master le dirá la última etiqueta que se puede alcanzar desde origin/master.

Para obtener la última etiqueta solo en el nombre de la rama/etiqueta actual que prefije con la rama actual, tuve que ejecutar lo siguiente

BRANCH=`git rev-parse --abbrev-ref HEAD` && git describe --tags --abbrev=0 $BRANCH^ | grep $BRANCH

Maestro de rama:

git checkout master

BRANCH=`git rev-parse --abbrev-ref HEAD` && git describe --tags 
--abbrev=0 $BRANCH^ | grep $BRANCH

master-1448

Rama personalizada:

git checkout 9.4

BRANCH=`git rev-parse --abbrev-ref HEAD` && git describe --tags 
--abbrev=0 $BRANCH^ | grep $BRANCH

9.4-6

Y mi necesidad final de incrementar y obtener la etiqueta +1 para el siguiente etiquetado.

BRANCH=`git rev-parse --abbrev-ref HEAD` && git describe --tags  --abbrev=0 $BRANCH^ | grep $BRANCH | awk -F- '{print $NF}'

Para la pregunta hecha,

Cómo obtener el último nombre de la etiqueta en la rama actual

Quieres

git log --first-parent --pretty=%d | grep -m1 tag:

--first-parent le dice a git log que no detalle ningún historial fusionado, --pretty=%d que muestre solo las decoraciones, es decir, los nombres locales para cualquier confirmación. grep -m1 dice "coincidir solo uno", por lo que obtienes solo la etiqueta más reciente.

Si sus etiquetas son clasificables:

git tag --merged $YOUR_BRANCH_NAME | grep "prefix/" | sort | tail -n 1