Como posso obter uma lista dos ramos Git, ordenados pelo commit mais recente?

1324

Quero obter uma lista de todas as ramificações em um repositório Git com as ramificações "mais recentes" na parte superior, onde a ramificação "mais recente" é a que foi confirmada mais recentemente (e, portanto, é mais provável que seja uma delas). Eu quero prestar atenção).

Existe uma maneira de usar o Git para (a) classificar a lista de ramificações pela última confirmação ou (b) obter uma lista de ramificações com a data da última confirmação de cada um, em algum tipo de formato legível por máquina?

Na pior das hipóteses, eu sempre poderia executar git branchpara obter uma lista de todas as ramificações, analisar sua saída e, em seguida, git log -n 1 branchname --format=format:%cipara cada uma, para obter a data de consolidação de cada ramificação. Mas isso será executado em uma caixa do Windows, onde iniciar um novo processo é relativamente caro, portanto, iniciar o executável do Git uma vez por filial pode ficar lento se houver muitas ramificações. Existe uma maneira de fazer tudo isso com um único comando?

Joe White
fonte
2
stackoverflow.com/a/2514279/1804124 Tem uma resposta melhor.
Spundun
12
@ Spundun, você me perdeu lá. Como uma combinação de vários comandos, incluindo coisas enviadas através de perl e sed, é "melhor" do que usar um comando que o Git já possui?
Joe White
37
@ Spundun com relação à resposta git for-each-refde Jakub Narębski: você pode obter ramificações remotas em refs/remotes/vez de refs/heads/(ou você pode passar ambas, separadas por espaços em branco); refs/tags/para tags ou apenas refs/para os três tipos.
precisa saber é
4
Iniciando o git 2.7 (quarto trimestre de 2015), não mais for-each-ref! Você usará diretamente git branch --sort=-committerdate: veja minha resposta abaixo
VonC
1
Possivelmente uma duplicata de stackoverflow.com/questions/9236219/…
Ondra Žižka

Respostas:

1874

Use a --sort=-committerdateopção de git for-each-ref;

Também disponível desde o Git 2.7.0 para git branch:

Uso básico:

git for-each-ref --sort=-committerdate refs/heads/

# Or using git branch (since version 2.7.0)
git branch --sort=-committerdate  # DESC
git branch --sort=committerdate  # ASC

Resultado:

Result

Uso avançado:

git for-each-ref --sort=committerdate refs/heads/ --format='%(HEAD) %(color:yellow)%(refname:short)%(color:reset) - %(color:red)%(objectname:short)%(color:reset) - %(contents:subject) - %(authorname) (%(color:green)%(committerdate:relative)%(color:reset))'

Resultado:

Result

Jakub Narębski
fonte
15
Perfeito! Eu posso até restringir a saída apenas aos nomes de referência acrescentando --format=%(refname).
Joe White
35
Isso é melhor para mim:git for-each-ref --sort=-committerdate refs/heads/ --format='%(refname) %(committerdate) %(authorname)' | sed 's/refs\/heads\///g'
saeedgnu
2
@ilius: por que não usar :shortname?
Jakub Narębski
37
@ilius: Como @BeauSmith escreveu: git for-each-ref --sort=-committerdate --format='%(refname:short)' refs/heads/. A página de manual do git-for-each-ref (1) diz: Para um nome abreviado não ambíguo do ap ap ref :short.
Jakub Narębski
76
Esta é uma versão colorida, incluindo hashes, mensagens, ordenadas ascendentes com base na data de confirmação, com a idade relativa do último commit em cada ramificação. Eu roubei todas as idéias de vocês acima. Está no meu .gitconfig na [alias]seção e eu adoro isso. br = for-each-ref --sort=committerdate refs/heads/ --format='%(HEAD) %(color:yellow)%(refname:short)%(color:reset) - %(color:red)%(objectname:short)%(color:reset) - %(contents:subject) - %(authorname) (%(color:green)%(committerdate:relative)%(color:reset))'
Michael Percy
124

Lista de nomes de ramificações Git, ordenados pela confirmação mais recente…

Expandindo a resposta de Jakub e a dica de Joe , o seguinte removerá os "refs / heads /" para que a saída exiba apenas os nomes das ramificações:


Comando:

git for-each-ref --count=30 --sort=-committerdate refs/heads/ --format='%(refname:short)'

Resultado:

Recent Git branches

