tag - tipos de etiquetas en git

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

Question

¿Cuál es la forma más sencilla de obtener la etiqueta más reciente en Git?

git tag a HEAD
git tag b HEAD^^
git tag c HEAD^
git tag

salida:

a
b
c

¿Debo escribir un script para obtener la fecha y hora de cada etiqueta y compararlas?

Answer 1

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

Podría decir "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, desearía devolver la etiqueta c .

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

Estos podrían ser diferentes, por supuesto:

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

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

Creo que normalmente quieres esta segunda respuesta, más cercana en la historia del desarrollo. Puede averiguarlo utilizando git log v0.2..HEAD etc. para cada etiqueta. Esto le da el número de confirmaciones en HEAD, ya que la ruta que termina en v0.2 divergió de la ruta seguida por HEAD.

Aquí hay una secuencia de comandos de Python que lo hace mediante la iteración de todas las etiquetas que ejecutan esta comprobación, y luego imprimiendo la etiqueta con menos confirmaciones en HEAD ya que la ruta de la etiqueta se desvió:

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

git describe hace algo ligeramente diferente, ya que realiza un seguimiento de (por ejemplo, HEAD) para encontrar la primera etiqueta que se encuentra en un camino de regreso en la historia de HEAD. En términos de git, git describe busca las 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 HEAD, sino un camino que divergió desde allí.

Answer 2

¿Qué hay de malo con todas las sugerencias (excepto la explicación de Matthew Brett , actualizada en este post de respuesta)?

Simplemente ejecute cualquier comando proporcionado por otro en el historial de jQuery Git cuando se encuentre en un punto diferente del historial y verifique el resultado con la representación del historial de etiquetado visual (lo hice por eso ve esta publicación):

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

En la actualidad, muchos proyectos realizan lanzamientos (y, por lo tanto, etiquetado) en una rama separada de la línea principal .

Hay una fuerte razón para esto. Basta con mirar cualquier proyecto JS / CSS bien establecido. Para convenciones de usuarios, llevan archivos de publicación binarios / minificados en DVCS. Naturalmente, como mantenedor del proyecto, no desea desechar el historial de diferencias de su línea principal con blobs binarios inútiles y realizar trabajos de compilación de artefactos 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 la distancia, por lo que podemos decir: ¡oh, la aceleración es la más cercana a mi HEAD !

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

¿Cuál es la etiqueta más cercana en el pasado con respecto a las sucursales en Git?

Actualmente tengo 4 definiciones razonables de distancia entre etiqueta y revisión con disminución de utilidad:

• Longitud del camino más corto desde HEAD para fusionar la base con la etiqueta
• fecha de la base de fusión entre HEAD y la etiqueta
• número de revoluciones alcanzables desde HEAD pero no accesibles desde la etiqueta
• fecha de la etiqueta independientemente de la base de fusión

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

Script que clasifica las etiquetas según la fecha de la base de fusión 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 los proyectos.

Script que clasifica las etiquetas según el número de revoluciones que se pueden alcanzar desde HEAD 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 su proyecto tiene fechas extrañas en las confirmaciones (debido a rebases u otra reescritura de la historia o algún imbécil, olvide reemplazar la batería de la BIOS u otras magias que haga en la historia) use el script anterior.

Para la última opción ( fecha de la etiqueta independientemente de la base de fusión ) para obtener una lista de etiquetas ordenadas por fecha de uso:

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

Para conocer la fecha actual de la revisión use:

$ git log --max-count=1

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

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

Answer 3

¿Qué tal esto?

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

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

Answer 4

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

Edición: también puede proporcionar cualquier nombre de referencia válido, incluso mandos a distancia; es decir, git describe origin/master le dirá la etiqueta más reciente a la que se puede acceder desde origin / master.

Answer 5

Lo siguiente funciona para mí en caso de que necesite las dos últimas 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 confirmación avance. Solo estoy compartiendo en caso de que ayude a alguien.

Answer 6

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

Answer 7

Para obtener la última etiqueta solo en la rama actual / nombre de etiqueta que prefija 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}''

Answer 8

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 de recuento o el campo de clasificación como desee. Parece que tal vez quisiste hacer una pregunta ligeramente diferente, pero esto sí responde a la pregunta tal como la interpreto.

Answer 9

Para obtener la etiqueta más reciente:

git describe --tags

Para obtener la etiqueta anotada más reciente:

git describe --abbrev=0 --tags

Answer 10

Por la pregunta formulada,

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

usted quiere

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

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

Answer 11

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

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

Answer 12

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

Answer 13

Puedes echar un vistazo a git describe , que hace algo parecido a lo que estás preguntando.

Answer 14

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

Answer 15

Si sus etiquetas son clasificables:

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

Answer 16

git describe --abbrev=0 --tags

Si no ve la etiqueta más reciente, asegúrese de obtener el origen antes de ejecutar eso:

git remote update

Answer 17

git describe --tags

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

Answer 18

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 a veces da hashes incorrectos, no sé por qué, pero para mí --max-count 2 no funciona)

así es como puede 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 1.7. *), No hay una cadena "tag:" en la salida; simplemente borre la última llamada sed

Si desea más de 2 etiquetas más recientes, cambie este "sed 2q" a "sed 5q" o lo que necesite

Luego, puede analizar fácilmente cada nombre de etiqueta a variable más o menos.

Answer 19

git tag -l ac* | tail -n1

Obtener la última etiqueta con el prefijo "ac" . Por ejemplo, etiqueta nombrada con ac1.0.0 o ac1.0.5 . Otras etiquetas llamadas 1.0.0 , 1.1.0 serán ignoradas.

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

Consigue la última etiqueta, cuyo primer char es 0-9 . Por lo tanto, esas etiquetas con primer char az serán ignoradas.

Más información

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

git tag -l <pattern>

Enumere las etiquetas con nombres que coincidan con el patrón dado (o todo si no se da ningún patrón). Ejecutar "git tag" sin argumentos también lista todas las etiquetas. El patrón es un comodín de shell (es decir, se combina con fnmatch (3)). Se pueden dar múltiples patrones; Si alguno de ellos coincide, se muestra la etiqueta.

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

Actualizar

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

El orden de clasificación por defecto es el valor configurado para la variable tag.sort si existe, o el orden lexicográfico de lo contrario. Ver git-config (1).

Después de Google, alguien dijo que git 2.8.0 era compatible con la siguiente sintaxis.

git tag --sort=committerdate