Como obter o nome da tag mais recente na ramificação atual no Git?

Qual é a maneira mais simples de obter a tag mais recente no Git?

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

saída:

 a b c 

Devo escrever um script para obter datetime de cada tag e compará-los?

Você poderia dar uma olhada no git describe , que faz algo próximo do que você está perguntando.

Para obter a tag mais recente:

 git describe --tags 

Para obter a tag anotada mais recente:

 git describe --abbrev=0 --tags 

Irá produzir a tag do último commit marcado em todas as filiais

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

Para obter a tag mais recente, você pode fazer:

 $ git para cada refs / tags --sort = -taggerdate --format = '% (refname)' --count = 1

Naturalmente, você pode alterar o argumento de contagem ou o campo de sorting conforme desejado. Parece que você pode ter feito uma pergunta um pouco diferente, mas isso responde à pergunta que eu interpreto.

Que tal agora?

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

Tecnicamente, você não receberá necessariamente a tag mais recente, mas o último commit marcado, que pode ou não ser o que você está procurando.

git describe --tags

retorna a última tag capaz de ser vista pela ramificação atual

“Mais recente” poderia ter dois significados em termos de git.

Você poderia querer dizer “qual tag tem a data de criação mais recente no tempo”, e a maioria das respostas aqui são para essa pergunta. Em termos de sua pergunta, você gostaria de retornar a tag c .

Ou você pode querer dizer “qual tag é a mais próxima no histórico de desenvolvimento para alguma ramificação nomeada”, geralmente a ramificação em que você está, HEAD . Na sua pergunta, isso retornaria a tag a .

Estes podem ser diferentes, claro:

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

Imagine que o desenvolvedor tenha marcado Z como v0.2 na segunda-feira e, em seguida, tenha marcado Q como v0.1 na terça-feira. v0.1 é o mais recente, mas a v0.2 está mais próxima no histórico de desenvolvimento de HEAD, no sentido de que o caminho em que ele está inicia em um ponto mais próximo de HEAD.

Eu acho que você geralmente quer essa segunda resposta, mais próxima do histórico de desenvolvimento. Você pode descobrir isso usando o git log v0.2..HEAD etc para cada tag. Isto lhe dá o número de commits no HEAD desde que o caminho terminando na v0.2 divergiu do caminho seguido por HEAD.

Aqui está um script Python que faz isso iterando todas as tags que executam essa verificação e, em seguida, imprimindo a tag com menos commits no HEAD, já que o caminho da tag divergiu:

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

git describe faz algo um pouco diferente, pois ele rastreia (ex.) HEAD para encontrar a primeira tag que está em um caminho de volta no histórico da HEAD. Em termos git, o git describe procura tags que são “alcançáveis” a partir do HEAD. Portanto, ele não encontrará tags como v0.2 que não estão no caminho de volta de HEAD, mas um caminho que divergiu de lá.

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

SE VOCÊ PRECISA MAIS DE UM ÚLTIMO TAG

(git descreve –tags às vezes dá hashes errados, eu não sei porque, mas para mim –max-count 2 não funciona)

é assim que você pode obter a lista com os últimos 2 nomes de tag em ordem cronológica inversa, funciona perfeitamente no git 1.8.4. Para versões anteriores do git (como 1.7. *), Não há string “tag:” na saída – apenas delete last sed call

Se você quiser mais de 2 tags mais recentes – altere este “sed 2q” para “sed 5q” ou o que você precisar

Então você pode facilmente analisar cada nome de tag para variável ou assim.

git describe --abbrev=0 --tags

Se você não vir a tag mais recente, certifique-se de buscar a origem antes de executá-la:

git remote update

O que há de errado com todas as sugestões (exceto a explicação de Matthew Brett , até a data deste post de resposta)?

Basta executar qualquer comando fornecido por outro no histórico do jQuery Git quando você estiver em um ponto diferente da história e verificar o resultado com a representação do histórico de marcação visual ( foi por isso que você vê este post):

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

Hoje muitos projetos executam lançamentos (e, portanto, marcação) em ramificação separada da linha principal .

fortes razões para isso. Basta olhar para qualquer projeto JS / CSS bem estabelecido. Para convenções de usuários, eles carregam arquivos de versão binários / minificados em DVCS. Naturalmente, como mantenedor de projetos, você não quer colocar lixo no histórico de diferenças da sua linha principal com bobs binários inúteis e executar commit de artefatos de construção fora da linha principal .

Porque o Git usa o DAG e não o histórico linear – é difícil definir a métrica da distância para que possamos dizer – oh que a rev é a mais próxima da minha HEAD !

Eu começo minha própria jornada (olhe lá dentro, eu não copiei imagens de prova para esse longo post):