Beau Smith
fonte
4
Você também pode usar em --format=%(refname:short)vez de confiar cut.
Chaitanya Gupta
3
Existe alguma maneira de fazer isso no repositório REMOTE?
Allan Bowe
10
aah - @ jakub.g já explicado: você pode obter ramificações remotas passando refs / remotes / em vez de refs / heads /. Perfeito!!
Allan Bowe
I como este, se você está tentando o alias, o que fiz, para git rblembrar a cercar o comando entre aspas:git config --global alias.rb "for-each-ref --count=20 --sort=-committerdate refs/heads/ --format=\'%(refname:short)\'"
Michael Discenza
2
E agora você pode fazer isso com git branch, portanto, obter local, remoto ou todos os ramos funciona como no git-branch (ou seja, -r, -a). git branch -r --sort=committerdate --format='%(HEAD) %(color:yellow)%(refname:short)%(color:reset) - %(color:red)%(objectname:short)%(color:reset) - %(contents:subject) - %(authorname) (%(color:green)%(committerdate:relative)%(color:reset))'
phord
89

Aqui está o código ideal, que combina as outras duas respostas:

git for-each-ref --sort=-committerdate refs/heads/ --format='%(committerdate:short) %(authorname) %(refname:short)'
Nikolay
fonte
10
Mesmo um pouco mor otimizada para obter uma saída tabular:git for-each-ref --sort=-committerdate refs/heads/ --format='%(committerdate:short) %(authorname) %(refname:short)'
schoetbi
2
por algum motivo eu tive que usar aspas em janelas, mas caso contrário estes trabalham muito bem :)
amenthes
1
@schoetbi Esse código é exatamente igual ao da nikolay, o que você mudou para torná-lo tabular?
Enrico
@Enrico e outros que podem se perguntar sobre a mesma coisa. nikolay mudou sua resposta usando a sugestão de schoetbis. Ao mudar a data primeiro, que sempre tem a mesma duração, o resultado parece mais tabular.
johnny
83

Aqui está um comando simples que lista todas as ramificações com as confirmações mais recentes:

git branch -v

Para solicitar pela confirmação mais recente, use

git branch -v --sort=committerdate

Fonte: http://git-scm.com/book/en/Git-Branching-Branch-Management

user1682406
fonte
11
git branch -avse você quiser ver ramificações não locais também.
Scott Stafford
34
Isso não classifica por data de confirmação conforme a pergunta.
Cas
1
É fácil git branch -vincluir a data de cada confirmação listada?
dumbledad
1
que tal <pre> git branch -v --sort = committerdate </pre>?
iraj jelodari
2
Isso é incrível. Gosto git branch -va --sort=-committerdatede mostrar ramificações não locais, com as ramificações alteradas mais recentemente no topo.
Clinton Blackmore
61

Eu uso o seguinte alias:

recent = "!r(){git for-each-ref --sort=-committerdate refs/heads --format='%(HEAD)%(color:yellow)%(refname:short)|%(color:bold green)%(committerdate:relative)|%(color:blue)%(subject)|%(color:magenta)%(authorname)%(color:reset)'|column -ts'|'}; r"

que produz:

Result

Use '|' separar.

escuro
fonte
1
Ótimo apelido! Sugiro column -ts'|'que os caracteres de vírgula possam ocorrer dentro de carimbos de data e hora relativos no seu código do idioma.
Björn Lindqvist
1
ótimo apelido, muito obrigado. você pode aprimorá-lo para mostrar o ramo atual com uma outra cor ou com * no início?
elhadi dp ıpɐɥ ן ǝ 03/09/2015
2
Pelo menos na versão mais recente do git você pode apenas adicionar '%(HEAD) ...'no início da cadeia de formato para obter o mesmo efeito sem tubulação pensamento do sedcomando
Joshua Skrzypek
5
Eu não poderia fazer isso funcionar como um alias do git. Eu precisava usar[alias] recent = !git for-each-ref --sort=-committerdate refs/heads --format='%(HEAD)%(color:yellow)%(refname:short)|%(color:bold green)%(committerdate:relative)|%(color:blue)%(subject)|%(color:magenta)%(authorname)%(color:reset)'|column -ts'|'
Wesley Smith
11
Eu tive que adicionar --color = sempre para obter cores. git for-each-ref --sort=-committerdate refs/heads --format='%(HEAD)%(color:yellow)%(refname:short)|%(color:bold green)%(committerdate:relative)|%(color:blue)%(subject)|%(color:magenta)%(authorname)%(color:reset)' --color=always|column -ts'|'}
usar o seguinte comando
40

