¿Cómo puedo ver qué ramas de Git están rastreando qué rama remota / aguas arriba?

Sé que puedo hacerlo git branch --all, y eso me muestra ramas locales y remotas, pero no es tan útil para mostrarme las relaciones entre ellas.

¿Cómo enumero sucursales de una manera que muestre qué sucursal local está rastreando qué control remoto?

Muy un comando de porcelana, no es bueno si quieres esto para scripting:

git branch -vv   # doubly verbose!

Tenga en cuenta que con git 1.8.3, esa rama ascendente se muestra en azul (consulte " ¿Qué es el seguimiento de esta rama (si hay algo) en git? ")

Si desea una salida limpia, vea la respuesta de arcresu : utiliza un comando de porcelana que no creo que existiera en el momento en que escribí originalmente esta respuesta, por lo que es un poco más conciso y funciona con ramas configuradas para rebase, no solo fusión.

git remote show origin

Reemplace 'origen' con el nombre de su control remoto.

Si observa la página de manual git-rev-parse, verá que se describe la siguiente sintaxis:

<branchname>@{upstream}, Por ejemplo master@{upstream},@{u}

El sufijo @{upstream}de un nombre de rama (forma abreviada <branchname>@{u}) se refiere a la rama que la rama especificada por nombre de rama está configurada para construir encima. Un nombre de rama que falta es el predeterminado.

Por lo tanto, para encontrar el flujo ascendente de la rama master, haría:

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

Para imprimir la información de cada rama, puede hacer 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
# ...

Esto es más limpio que analizar referencias y configuraciones manualmente.

Una alternativa a la respuesta de kubi es echar un vistazo al .git/configarchivo que muestra la configuración del repositorio local:

cat .git/config

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

mostrará una línea para cada sucursal local. Una rama de seguimiento se verá así:

master <- origin/master

Una que no sea de seguimiento se verá así:

test <- 

Para la rama actual , aquí hay dos buenas opciones:

% 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

Esa respuesta también está aquí , a una pregunta ligeramente diferente que fue marcada (erróneamente) como un duplicado.

Para la rama actual, también podría decir git checkout(sin ninguna rama). Este es un no-op con efectos secundarios para mostrar la información de seguimiento, si existe, para la rama actual.

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

Yo uso este 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'

entonces

git track

Basado en la respuesta 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

Muestra solo local con la pista configurada.

Escríbalo en un script llamado git-track en su ruta y obtendrá un comando git track

Una versión más elaborada en https://github.com/albfan/git-showupstream

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

le dará el nombre del control remoto que se está rastreando

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

le dará el nombre de la rama remota que se está rastreando.

Deberá reemplazar $ current_branch con el nombre de su sucursal actual. Puede obtener eso dinámicamente congit rev-parse --abbrev-ref HEAD

El siguiente mini script combina esas cosas. Péguelo en un archivo llamado git-tracking, hágalo ejecutable y asegúrese de que esté en su camino.

entonces puedes decir

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

tenga en cuenta que el nombre de la sucursal remota puede ser diferente del nombre de su sucursal local (aunque generalmente no lo es). Por ejemplo:

$git tracking 
xxx_xls_xslx_thing -> origin/totally_bogus

Como puede ver en el código, la clave para esto es extraer los datos de la configuración de git. Solo uso sed para borrar los datos extraños.

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

Aquí hay uno simple y ordenado. Puede verificar git remote -v, que le muestra todo el origen y el flujo ascendente de la rama actual.