Come ottenere l'ultimo nome tag nell'attuale ramo in Git?

https://stackoverflow.com/questions/1404796

05-07-2019
|

Domanda

Qual è il modo più semplice per ottenere il tag più recente in Git?

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

uscita:

a
b
c

Devo scrivere uno script per ottenere il datetime di ogni tag e confrontarlo?

Soluzione

Puoi dare un'occhiata a git descritto , che fa qualcosa di simile a quello che stai chiedendo.

Altri suggerimenti

Per ottenere il tag più recente:

git describe --tags

Per ottenere il tag annotato più recente:

git describe --abbrev=0

Produrrà il tag dell'ultimo commit taggato su tutti i rami

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

Per ottenere il tag più recente, puoi fare:

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

Ovviamente, puoi modificare l'argomento count o il campo di ordinamento come desiderato. Sembra che potresti aver pensato di porre una domanda leggermente diversa, ma questo risponde alla domanda mentre la interpreto.

Che ne dici di questo?

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

Tecnicamente, non otterrai necessariamente il tag più recente, ma l'ultimo commit che è taggato, che potrebbe essere o meno la cosa che stai cercando.

git descritto --tags

restituisce l'ultimo tag che può essere visto dal ramo corrente

" Più recenti " potrebbe avere due significati in termini di git.

Potresti voler dire, "quale tag ha la data di creazione più recente nel tempo" e la maggior parte delle risposte qui sono per quella domanda. In termini di domanda, si desidera restituire il tag c .

Oppure potresti intendere " quale tag è il più vicino nella storia dello sviluppo ad un ramo chiamato " ;, di solito il ramo su cui ti trovi, HEAD . Nella tua domanda, questo restituirebbe il tag a .

Questi potrebbero ovviamente essere diversi:

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

Immagina che lo sviluppatore abbia taggato Z come v0.2 lunedì, e quindi taggato Q come v0. 1 martedì. v0.1 è il più recente, ma v0.2 è più vicino nella storia dello sviluppo a HEAD, nel senso che il percorso su cui si trova inizia in un punto più vicino a HEAD .

Penso che di solito desideri questa seconda risposta, più vicina alla storia dello sviluppo. Puoi scoprirlo usando git log v0.2..HEAD ecc per ogni tag. Questo ti dà il numero di commit su HEAD poiché il percorso che termina in v0.2 è divergente dal percorso seguito da HEAD.

Ecco uno script Python che lo fa ripetendo tutti i tag che eseguono questo controllo e quindi stampando il tag con il minor numero di commit su HEAD poiché il percorso del tag è divergente:

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

git descritto fa qualcosa di leggermente diverso, in quanto ritorna da (ad esempio) HEAD per trovare il primo tag che si trova su un percorso nella storia da HEAD. In termini git, git descrivono cerca tag che sono " raggiungibili " da HEAD. Pertanto non troverà tag come v0.2 che non si trovano sul percorso di ritorno da HEAD, ma un percorso divergente da lì.

Puoi eseguire: git descritto --tags $ (git rev-list --tags --max-count = 1) parlato qui: Come ottenere il nome tag più recente?

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

SE AVETE BISOGNO DI PIÙ DI UN ULTIMO TAG

(git descrivono - a volte i tag danno hash errati, non so perché, ma per me --max-count 2 non funziona)

ecco come puoi ottenere l'elenco con gli ultimi 2 nomi di tag in ordine cronologico inverso, funziona perfettamente su git 1.8.4. Per le versioni precedenti di git (come 1.7. *), Non esiste un tag ": " stringa nell'output: basta eliminare l'ultima chiamata sed

Se desideri più di 2 tag più recenti, cambia questo " sed 2q " a "sed 5q" o qualunque cosa ti serva

Quindi puoi facilmente analizzare ogni nome di tag in una variabile o così.

Che cos'è sbagliato con tutti i suggerimenti (tranne Matthew Brett , fino a data questo post di risposta)?

Esegui qualsiasi comando fornito da altri sulla cronologia di jQuery Git quando ti trovi in ?? diversi punti della storia e controlla il risultato con rappresentazione della cronologia dei tag visivi (< ecco perché vedi questo post):

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

Oggi molti progetti eseguono rilasci (e quindi tag) in un ramo separato dalla linea principale .

Ci sono validi motivi per questo. Guarda tutti i progetti JS / CSS ben consolidati. Per le convenzioni degli utenti portano file di rilascio binari / minimizzati in DVCS. Naturalmente, in qualità di manutentore del progetto, non vuoi eliminare la tua storia principale diff con inutili BLOB binari ed eseguire il commit di manufatti di costruzione fuori dalla linea principale .

Poiché Git utilizza DAG e non una cronologia lineare - è difficile definire la metrica della distanza quindi possiamo dire - oh, il rev è il più vicino al mio HEAD !

Inizio il mio viaggio (guarda dentro, non ho copiato immagini di prova fantasiose in questo lungo post):

Qual è il più vicino tag in passato rispetto alla ramificazione in Git?