Consegui fazer referência aos exemplos anteriores para criar algo que funcione melhor para mim.

git for-each-ref --ort = -committerdate refs / heads / --format = '% (authordate: short)% (color: red)% (objectname: short)% (color: yellow)% (refname: short )% (cor: redefinir) (% (cor: verde)% (data do emissor: relativa)% (cor: redefinir)) '

Captura de tela da saída

Andy
fonte
1
Parece bom, mais colorido do que usar ramificação git diretamente, como sugeri em stackoverflow.com/a/33163401/6309 . +1
VonC
2
Este funcionou prontamente para mim, ao contrário de outros, por isso votei a favor.
Casey
1
Trabalhou como é realmente bem! Obrigado! :-)
FrozenTarzan
1
Idem - este funcionou pronto para uso, diferente de vários outros que acabei de experimentar. Obrigado.
Dan Nissenbaum
2
Este é limpo e arrumado. Em algum momento eu adicionaria remote e authorname como este: git for-each-ref --sort=-committerdate refs/heads/ refs/remotes --format='%(authordate:short) %(authorname) %(color:red)%(objectname:short) %(color:yellow)%(refname:short)%(color:reset) (%(color:green)%(committerdate:relative)%(color:reset))'
ywu 21/10/19
38

Eu também precisava de cores, tags e referências remotas sem duplicatas:

for ref in $(git for-each-ref --sort=-committerdate --format="%(refname)" refs/heads/ refs/remotes ); do git log -n1 $ref --pretty=format:"%Cgreen%cr%Creset %C(yellow)%d%Creset %C(bold blue)<%an>%Creset%n" | cat ; done | awk '! a[$0]++'

Como as cotações podem ser difíceis, eis o alias para o Bash:

alias glist='for ref in $(git for-each-ref --sort=-committerdate --format="%(refname)" refs/heads/ refs/remotes ); do git log -n1 $ref --pretty=format:"%Cgreen%cr%Creset %C(yellow)%d%Creset %C(bold blue)<%an>%Creset%n" | cat ; done | awk '"'! a["'$0'"]++'"
estani
fonte
$ <Seu comando aqui> awk: erro de sintaxe perto da linha 1 awk: resgatando perto da linha 1
Jamie Mason
@GotNoSugarBaby Você está usando aspas simples, como no exemplo, certo? qual shell você está usando? Bash atribui a esse personagem um significado especial.
Estani
ei, eu executei isso em / bin / bash (GNU bash, versão 4.0.28 (1) -release (i386-pc-solaris2.11)) com uma cópia direta e cole do seu exemplo - mas desde então eu corro on / bin / bash (GNU bash, versão 3.2.48 (1) -release (x86_64-apple-darwin12)) e funciona, então removerei o voto negativo. Muito obrigado estani.
Jamie Mason
@GotNoSugarBaby Eu uso a versão 4.2.25 (1) (x86_64-pc-linux-gnu) e tentei 3.x e funcionou. Não tenho certeza de qual era o problema ... mas ele pode ter um problema relacionado à versão git, em vez de um bash. De qualquer forma, fico feliz que funcione para você!
Estani
1
@MichaelDiscenza apenas coloca tudo na cabeça. isso seria adicionar | head -n20no final. Se você estiver usando o alias, verifique se está dentro das aspas.
estani
24

As outras respostas não parecem permitir a passagem -vv a obtenha uma saída detalhada.

Então, aqui está uma lista que classifica git branch -vvpor data de confirmação, preservando a cor etc:

git branch -vv --color=always | while read; do echo -e $(git log -1 --format=%ct $(echo "_$REPLY" | awk '{print $2}' | perl -pe 's/\e\[?.*?[\@-~]//g') 2> /dev/null || git log -1 --format=%ct)"\t$REPLY"; done | sort -r | cut -f 2

Se você desejar imprimir adicionalmente a data de confirmação, poderá usar esta versão:

git branch -vv --color=always | while read; do echo -e $(git log -1 --format=%ci $(echo "_$REPLY" | awk '{print $2}' | perl -pe 's/\e\[?.*?[\@-~]//g') 2> /dev/null || git log -1 --format=%ci)" $REPLY"; done | sort -r | cut -d ' ' -f -1,4-

