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

https://stackoverflow.com/questions/1404796

05-07-2019
|

Pregunta

¿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?

Solución

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

Otros consejos

Para obtener la etiqueta más reciente:

git describe --tags

Para obtener la etiqueta anotada más reciente:

git describe --abbrev=0

Producirá la etiqueta del último commit etiquetado en todas las ramas

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

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

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

Por supuesto, puede cambiar el argumento de conteo o el campo de clasificación según lo desee. Aparece es posible que haya querido hacer una pregunta ligeramente diferente, pero esto responde la pregunta tal como la interpreto.

¿Qué tal esto?

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

Técnicamente, no necesariamente obtendrá la última etiqueta, pero 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 ver la rama actual

" 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 tiempo", y la mayoría de las respuestas aquí son para esa pregunta. En términos de su pregunta, le gustaría devolver la etiqueta c .

O podría decir "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 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 el más reciente, pero v0.2 está más cerca en el historial de desarrollo de HEAD, en el sentido de que la ruta en la que se inicia comienza en un punto más cercano a HEAD .

Creo que generalmente quieres esta segunda respuesta, más cerca 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 un script de Python que lo hace iterando a través de todas las etiquetas que ejecutan esta verificación y luego imprimiendo la etiqueta con la menor cantidad de confirmaciones en HEAD ya 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 una ruta en el historial desde HEAD. En términos de git, git describe busca etiquetas que sean accesibles y accesibles; de HEAD. Por lo tanto, no encontrará etiquetas como v0.2 que no están en la ruta de regreso de HEAD, sino en una ruta que se desvió de allí.

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

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 etiqueta '': '' cadena en la salida: simplemente elimine la última llamada sed

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

Luego puedes analizar fácilmente cada nombre de etiqueta a variable o algo así.

Lo que está mal con todas las sugerencias (excepto la explicación de Matthew Brett , hasta la fecha de esta publicación de respuesta)?

Simplemente ejecute cualquier comando suministrado por otro en el historial de jQuery Git cuando se encuentre en diferentes puntos del historial y verifique el resultado con representación visual del historial de etiquetado (yo sí es por eso que ves esta publicación):

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

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

Hay razones fuertes para esto. Basta con mirar cualquier proyecto JS / CSS bien establecido. Para convenciones de usuarios, llevan archivos de lanzamiento binarios / minificados en DVCS. Naturalmente, como mantenedor del proyecto, no querrá desechar su historial de la línea principal diff con blobs binarios inútiles y realizar confirmaciones 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, la aceleración es la más cercana a mi HEAD !

Comienzo mi propio viaje (mira dentro, no copié imágenes de prueba elegantes en esta larga publicación):

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

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

longitud de la ruta más corta desde HEAD a fusionar base con etiqueta
fecha de fusionar base entre HEAD y la etiqueta
número de revoluciones que se puede acceder desde HEAD pero no se puede acceder desde la etiqueta
fecha de etiqueta independientemente de base de fusión

No sé cómo calcular longitud de la ruta más corta .

El script que clasifica las etiquetas de acuerdo con la fecha de fusionar 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 los proyectos.

Script que clasifica las etiquetas según número de revoluciones que se puede acceder desde HEAD pero no se puede acceder 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 fusionar base ) 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 de revisión actual, 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 Puedes usar las recetas anteriores en cualquier revisión, simplemente reemplaza HEAD con lo que quieras

git tag -l ac* | tail -n1

Obtenga la última etiqueta con el prefijo " ac " . Por ejemplo, la etiqueta nombrada con ac1.0.0 o ac1.0.5 . Se ignorarán otras etiquetas llamadas 1.0.0 , 1.1.0 .

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

Obtenga la última etiqueta, cuyo primer carácter es 0-9 . Por lo tanto, las etiquetas con el primer carácter a-z se ignorarán.

Más información

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

git tag -l <pattern>

Lista de etiquetas con nombres que coinciden con el patrón dado (o todos si no se da el patrón). Ejecutando " git tag " sin argumentos también listas 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

Actualizar

Con git tag --help , sobre el argumento sort . Utilizará orden lexicorográfico de forma predeterminada, si la propiedad tag.sort no existe.

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

Después de Google, alguien dijo la compatibilidad con git 2.8.0 siguiendo la sintaxis.

git tag --sort=committerdate

git describe --abbrev = 0 --tags

Si no ve la última etiqueta, asegúrese de obtener el origen antes de ejecutar eso:

actualización remota git

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 probé 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.

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 encuentra una referencia donde git tag --contains produce una lista no vacía, ha 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 . Hecho.

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

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 sucursal:

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 formulada,

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

que quieras

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

- first-parent le dice a git log que no detalle ninguna historia combinada, --pretty =% d dice que muestre solo la Decoraciones, es decir, nombres locales para cualquier compromiso. grep -m1 dice "solo una " ;, así que obtienes la etiqueta más reciente.

si sus etiquetas se pueden ordenar:

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

Licenciado bajo: CC-BY-SA con atribución

No afiliado a StackOverflow