Como posso ver quais ramificações do Git estão rastreando qual ramificação remota / upstream?

Eu sei que posso fazer git branch --all , e isso me mostra ramificações locais e remotas, mas não é tão útil para me mostrar o relacionamento entre elas.

Como listar ramificações de uma maneira que mostre qual ramificação local está rastreando qual remoto?

Um comando de porcelana, não é bom se você deseja isso para scripts:

git branch -vv   # doubly verbose!

Observe que, com o git 1.8.3, esse ramo upstream é exibido em azul (consulte " O que esse ramo está rastreando (se houver) no git? ")

Se você deseja uma saída limpa, consulte a resposta do arcresu - ele usa um comando de porcelana que não acredito que existia no momento em que escrevi essa resposta originalmente, por isso é um pouco mais conciso e funciona com ramificações configuradas para rebase, não apenas para mesclagem.

git remote show origin

Substitua 'origem' por qualquer que seja o nome do seu controle remoto.

Se você olhar para a página de manual git-rev-parse, verá a seguinte sintaxe descrita:

<branchname>@{upstream}por exemplo master@{upstream},@{u}

O sufixo @{upstream}para um nome da ramificação (formato abreviado <branchname>@{u}) refere-se à ramificação que a ramificação especificada por nome da ramificação está configurada para construir. Um nome de filial ausente é padronizado como o atual.

Portanto, para encontrar a montante do ramo master, você faria:

git rev-parse --abbrev-ref master@{upstream}
# => origin/master

Para imprimir as informações de cada filial, você pode fazer algo como:

while read branch; do
  upstream=$(git rev-parse --abbrev-ref $branch@{upstream} 2>/dev/null)
  if [[ $? == 0 ]]; then
    echo $branch tracks $upstream
  else
    echo $branch has no upstream configured
  fi
done < <(git for-each-ref --format='%(refname:short)' refs/heads/*)

# Output:
# master tracks origin/master
# ...

Isso é mais limpo do que analisar refs e config manualmente.

Uma alternativa à resposta do kubi é dar uma olhada no .git/configarquivo que mostra a configuração do repositório local:

cat .git/config

git for-each-ref --format='%(refname:short) <- %(upstream:short)' refs/heads

mostrará uma linha para cada filial local. Um ramo de rastreamento será semelhante a:

master <- origin/master

Um sem rastreamento será parecido com:

test <- 

Para a ramificação atual , aqui estão duas boas opções:

% git rev-parse --abbrev-ref --symbolic-full-name @{u}
origin/mainline

ou

% git for-each-ref --format='%(upstream:short)' $(git symbolic-ref -q HEAD)
origin/mainline

Essa resposta também está aqui , para uma pergunta um pouco diferente que foi (erroneamente) marcada como duplicada.

Para a ramificação atual, você também pode dizer git checkout(sem ramificação). Este é um no-op com efeitos colaterais para mostrar as informações de rastreamento, se existir, do ramo atual.

$ git checkout 
Your branch is up-to-date with 'origin/master'.

Eu uso esse apelido

git config --global alias.track '!f() { ([ $# -eq 2 ] && ( echo "Setting tracking for branch " $1 " -> " $2;git branch --set-upstream $1 $2; ) || ( git for-each-ref --format="local: %(refname:short) <--sync--> remote: %(upstream:short)" refs/heads && echo --Remotes && git remote -v)); }; f'

então

git track

Com base na resposta de Olivier Refalo

if [ $# -eq 2 ] 
then
    echo "Setting tracking for branch " $1 " -> " $2
    git branch --set-upstream $1 $2
else
    echo "-- Local --" 
    git for-each-ref --shell --format="[ %(upstream:short) != '' ] && echo -e '\t%(refname:short) <--> %(upstream:short)'" refs/heads | sh
    echo "-- Remote --" 
    REMOTES=$(git remote -v) 
    if [ "$REMOTES" != '' ]
    then
        echo $REMOTES
    fi  
fi

Mostra apenas local com a faixa configurada.

Escreva em um script chamado git-track no seu caminho e você receberá um comando git track

Uma versão mais elaborada em https://github.com/albfan/git-showupstream

git config --get-regexp "branch\.$current_branch\.remote"

lhe dará o nome do controle remoto que está sendo rastreado

git config --get-regexp "branch\.$current_branch\.merge"

fornecerá o nome da ramificação remota que está sendo rastreada.

Você precisará substituir $ current_branch pelo nome da sua filial atual. Você pode conseguir isso dinamicamente comgit rev-parse --abbrev-ref HEAD

O mini-script a seguir combina essas coisas. Cole-o em um arquivo chamadogit-tracking , torne-o executável e verifique se ele está no seu caminho.

então você pode dizer

$ git  tracking
<current_branch_name>-><remote_repo_name>/<remote_branch_name>

observe que o nome da filial remota pode ser diferente do nome da filial local (embora geralmente não seja). Por exemplo:

$git tracking 
xxx_xls_xslx_thing -> origin/totally_bogus

como você pode ver no código, a chave para isso é extrair os dados da configuração do git. Eu apenas uso sed para limpar os dados estranhos.

#!/bin/sh

current_branch=$(git rev-parse --abbrev-ref HEAD)
remote=$(git config --get-regexp "branch\.$current_branch\.remote" | sed -e "s/^.* //")
remote_branch=$(git config --get-regexp "branch\.$current_branch\.merge" | \
  sed -e "s/^.* //" -e "s/refs\/.*\///")

echo "$current_branch -> $remote/$remote_branch"

Aqui está um puro e simples. Pode verificar git remote -v, que mostra toda a origem e a montante da ramificação atual.