Saída de amostra:

2013-09-15   master                  da39a3e [origin/master: behind 7] Some patch
2013-09-11 * (detached from 3eba4b8) 3eba4b8 Some other patch
2013-09-09   my-feature              e5e6b4b [master: ahead 2, behind 25] WIP

Provavelmente é mais legível dividido em várias linhas:

git branch -vv --color=always | while read; do
    # The underscore is because the active branch is preceded by a '*', and
    # for awk I need the columns to line up. The perl call is to strip out
    # ansi colors; if you don't pass --color=always above you can skip this
    local branch=$(echo "_$REPLY" | awk '{print $2}' | perl -pe 's/\e\[?.*?[\@-~]//g')
    # git log fails when you pass a detached head as a branch name.
    # Hide the error and get the date of the current head.
    local branch_modified=$(git log -1 --format=%ci "$branch" 2> /dev/null || git log -1 --format=%ci)
    echo -e "$branch_modified $REPLY"
# cut strips the time and timezone columns, leaving only the date
done | sort -r | cut -d ' ' -f -1,4-

Isso também deve funcionar com outros argumentos para git branch, por exemplo, -vvrlistar ramificações de rastreamento remoto ou -vvalistar ramificações de rastreamento remoto e locais.

John Mellor
fonte
-vvpode ser realmente útil, obrigado. No entanto, essa solução ainda gera novos processos para cada filial, que o OP queria evitar.
Musiphil
Na verdade git branch, não define especificamente o significado de -vv, mas apenas de -v, portanto, -vvdeve ter o mesmo que -v.
Musiphil
2
Isso é o melhor. E adicionar -avv também leva em conta ramificações remotas. Obrigado por isso!
Gopherkhan
@musiphil A página de manual da minha ramificação git , seção -v, -vv, --verbosecontém o seguinte:If given twice, print the name of the upstream branch, as well
Perleone 28/09/15
@ Perleone: Eu não sei como obtive essa informação, mas você está certo, e eu estou corrigido. Obrigado!
Musiphil 28/09/2015
23

O git 2.7 (quarto trimestre de 2015) introduzirá a classificação de ramificação usando diretamente git branch:
Consulte commit aa3bc55 , commit aedcb7d , commit 1511b22 , commit f65f139 , ... (23 de setembro de 2015), commit aedcb7d , commit 1511b22 , commit ca41799 (24 set 2015) e confirmar f65f139 , ... (23 de setembro de 2015) por Karthik Nayak ( KarthikNayak) .
(Mesclado por Junio ​​C Hamano - gitster- no commit 7f11b48 , 15 de outubro de 2015)

Em particular, confirme aedcb7d :

branch.c: use ref-filterAPIs ' '

Crie APIs ' branch.c' use ' ref-filter' para iterar através da classificação refs. Isso remove a maior parte do código usado em " branch.c" substituí-lo por chamadas para a ref-filterbiblioteca " ".

Ele adiciona a opção--sort=<key> :

Classifique com base na chave fornecida.
Prefixo -para classificar em ordem decrescente do valor.

Você pode usar a --sort=<key>opção várias vezes; nesse caso, a última chave se torna a chave primária.

As chaves suportadas são as mesmas que as degit for-each-ref .
O padrão da ordem de classificação é a classificação com base no nome completo da ref (incluindo o refs/...prefixo). Isso lista primeiro o HEAD desanexado (se presente), depois as ramificações locais e, finalmente, as ramificações de rastreamento remoto.

Aqui:

git branch --sort=-committerdate 

Ou (veja abaixo com Git 2.19)

# if you are sure to /always/ want to see branches ordered by commits:
git config --global branch.sort -committerdate
git branch

Veja também commit 9e46833 (30 de outubro de 2015) por Karthik Nayak ( KarthikNayak) .
Ajudado por: Junio ​​C Hamano ( gitster) .
(Mesclado por Junio ​​C Hamano - gitster- na confirmação 415095f , 03 de novembro de 2015)

Ao classificar de acordo com valores numéricos (por exemplo, --sort=objectsize ), não há comparação de fallback quando os dois refs mantêm o mesmo valor. Isso pode causar resultados inesperados (isto é, a ordem de listar referências com valores iguais não pode ser pré-determinada), como apontado por Johannes Sixt ( $ gmane / 280117 ).

Portanto, faça o fallback da comparação alfabética com base no nome da ref sempre que o outro critério for igual .

