Como obter o mais recente nome da marca no ramo atual em Git?

Question

O que é a maneira mais simples para 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

Eu deveria escrever um script para obter data e hora de cada tag e compará-los?

Answer 1

Você poderia dar uma olhada em git describe, que faz algo parecido com o que você está pedindo.

Answer 2

Para obter o tag mais recente:

git describe --tags

Para obter o mais recente anotada tag:

git describe --abbrev=0

Answer 3

saída será a marca do último marcado comprometer em todos os ramos

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

Answer 4

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

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

É claro, você pode alterar o argumento de contagem ou o campo de classificação como desejado. Parece que você pode ter a intenção de fazer uma pergunta ligeiramente diferente, mas isso não responder à pergunta como eu interpretá-lo.

Answer 5

Como sobre isso?

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

Tecnicamente, não necessariamente que você obtenha o mais recente tag, mas a última comprometer que é marcado, que pode ou não ser a coisa que você está procurando.

Answer 6

git describe --tags

Retorna a última tag capaz de ser visto por ramificação actual

Answer 7

"mais recente" pode ter dois significados em termos de git.

Você poderia dizer, "que 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ê iria querer voltar tag c.

Ou você poderia dizer "que tag é o mais próximo na história de desenvolvimento para algum ramo nomeado", geralmente o ramo onde se encontra, HEAD. Em sua pergunta, este voltaria tag a.

Estes podem ser diferentes, é claro:

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

Imagine a Z tag'ed desenvolvedor como v0.2 na segunda-feira, e depois tag'ed Q como v0.1 na terça-feira. v0.1 é a mais recente, mas v0.2 está mais perto da história de desenvolvimento para HEAD, no sentido de que o caminho é em começa em um ponto mais perto de HEAD.

Eu acho que você normalmente querem esta segunda resposta, mais perto da história de desenvolvimento. Você pode descobrir isso usando git log v0.2..HEAD etc para cada tag. Isto dá-lhe o número de commits na cabeça desde o caminho terminando no v0.2 se desviaram do caminho seguido por HEAD.

Aqui está um script Python que faz isso por iteração através de todas as tags executando esta verificação, e em seguida, imprimir a etiqueta com o menor número de commits na cabeça desde o caminho tag divergiram:

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

git describe faz algo um pouco diferente, na medida em que acompanha de volta a partir de (por exemplo) cabeça para encontrar a primeira tag que está em uma volta caminho na história da HEAD. Em termos git, olhares git describe para tags que são "acessíveis" da cabeça. É, portanto, não vai encontrar marcas como v0.2 que não estão na parte de trás caminho de cabeça, mas um caminho que divergiram de lá.

Answer 8

Você pode executar: git describe --tags $(git rev-list --tags --max-count=1) falou aqui: Como chegar última etiqueta de nome?

Answer 9

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

SE VOCÊ PRECISA MAIS DE UM última tag

(GIT descrever --tags às vezes dá hashes erradas, eu não sei porque, mas para mim --max-count 2 não funciona)

Este é como você pode obter a lista com as últimas 2 nomes de tags em ordem cronológica inversa, funciona perfeitamente em git 1.8.4. (. como 1,7 *) para versões anteriores do git, não existe um "tag:" string na saída - basta apagar última chamada sed

Se você quer mais do que 2 últimas marcas - alterar este "2T sed" para "5q sed" ou o que quer que você precisa

Em seguida, você pode facilmente analisar cada nome do tag para variável ou assim.

Answer 10

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

Apenas executar qualquer comando fornecido por outra sobre a história jQuery Git quando a ponto da história diferente e resultado do teste com marcação visual representação história (I fez que é por isso que você vê neste post):

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

de hoje muitos projecto realizar lançamentos (e assim por marcação) no ramo separado do mainline .

Existem forte razão para isso. Basta olhar para qualquer projeto bem estabelecido JS / CSS. Para convenções de usuários que carregam / arquivos versão binária minified em DVCS. Naturalmente, como mantenedor projeto que você não quer lixo sua linha principal diff história com blobs binários inúteis e realizar comprometer de artefatos de construção fora da linha principal .

Porque Git usa DAG e não história linear - é difícil definir a distância métrica para que possamos dizer - oh que rev é o mais próximo ao meu HEAD

I começar a minha própria jornada in (dentro de olhar, eu não copiar as imagens de prova de fantasia para este longo post):

O que é mais próximo tag no passado com relação a ramificação no Git?

