Come posso vedere quali rami Git stanno monitorando quale ramo remoto / upstream?

So di poterlo fare git branch --all, e questo mi mostra sia i rami locali sia quelli remoti, ma non è così utile nel mostrarmi le relazioni tra loro.

Come posso elencare i rami in un modo che mostri quale ramo locale sta monitorando quale telecomando?

Molto un comando di porcellana, non va bene se lo si desidera per gli script:

git branch -vv   # doubly verbose!

Nota che con git 1.8.3, quel ramo a monte viene visualizzato in blu (vedi " Che cos'è questo tracciamento del ramo (se presente) in git? ")

Se vuoi un output pulito, vedi la risposta di arcresu : usa un comando di porcellana che non credo esistesse al momento in cui ho scritto originariamente questa risposta, quindi è un po 'più conciso e funziona con i rami configurati per rebase, non solo unisci.

git remote show origin

Sostituisci "origine" con qualunque sia il nome del tuo telecomando.

Se guardi la pagina man per git-rev-parse, vedrai che è descritta la seguente sintassi:

<branchname>@{upstream}, ad es master@{upstream}.@{u}

Il suffisso @{upstream}per un nome di ramo (forma abbreviata <branchname>@{u}) si riferisce al ramo su cui è impostato il ramo specificato da nome di ramo. Un nome di ramo mancante viene impostato automaticamente su quello corrente.

Quindi per trovare l'upstream del ramo master, faresti:

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

Per stampare le informazioni per ogni ramo, potresti fare qualcosa del tipo:

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

Questo è più pulito dell'analisi dei ref e della configurazione manuale.

Un'alternativa alla risposta di Kubi è dare un'occhiata al .git/configfile che mostra la configurazione del repository locale:

cat .git/config

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

mostrerà una linea per ogni filiale locale. Un ramo di tracciamento sarà simile a:

master <- origin/master

Una non tracciabile sarà simile a:

test <- 

Per il ramo attuale , ecco due buone scelte:

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

o

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

Questa risposta è anche qui , a una domanda leggermente diversa che era (erroneamente) contrassegnata come duplicata.

Per il ramo corrente, potresti anche dire git checkout(senza alcun ramo). Questa è una no-op con effetti collaterali per mostrare le informazioni di tracciamento, se esistenti, per il ramo corrente.

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

Uso questo alias

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'

poi

git track

Basato sulla risposta di 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 solo locale con traccia configurata.

Scrivilo su uno script chiamato git-track sul tuo percorso e otterrai un comando git track

Una versione più elaborata su https://github.com/albfan/git-showupstream

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

ti darà il nome del telecomando che viene monitorato

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

ti darà il nome del ramo remoto che viene monitorato.

Dovrai sostituire $ current_branch con il nome della tua filiale attuale. Puoi farlo in modo dinamico congit rev-parse --abbrev-ref HEAD

Il seguente mini-script combina queste cose. Inseriscilo in un file chiamato git-tracking, rendilo eseguibile e assicurati che sia nel tuo percorso.

allora puoi dire

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

notare che il nome della filiale remota può essere diverso dal nome della filiale locale (anche se di solito non lo è). Per esempio:

$git tracking 
xxx_xls_xslx_thing -> origin/totally_bogus

come puoi vedere nel codice, la chiave è estrarre i dati dalla configurazione di git. Uso solo sed per cancellare i dati estranei.

#!/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"

Eccone uno pulito e semplice. Può controllare git remote -v, che mostra tutta l'origine e l'upstream del ramo corrente.