Come ottenere l’ultimo nome del tag nel ramo corrente in Git?

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 

produzione:

 a b c 

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

Puoi dare un’occhiata a git describe , che fa qualcosa di simile a ciò che stai chiedendo.

Per ottenere il tag più recente:

 git describe --tags 

Per ottenere il tag annotato più recente:

 git describe --abbrev=0 --tags 

Produrrà il tag dell’ultimo commit con tag in tutte le filiali

 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

Naturalmente, è ansible modificare l’argomento count o il campo di ordinamento come desiderato. Sembra che tu abbia voluto fare una domanda leggermente diversa, ma questo risponde alla domanda mentre la interpreto.

Cosa ne pensi di questo?

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

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

git describe --tags

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

“Più recente” potrebbe avere due significati in termini di git.

Potresti dire “quale tag ha la data di creazione più recente” e la maggior parte delle risposte qui sono per quella domanda. In termini di domanda, vorresti restituire il tag c .

Oppure potresti voler dire “quale tag è il più vicino nella cronologia di sviluppo ad un certo ramo”, di solito il ramo su cui ti trovi, HEAD . Nella tua domanda, questo restituirà il tag a .

Questi potrebbero essere diversi naturalmente:

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

Immagina che lo sviluppatore tagga Z come v0.2 lunedì, e poi tagga Q come v0.1 martedì. v0.1 è il più recente, ma v0.2 è più vicino nella storia di 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 con v0.2 diverge dal percorso seguito da HEAD.

Ecco uno script Python che lo fa iterando attraverso 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 è diverguto:

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

git describe qualcosa di leggermente diverso, nel senso che rintraccia (ad esempio) HEAD per trovare il primo tag che si trova su un percorso nella storia da HEAD. In termini git, git describe aspetto dei 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 che si è discostato da lì.

 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 descrive –tags a volte dà hash sbagliati, non so perché, ma per me –max-count 2 non funziona)

questo è come si può ottenere la lista 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 c’è nessuna stringa “tag:” in uscita – basta eliminare l’ultima chiamata sed

Se vuoi più di 2 tag più recenti – cambia questo “sed 2q” in “sed 5q” o qualsiasi altra cosa tu abbia bisogno

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

git describe --abbrev=0 --tags

Se non vedi l’ultimo tag, assicurati di recuperare l’origine prima di eseguirla:

git remote update

Cosa c’è di sbagliato in tutti i suggerimenti (eccetto la spiegazione di Matthew Brett , aggiornata su questo post di risposta)?

Esegui semplicemente qualsiasi comando fornito da altri sulla cronologia di Git jQuery quando ti trovi in un punto diverso della cronologia e verifica il risultato con la rappresentazione della cronologia visiva (ho fatto per questo che vedi questo post):

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

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

Ci sono forti ragioni per questo. Basta guardare a qualsiasi progetto JS / CSS ben consolidato. Per le convenzioni degli utenti portano file di rilascio binari / minificati in DVCS. Naturalmente, come manutentore del progetto, non si vuole spazzare via la cronologia della mainline con blob binari inutili ed eseguire commit di artefatti di build fuori linea principale .

Dato che Git usa DAG e non la cronologia lineare, è difficile definire la metrica della distanza in modo che possiamo dire – oh che la rivoluzione è più vicina al mio HEAD !

Inizio il mio stesso viaggio (guarda dentro, non ho copiato le immagini di fantasia su questo lungo post):

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

Attualmente ho 4 ragionevole definizione di distanza tra tag e revisione con diminuzione dell’utilità:

  • lunghezza del percorso più breve da HEAD per unire base con tag
  • data di fusione tra HEAD e tag
  • numero di giri raggiungibile da HEAD ma non raggiungibile dal tag
  • data del tag indipendentemente dalla base di unione

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

Script che ordina i tag in base alla data di fusione 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 per la maggior parte dei progetti.

Script che ordina i tag in base al numero di giri raggiungibile da HEAD ma non raggiungibile 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 sui commit (a causa di rebases o un’altra riscrittura della cronologia o qualche idiota dimentica di sostituire la batteria del BIOS o altre magie che fai nella cronologia) usa lo script sopra.

Per ultima opzione ( data del tag indipendentemente dalla base di unione ) per ottenere l’elenco dei tag ordinati per data utilizzare:

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

Per conoscere la data di revisione attuale, utilizzare:

 $ git log --max-count=1 

Si noti che git describe --tags hanno l’uso sui propri casi ma non per trovare il tag più vicino previsto nella storia del progetto .

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

 git tag -l ac* | tail -n1 

Ottieni l’ultimo tag con il 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 . Quindi, quei tag con il primo carattere az verranno ignorati.

Ulteriori informazioni

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

 git tag -l  

Elenca i tag con nomi che corrispondono al modello specificato (o tutti se non viene fornito alcun motivo). L’esecuzione di “tag git” senza argomenti elenca anche tutti i tag. Il modello è un carattere jolly della shell (cioè, abbinato usando fnmatch (3)). Possono essere forniti modelli multipli; se qualcuno di essi corrisponde, viene visualizzato il tag.


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

Aggiornare

Con git tag --help , sull’argomento sort . lexicorgraphic order impostazione predefinita, se la proprietà tag.sort non esiste.

L’ordinamento ordina per default il valore configurato per la variabile tag.sort se esiste, o altrimenti l’ordine lessicografico. Vedi git-config (1).

Dopo google, qualcuno ha detto che git 2.8.0 supporta la syntax successiva.

 git tag --sort=committerdate 

Quanto segue funziona per me nel caso in cui siano necessari gli ultimi due tag (ad esempio, per generare il log 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_"` 

Si adatta alle mie esigenze, ma siccome non sono un mago git, sono sicuro che potrebbe essere ulteriormente migliorato. Sospetto anche che si interromperà nel caso in cui la storia del commit avanza. Sto solo condividendo nel caso in cui aiuti qualcuno.

Puoi eseguire: git describe --tags $(git rev-list --tags --max-count=1) parlato qui: Come ottenere l’ultimo nome del tag?

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 dove git tag --contains genera un elenco non vuoto, hai trovato i tag più recenti.

Se vuoi trovare l’ultimo tag applicato su un ramo specifico puoi provare quanto segue:

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

Questo è un thread vecchio, ma sembra che a molte persone manchi la risposta più semplice, più semplice e più corretta alla domanda dell’OP: per ottenere l’ultimo tag per il ramo corrente , si usa git describe HEAD . Fatto.

Modifica: puoi anche fornire qualsiasi refname valido, anche i telecomandi; Ad esempio, git describe origin/master ti dirà l’ultimo tag che può essere raggiunto da origine / master.

Per ottenere l’ultimo tag solo sul ramo corrente / nome del tag che prefissa con il ramo corrente, ho dovuto eseguire quanto segue

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

Caposquadra:

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

Ramo personalizzato:

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

E la mia ultima necessità 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 chiesto,

Come ottenere l’ultimo nome del tag nel ramo corrente

tu vuoi

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

--first-parent dice a git log non dettagliare le storie unite, --pretty=%d dice di mostrare solo le decorazioni, cioè i nomi locali per qualsiasi commit. grep -m1 dice “combaciale solo uno”, quindi ottieni solo il tag più recente.

se i tuoi tag sono ordinabili:

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