Atualmente tenho 4 definição razoável da distância entre tag e revisão com a diminuição da utilidade:

• comprimento do caminho mais curto a partir HEAD a base de merge com tag
• data de base de merge entre HEAD e tag
• número de rotações que acessível a partir de cabeça, mas não acessível a partir de tag
• data da tag independentemente base de merge

Eu não sei como calcular comprimento do caminho mais curto .

Script que as etiquetas de classificação de acordo com data de base de merge 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

-lo utilizável na maioria dos projectos.

Script que as etiquetas de classificação de acordo com número de rotações que acessível a partir de cabeça, mas não acessível a partir de tag:

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

Se o seu histórico projeto tem datas estranhas em commits (devido rebases ou outra história reescrita ou algum idiota se esqueça de substituir BIOS bateria ou outras magias que você faz na história) utilização acima script.

Para última opção ( data da tag independentemente base de merge ) para obter a lista de marcas classificadas pelo uso de data:

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

Para obter conhecido uso data da revisão atual:

$ git log --max-count=1

Note que git describe --tags têm uso em seus próprios casos, mas não para encontrar humana esperado tag mais próximo na história do projeto .

NOTA Você pode usar acima receitas em qualquer revisão, basta substituir HEAD com o que você quer!

Answer 11

git tag -l ac* | tail -n1

Obter a última tag com prefixo "ac" . Por exemplo, tag nomeado com ac1.0.0, ou ac1.0.5. Outros chamado tags 1.0.0, 1.1.0 serão ignorados.

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

Obter a última tag, cujo primeiro caractere é 0-9. Então, essas tags com primeira a-z caractere será ignorado.

Mais informações

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

---

git tag -l <pattern>

marcas da lista com nomes que correspondem ao padrão especificado (ou todos, se não padrão é dada). Running "tag git" sem argumentos também lista todas as tags. O padrão é um curinga shell (ou seja, combinado com fnmatch (3)). Vários padrões podem ser dadas; se algum deles partidas, o tag é mostrado.

---

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

---

Atualização

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

Ordem de classificação padrão para o valor configurado para a variável tag.sort se existe, ou a fim lexicographic contrário. Veja git-config (1).

Depois de google, alguém disse git 2.8.0 suporte seguinte sintaxe.

git tag --sort=committerdate

Answer 12

git describe --abbrev=0 --tags

Se você não vê mais recente tag, certifique-se de buscar origem antes de executar que:

git remote update

Answer 13

As seguintes obras para mim no caso de você precisar últimas duas tags (por exemplo, a fim de gerar log de alterações entre tag atual e a tag anterior). Eu testei-o apenas na situação em que o mais recente tag foi 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 eu não sou nenhum mago git, eu tenho certeza que ele ainda pode ser melhorada. Eu também suspeito que vai quebrar no caso da história se move comprometer a frente. Eu só estou compartilhando no caso de ajuda de alguém.

Answer 14

Meu primeiro pensamento é que você poderia usar git rev-list HEAD, que lista todas as rotações em ordem cronológica inversa, em combinação com git tag --contains. Quando você encontrar um ref onde git tag --contains produz uma lista não vazia, você encontrou a tag mais recente (s).

Answer 15

Se você quiser encontrar a última tag que foi aplicado em um ramo específico você pode tentar o seguinte:

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

Answer 16

Esta é uma discussão antiga, mas parece que um monte de pessoas estão faltando o, e resposta correta mais fácil mais simples para a pergunta de OP: para obter a última tag para o ramo atual , você usa git describe HEAD. Feito.

Edit: você pode também fornecer qualquer refname válida, mesmo remotos; ou seja, git describe origin/master irá dizer-lhe o mais recente tag que pode ser alcançado a partir de origem / master.

Answer 17

Para obter a última tag somente na atual nome de ramo / tag que prefixos com ramo atual, eu tive que executar o seguinte

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

branch master:

git checkout master

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

master-1448

costume Branch:

git checkout 9.4

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

9.4-6

E a minha necessidade final para incremento e obter a marca +1 para o próximo tagging.

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

Answer 18

Para a pergunta como solicitado,

Como obter o mais recente nome da marca no ramo atual

Você quer

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

--first-parent diz git log não ao detalhe qualquer fundiu histórias, --pretty=%d diz para mostrar apenas os nomes locais decorações ou seja, para nenhum commit. grep -m1 diz "corresponder apenas um", de modo a obter apenas o tag mais recente.

Answer 19

Se suas tags são classificáveis:

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