Attualmente ho 4 definizioni ragionevoli di distanza tra tag e revisione con riduzione dell'utilità:

lunghezza del percorso più breve da HEAD a unisci base con tag
data di unisci base tra HEAD e tag
numero di giri raggiungibili da HEAD ma non raggiungibili dal tag
data del tag indipendentemente da unisci base

Non so come calcolare la lunghezza del percorso più breve .

Script che ordina i tag in base a data di unisci base tra HEAD e tag:

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

Utilizzabile sulla maggior parte dei progetti.

Script che ordina i tag in base al numero di giri raggiungibili da HEAD ma non raggiungibili dal tag:

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

Se la cronologia del tuo progetto ha date strane su commit (a causa di ribassi o un'altra riscrittura della cronologia o qualche idiota dimentica di sostituire la batteria del BIOS o altre magie che fai sulla storia) usa lo script sopra.

Per l'ultima opzione ( data del tag indipendentemente da unisci base ) per ottenere un elenco di tag ordinati per data utilizzare:

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

Per conoscere la data di revisione corrente utilizzare:

$ git log --max-count=1

Nota che git descrivono --tags hanno un uso sui propri casi ma non per trovare tag umano più vicino previsto nella cronologia del progetto .

NOTA Puoi utilizzare le ricette sopra riportate su qualsiasi revisione, basta sostituire HEAD con quello che vuoi!

git tag -l ac* | tail -n1

Ottieni l'ultimo tag con prefisso " ac " . Ad esempio, tag denominato con ac1.0.0 o ac1.0.5 . Altri tag denominati 1.0.0 , 1.1.0 verranno ignorati.

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

Ottieni l'ultimo tag, il cui primo carattere è 0-9 . Pertanto, quei tag con il primo carattere a-z verranno ignorati.

Ulteriori informazioni

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

git tag -l <pattern>

Elenca i tag con nomi che corrispondono al modello dato (o tutti se no modello è dato). Esecuzione di " tag git " senza argomenti anche elenchi tutti i tag. Il modello è un carattere jolly shell (cioè, abbinato usando fnmatch (3)). Si possono dare più schemi; se qualcuno di loro corrispondenze, viene visualizzato il tag.

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

Aggiornamento

Con git tag --help , sull'argomento sort . Userà ordine lessicografico per impostazione predefinita, se la proprietà tag.sort non esiste.

Ordinamento il valore predefinito è configurato per la variabile tag.sort, se presente esiste, o ordine lessicografico altrimenti. Vedi git-config (1).

Dopo google, qualcuno ha detto supporto git 2.8.0 seguendo la sintassi.

git tag --sort=committerdate

git descritto --abbrev = 0 --tags

Se non vedi il tag più recente, assicurati di recuperare l'origine prima di eseguirlo:

git remote update

Quanto segue funziona per me nel caso in cui siano necessari gli ultimi due tag (ad esempio, per generare il registro delle modifiche tra il tag corrente e il tag precedente). L'ho provato solo in situazioni in cui l'ultimo tag 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_"`

Soddisfa le mie esigenze, ma poiché non sono un mago git, sono sicuro che potrebbe essere ulteriormente migliorato. Ho anche il sospetto che si spezzerà nel caso in cui la cronologia del commit passi avanti. Sto solo condividendo nel caso in cui aiuti qualcuno.

Il mio primo pensiero è che potresti usare git rev-list HEAD , che elenca tutti i giri in ordine cronologico inverso, in combinazione con git tag --contains . Quando trovi un riferimento in cui tag git --contains produce un elenco non vuoto, hai trovato i tag più recenti.

Se vuoi trovare l'ultimo tag che è stato applicato su un ramo specifico puoi provare quanto segue:

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

Questo è un vecchio thread, ma sembra che a molte persone manchi la risposta più semplice, più facile e più corretta alla domanda di OP: per ottenere l'ultimo tag per il ramo corrente , usi git descrive HEAD . Fatto.

Modifica: puoi anche fornire qualsiasi nome di riferimento valido, anche telecomandi; vale a dire, git descrivi origine / master ti dirà l'ultimo tag che può essere raggiunto da origin / master.

Per ottenere l'ultimo tag solo sul nome del ramo / tag corrente che ha il prefisso con il ramo corrente, ho dovuto eseguire il seguente

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

Branch branch:

git checkout master

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

master-1448

Branch personalizzato:

git checkout 9.4

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

9.4-6

E il mio ultimo bisogno di incrementare e ottenere il tag +1 per il prossimo tagging.

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

Per la domanda,

Come ottenere il nome tag più recente nel ramo corrente

vuoi

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

--first-parent dice a git log di non dettagliare alcuna storia unita, --pretty =% d dice di mostrare solo il decorazioni cioè nomi locali per qualsiasi commit. grep -m1 dice " corrisponde solo a " ;, in modo da ottenere solo il tag più recente.

se i tag sono ordinabili:

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

Autorizzato sotto: CC-BY-SA insieme a attribuzione

Non affiliato a StackOverflow