Qual é a marca mais próxima no passado em relação à ramificação no Git?

Atualmente tenho 4 definição razoável de distância entre tag e revisão com decréscimo de utilidade:

  • comprimento do caminho mais curto de HEAD para mesclar base com tag
  • data da base de mesclagem entre HEAD e tag
  • número de rotações que podem ser acessadas a partir do HEAD, mas não alcançáveis ​​no tag
  • data da tag independentemente da base de mesclagem

Não sei calcular o comprimento do caminho mais curto .

Script que classifica as tags de acordo com a data da base de mesclagem entre 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 

É utilizável na maioria dos projetos.

Script que classifica as tags de acordo com o número de revs que podem ser acessadas a partir do HEAD, mas que não podem ser acessadas na tag:

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

Se o seu histórico de projeto tem datas estranhas em commits (por causa de rebases ou outra história reescrita ou algum idiota que se esqueça de replace a bateria do BIOS ou outras magias que você faz no histórico) use o script acima.

Para a última opção ( data da tag independentemente da base de mesclagem ) para obter a lista de tags classificadas por data use:

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

Para obter o uso da data de revisão atual conhecida:

 $ git log --max-count=1 

Observe que git describe --tags tem uso em seus próprios casos, mas não para encontrar o tag humano mais próximo esperado no histórico do projeto .

NOTA Você pode usar as receitas acima em qualquer revisão, basta replace o HEAD pelo que você deseja!

 git tag -l ac* | tail -n1 

Obtenha a última tag com o prefixo “ac” . Por exemplo, a tag nomeada com ac1.0.0 ou ac1.0.5 . Outras tags nomeadas 1.0.0 , 1.1.0 serão ignoradas.

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

Pegue a última tag, cujo primeiro caractere é 0-9 . Então, aquelas tags com o primeiro caractere az serão ignoradas.

Mais informações

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

 git tag -l  

Listar tags com nomes que correspondem ao padrão fornecido (ou todos, se nenhum padrão for fornecido). A execução de “git tag” sem argumentos também lista todas as tags. O padrão é um curinga da shell (isto é, correspondido usando fnmatch (3)). Vários padrões podem ser dados; se qualquer um deles corresponder, a tag será mostrada.


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

Atualizar

Com git tag --help , sobre o argumento de sort . Ele usará a lexicorgraphic order por padrão, se a propriedade tag.sort não existir.

A ordem de sorting é padronizada para o valor configurado para a variável tag.sort, se existir, ou ordem lexicográfica, caso contrário. Veja git-config (1).

Depois do google, alguém disse git 2.8.0 support following syntax.

 git tag --sort=committerdate 

O seguinte funciona para mim no caso de você precisar das duas últimas tags (por exemplo, para gerar o log de alterações entre a tag atual e a tag anterior). Eu testei apenas na situação em que a tag mais recente era o 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_"` 

Ele atende às minhas necessidades, mas como não sou um git mago, tenho certeza de que poderia ser melhorado ainda mais. Eu também suspeito que ele irá quebrar caso o histórico de commit avance. Eu só estou compartilhando no caso de ajudar alguém.

Você pode executar: git describe --tags $(git rev-list --tags --max-count=1) falado aqui: Como obter o nome da tag mais recente?

Meu primeiro pensamento é que você poderia usar o git rev-list HEAD , que lista todos os revs em ordem cronológica inversa, em combinação com git tag --contains . Quando você encontra uma referência onde a git tag --contains produz uma lista não vazia, você encontrou a (s) tag (s) mais recente (s).

Se você quiser encontrar a última tag aplicada em uma ramificação específica, tente o seguinte:

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

Este é um thread antigo, mas parece que muitas pessoas estão perdendo a resposta mais simples, mais fácil e mais correta para a pergunta do OP: para obter a tag mais recente para o branch atual , use git describe HEAD . Feito.

Edit: você também pode fornecer qualquer refname válido, até mesmo controles remotos; isto é, git describe origin/master irá dizer-lhe a tag mais recente que pode ser alcançada a partir da origem / master.

Para obter a tag mais recente somente no nome da ramificação / tag atual que prefixava a ramificação atual, tive que executar o seguinte

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

Mestre de ramo:

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

Filial personalizada:

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

E minha necessidade final de incrementar e obter a tag +1 para a próxima marcação.

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

Para a pergunta, como solicitado,

Como obter o nome da tag mais recente no ramo atual

você quer

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

--first-parent informa ao git log para não detalhar quaisquer históricos mesclados, --pretty=%d diz para mostrar apenas as decorações, ou seja, nomes locais para quaisquer commits. grep -m1 diz “combine apenas um”, então você tem apenas a tag mais recente.

se suas tags são classificáveis:

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