$ git branch --sort=objectsize

*  (HEAD detached from fromtag)
      branch-two
      branch-one
      master

Com o Git 2.19, a ordem de classificação pode ser definida por padrão.
git branchsuporta uma configuração branch.sort, como git tag, que já tinha uma configuração tag.sort.
Veja commit 560ae1c (16 ago 2018) por Samuel Maftoul (``) .
(Mesclado por Junio ​​C Hamano - gitster- in commit d89db6f , 27 de agosto de 2018)

branch.sort:

Essa variável controla a ordem de classificação das ramificações quando exibida por git-branch.
Sem a --sort=<value>opção " " fornecida, o valor dessa variável será usado como padrão.


Para listar ramificações remotas, use git branch -r --sort=objectsize. O -rsinalizador faz com que ele aliste ramificações remotas em vez de ramificações locais.


Com o Git 2.27 (segundo trimestre de 2020) ",git branchfor-each-ref variantes " e outras " " aceitaram várias --sort=<key>opções na ordem crescente de precedência, mas houve algumas falhas "--ignore-case " falhas no manuseio e empate com o refname, que foram corrigidos.

Consulte commit 7c5045f , commit 76f9e56 (03 de maio de 2020) por Jeff King ( peff) .
(Mesclado por Junio ​​C Hamano - gitster- no commit 6de1630 , 08 de maio de 2020)

ref-filter: aplicar classificação refname de fallback somente após todas as classificações de usuário

Assinado por: Jeff King

