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?

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:

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:

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:

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)'

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

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:

Use '|' separar.

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)) '

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'"]++'"

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.

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".

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)$|$"

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.

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"

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/

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.

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?

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:

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

git fetch
git for-each-ref --sort=-committerdate refs/remotes/origin

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}"
}

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

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

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.

A resposta da linha de comando aceita é ótima, mas se você quiser algo mais bonito, como uma GUI, e sua origem === "github".

Você pode clicar em "Ramos" no repositório. Ou acesse o URL diretamente: https://github.com/ORGANIZATION_NAME/REPO_NAME/branches

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.

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.

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).

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

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

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