Confirmar 9e468334b4 (" ref-filter: fallback na comparação alfabética", 30/10/2015, Git v2.7.0-rc0 - mesclagem listada no lote # 10 ) ensinou a classificação do ref-filter a fallback na comparação de refnames.
Mas fez isso no nível errado, substituindo o resultado da comparação por um único "--sort " chave do usuário, em vez de depois que todas as chaves de classificação foram esgotadas.

Isso funcionou corretamente para um único "--sort " opção, mas não para várias.
Quebraríamos qualquer vínculo na primeira chave com o refname e nunca avaliaríamos a segunda chave.

Para tornar as coisas ainda mais interessantes, aplicamos esse fallback às vezes!
Para um campo como " taggeremail" que requer uma comparação de cadeias, retornaríamos realmente o resultado strcmp(), mesmo que fosse 0.
Mas para valuecampos " " numéricos como "taggerdate ", aplicamos o fallback. E é por isso que nosso teste de classificação múltipla perdeu isso: ele é usado taggeremailcomo comparação principal.

Então, vamos começar adicionando um teste muito mais rigoroso. Teremos um conjunto de confirmações expressando todas as combinações de dois e-mails, datas e nomes de nomes de marcadores. Em seguida, podemos confirmar que nossa classificação é aplicada com a precedência correta e pressionaremos os comparadores de string e valor.

Isso mostra o erro, e a correção é simples: mover o fallback para a compare_refs()função externa , afinalref_sorting teclas estiverem esgotadas.

Observe que na função externa não temos uma "ignore_case"bandeira, pois faz parte de cada ref_sortingelemento individual . É discutível o que esse fallback deve fazer, pois não usamos as chaves do usuário para corresponder.
Mas até agora tentamos respeitar essa bandeira, então a coisa menos invasiva é tentar continuar fazendo isso.
Como todos os chamadores no código atual definem o sinalizador para todas as teclas ou para nenhum, podemos simplesmente puxar o sinalizador da primeira tecla. Em um mundo hipotético em que o usuário realmente pode inverter a distinção entre maiúsculas e minúsculas de chaves separadamente, podemos estender o código para distinguir esse caso de um cobertor " --ignore-case".

VonC
fonte
Para listar controles remotos com essa opção, adicione-r
Troy Daniels
@TroyDaniels concordou. Você pode editar a resposta. Vou revisar sua edição.
VonC 26/10/19
19

Eu gosto de usar uma data relativa e encurtar o nome do ramo assim:

git for-each-ref --sort='-authordate:iso8601' --format=' %(authordate:relative)%09%(refname:short)' refs/heads

O que fornece saída:

21 minutes ago  nathan/a_recent_branch
6 hours ago     master
27 hours ago    nathan/some_other_branch
29 hours ago    branch_c
6 days ago      branch_d

Eu recomendo criar um arquivo Bash para adicionar todos os seus aliases favoritos e depois compartilhar o script para sua equipe. Aqui está um exemplo para adicionar apenas este:

#!/bin/sh

git config --global alias.branches "!echo ' ------------------------------------------------------------' && git for-each-ref --sort='-authordate:iso8601' --format=' %(authordate:relative)%09%(refname:short)' refs/heads && echo ' ------------------------------------------------------------'"

Em seguida, você pode fazer isso para obter uma lista de filiais locais bem formatada e classificada:

git branches

Atualização: Faça isso se quiser colorir:

#!/bin/sh
#
(echo ' ------------------------------------------------------------‌​' && git for-each-ref --sort='-authordate:iso8601' --format=' %(authordate:relative)%09%(refname:short)' refs/heads && echo ' ------------------------------------------------------------‌​') | grep --color -E "$(git rev-parse --abbrev-ref HEAD)$|$"
n8tr
fonte
Isso me dá #fatal: unknown field name: '-authordate:iso8601'
Factor Mystic
1
Saída colorida extravagante é chique, mas isso é simples e exatamente o que eu estava procurando. Substitua refs/headspor refs/remotespara dar uma olhada nas ramificações remotas.
precisa saber é o seguinte
O comando em si é agradável, mas o alias gera um erro:expansion of alias 'branches' failed; 'echo' is not a git command
Philip Kahn
Funciona para mim. O que acontece se você simplesmente copiar e colar isso no terminal? (echo ' ------------------------------------------------------------‌​' && git for-each-ref --sort='-authordate:iso8601' --format=' %(authordate:relative)%09%(refname:short)' refs/heads && echo ' ------------------------------------------------------------‌​') | grep --color -E "$(git rev-parse --abbrev-ref HEAD)$|$"
N8tr 15/04/19
17

A partir do Git 2.19, você pode simplesmente:

git branch --sort=-committerdate

Você também pode:

git config branch.sort -committerdate

Portanto, sempre que você listar ramificações no repositório atual, ele será listado classificado por data de envio.

Se, sempre que você listar ramificações, você desejar que elas sejam classificadas por data do emissor:

git config --global branch.sort -committerdate

Isenção de responsabilidade: sou o autor desse recurso no Git e o implementei quando vi essa pergunta.

user801247
fonte
2
Mais up-to-date resposta, muito mais fácil do que usar scripts complexos ou aliases 👌
mtefi
Use com cuidado! Cuidado com todos, este não é um comando para listar os ramos. É um comando para alterar a configuração do Git e terá repercussões globais permanentes.
Jazimov
1
@Jazimov você está certo, eu editei a resposta por isso é mais claro
user801247
11

Adiciona um pouco de cor (já que pretty-formatnão está disponível)

[alias]
    branchdate = for-each-ref --sort=-committerdate refs/heads/ --format="%(authordate:short)%09%(objectname:short)%09%1B[0;33m%(refname:short)%1B[m%09"
epylinkn
fonte
9

Eu tinha o mesmo problema, então escrevi uma gema Ruby chamada Twig . Ele lista ramificações em ordem cronológica (a mais nova primeiro) e também permite definir uma idade máxima para não listar todas as ramificações (se houver muitas). Por exemplo:

$ twig

                              issue  status       todo            branch
                              -----  ------       ----            ------
2013-01-26 18:00:21 (7m ago)  486    In progress  Rebase          optimize-all-the-things
2013-01-26 16:49:21 (2h ago)  268    In progress  -               whitespace-all-the-things
2013-01-23 18:35:21 (3d ago)  159    Shipped      Test in prod  * refactor-all-the-things
2013-01-22 17:12:09 (4d ago)  -      -            -               development
2013-01-20 19:45:42 (6d ago)  -      -            -               master

Também permite armazenar propriedades personalizadas para cada filial, por exemplo, ID do ticket, status, todos e filtrar a lista de agências de acordo com essas propriedades. Mais informações: http://rondevera.github.io/twig/

Ron DeVera
fonte
5
Esse nome pode não ajudar, pois tenho certeza de que existem alguns softwares com o mesmo nome.
thoroc
8

Eu vim com o seguinte comando (para Git 2.13 e posterior):

git branch -r --sort=creatordate \
    --format "%(creatordate:relative);%(committername);%(refname:lstrip=-1)" \
    | grep -v ";HEAD$" \
    | column -s ";" -t

Se você não possui, columnpode substituir a última linha por

    | sed -e "s/;/\t/g"

A saída parece

6 years ago             Tom Preston-Werner  book
4 years, 4 months ago   Parker Moore        0.12.1-release
4 years ago             Matt Rogers         1.0-branch
3 years, 11 months ago  Matt Rogers         1.2_branch
3 years, 1 month ago    Parker Moore        v1-stable
12 months ago           Ben Balter          pages-as-documents
10 months ago           Jordon Bedwell      make-jekyll-parallel
6 months ago            Pat Hawks           to_integer
5 months ago            Parker Moore        3.4-stable-backport-5920
4 months ago            Parker Moore        yajl-ruby-2-4-patch
4 weeks ago             Parker Moore        3.4-stable
3 weeks ago             Parker Moore        rouge-1-and-2
19 hours ago            jekyllbot           master

Eu escrevi um post sobre como as várias peças funcionam.

Bdesham
fonte
Agradável. +1. Ele usa o que git branch --sorteu mencionei em stackoverflow.com/a/33163401/6309 .
VonC 01/08/19
@DanNissenbaum Verifique se você está usando o Git 2.13 (lançado em maio de 2017) ou posterior.
bdesham
7

Para sua informação, se você deseja obter uma lista dos ramos que fizeram check-out recentemente (em vez dos que foram confirmados recentemente), pode usar o reflog do Git:

$ git reflog | egrep -io "moving from ([^[:space:]]+)" | awk '{ print $3 }' | head -n5
master
stable
master
some-cool-feature
feature/improve-everything

Veja também: Como posso obter uma lista dos ramos do Git que fiz check-out recentemente?

Jordan Brough
fonte
5

Aqui está um pequeno script que eu uso para alternar entre ramificações recentes:

#!/bin/bash
# sudo bash

re='^[0-9]+$'

if [[ "$1" =~ $re ]]; then
    lines="$1"
else
    lines=10
fi
branches="$(git recent | tail -n $lines | nl)"
branches_nf="$(git recent-nf | tail -n $lines | nl)"
echo "$branches"

# Prompt which server to connect to
max="$(echo "$branches" | wc -l)"
index=
while [[ ! ( "$index" =~ ^[0-9]+$ && "$index" -gt 0 && "$index" -le "$max" ) ]]; do
    echo -n "Checkout to: "
    read index
done

branch="$( echo "$branches_nf" | sed -n "${index}p" | awk '{ print $NF }' )"
git co $branch
clear

Usando esses dois aliases:

recent = for-each-ref --sort=committerdate refs/heads/ --format=' %(color:blue) %(authorname) %(color:yellow)%(refname:short)%(color:reset)'
recent-nf = for-each-ref --sort=committerdate refs/heads/ --format=' %(authorname) %(refname:short)'

Apenas chame isso em um repositório Git, e ele mostrará os últimos N ramos (10 por padrão) e um número de lado cada um. Insira o número da ramificação e faça o check-out:

Digite a descrição da imagem aqui

Agus Arias
fonte
4

Normalmente, consideramos os ramos remotos recentemente. Então tente isso

git fetch
git for-each-ref --sort=-committerdate refs/remotes/origin
Victor Choy
fonte
4

Aqui está outro script que faz o que todos os outros scripts fazem. De fato, ele fornece uma função para o seu shell.

Sua contribuição é que ele extrai algumas cores da sua configuração do Git (ou usa padrões).

# Git Branch by Date
# Usage: gbd [ -r ]
gbd() {
    local reset_color=`tput sgr0`
    local subject_color=`tput setaf 4 ; tput bold`
    local author_color=`tput setaf 6`

    local target=refs/heads
    local branch_color=`git config --get-color color.branch.local white`

    if [ "$1" = -r ]
    then
        target=refs/remotes/origin
        branch_color=`git config --get-color color.branch.remote red`
    fi

    git for-each-ref --sort=committerdate $target --format="${branch_color}%(refname:short)${reset_color} ${subject_color}%(subject)${reset_color} ${author_color}- %(authorname) (%(committerdate:relative))${reset_color}"
}
joeytwiddle
fonte
3

Isso é baseado na versão do saeedgnu , mas com o ramo atual mostrado com uma estrela e em cores e mostrando apenas algo que não foi descrito como "meses" ou "anos" atrás:

current_branch="$(git symbolic-ref --short -q HEAD)"
git for-each-ref --sort=committerdate refs/heads \
  --format='%(refname:short)|%(committerdate:relative)' \
  | grep -v '\(year\|month\)s\? ago' \
  | while IFS='|' read branch date
    do
      start='  '
      end=''
      if [[ $branch = $current_branch ]]; then
        start='* \e[32m'
        end='\e[0m'
      fi
      printf "$start%-30s %s$end\\n" "$branch" "$date"
    done
Mark Lodato
fonte
2

Meu melhor resultado como um script:

git for-each-ref --sort=-committerdate refs/heads/ --format='%(refname:short)|%(committerdate:iso)|%(authorname)' |
    sed 's/refs\/heads\///g' |
    grep -v BACKUP  | 
    while IFS='|' read branch date author
    do 
        printf '%-15s %-30s %s\n' "$branch" "$date" "$author"
    done
saeedgnu
fonte
1
Que tipo de script? Bater?
Peter Mortensen
2

git branch --sort=-committerdate | head -5

Para qualquer pessoa interessada em obter apenas os 5 principais nomes de agências, classificados com base na data do emissor.

erro desconhecido
fonte
1

Aqui está a variação que eu estava procurando:

git for-each-ref --sort=-committerdate --format='%(committerdate)%09%(refname:short)' refs/heads/ | tail -r

Isso tail -rinverte a lista para que a mais recente commiterdateseja a última.

Ben
fonte
3
Você também pode alterar --sort = -committerdate para --sort = committerdate para fazer isso.
Rephorm
Qual tailtem -r?
Christoffer Hammarström
1

Canalizo a saída da resposta aceita dialogpara uma lista interativa:

#!/bin/bash

TMP_FILE=/tmp/selected-git-branch

eval `resize`
dialog --title "Recent Git Branches" --menu "Choose a branch" $LINES $COLUMNS $(( $LINES - 8 )) $(git for-each-ref --sort=-committerdate refs/heads/ --format='%(refname:short) %(committerdate:short)') 2> $TMP_FILE

if [ $? -eq 0 ]
then
    git checkout $(< $TMP_FILE)
fi

rm -f $TMP_FILE

clear

Salvar como (por exemplo) ~/bin/git_recent_branches.she chmod +xele. Então, git config --global alias.rb '!git_recent_branches.sh'para me dar um novo git rbcomando.

John Delaney
fonte
1

Eu sei que já existem muitas respostas, mas aqui estão meus dois centavos para um alias simples (eu gosto de ter minha ramificação mais recente na parte inferior):

[alias]
        br = !git branch --sort=committerdate --color=always | tail -n15
[color "branch"]
        current = yellow
        local = cyan
        remote = red

Isso fornecerá uma boa visão geral dos seus 15 ramos mais recentes, em cores, com o ramo atual realçado (e possui um asterisco).

Tom
fonte
1

Ocorreu algum problema ao lidar com aspas simples no Mac no bash_profile ao tentar definir um alias. Esta resposta ajudou a resolvê-lo " Como escapar de aspas simples em cadeias de caracteres entre aspas simples

Solução de trabalho:

alias gb='git for-each-ref --sort=committerdate refs/heads/ --format='"'"'%(HEAD) %(color:yellow)%(refname:short)%(color:reset) - %(color:red)%(objectname:short)%(color:reset) - %(contents:subject) - %(authorname) (%(color:green)%(committerdate:relative)%(color:reset))'"'"''

PS Não foi possível comentar por causa da minha reputação

Aditya Kadam
fonte
0

git for-each-ref --sort=committerdate refs/heads/ --format='%(HEAD) %(color:yellow)%(refname:short)%(color:reset) - %(color:red)%(objectname:short)%(color:reset) - %(contents:subject) - %(authorname) (%(color:green)%(committerdate:relative)%(color:reset))' é isso que você precisa

ChunkCoder
fonte
0

O Git v2.19 apresenta a branch.sortopção de configuração (consulte branch.sort ).

Por isso git branch, classificará por data do committer (desc) por padrão com

# gitconfig
[branch]
    sort = -committerdate     # desc

roteiro:

$ git config --global branch.sort -committerdate

Atualizar:

Assim,

$ git branch
* dev
  master
  _

e

$ git branch -v
* dev    0afecf5 Merge branch 'oc' into dev
  master 652428a Merge branch 'dev'
  _      7159cf9 Merge branch 'bashrc' into dev
hIpPy
fonte