¿Puede "git pull --all" actualizar todas mis sucursales locales?

A menudo tengo al menos 3 sucursales remotas: maestra, puesta en escena y producción. Tengo 3 sucursales locales que rastrean esas sucursales remotas.

Actualizar todas mis sucursales locales es tedioso:

git fetch --all
git rebase origin/master
git checkout staging
git rebase origin/staging
git checkout production
git rebase origin/production

Me encantaría poder hacer un "git pull-all", pero no he podido hacerlo funcionar. Parece hacer una "búsqueda --todos", luego actualiza (adelanta o combina) la rama de trabajo actual, pero no las otras ramas locales.

Todavía estoy atascado cambiando manualmente a cada rama local y actualizando.

El comportamiento que describe pull --alles exactamente el esperado, aunque no necesariamente útil. La opción se pasa a git fetch, que luego obtiene todas las referencias de todos los controles remotos, en lugar de solo la necesaria; pullluego fusiona (o en su caso, vuelve a crear) la rama individual apropiada.

Si desea ver otras sucursales, tendrá que revisarlas. Y sí, la fusión (y el rebase) requieren absolutamente un árbol de trabajo, por lo que no se pueden hacer sin verificar las otras ramas. Si lo desea, puede resumir sus pasos descritos en un guión / alias, aunque sugeriría unir los comandos &&para que, en caso de que uno de ellos falle, no intente continuar.

Utilizo el syncsubcomando de hub para automatizar esto. Tengo alias git=huben mi .bash_profile, así que el comando que escribo es:

git sync

Esto actualiza todas las sucursales locales que tienen una rama ascendente coincidente. Desde la página del manual:

• Si la sucursal local está desactualizada, avance rápidamente;
• Si la sucursal local contiene trabajo no apresurado, advierta al respecto;
• Si la rama parece fusionada y se eliminó su rama ascendente, elimínela.

También maneja los cambios no confirmados de ocultación / desactivación en la rama actual.

Solía ​​usar una herramienta similar llamada git-up , pero ya no se mantiene y git synchace casi exactamente lo mismo.

Sé que esta pregunta tiene casi 3 años, pero me hice la misma pregunta y no encontré ninguna solución preparada. Entonces, creé un script de shell de comando git personalizado.

Aquí va, el git-ffwd-updatescript hace lo siguiente ...

1. emite una git remote updatepara buscar las últimas revoluciones
2. luego se usa git remote showpara obtener una lista de sucursales locales que rastrean una sucursal remota (por ejemplo, sucursales que se pueden usar con git pull)
3. luego comprueba con git rev-list --count <REMOTE_BRANCH>..<LOCAL_BRANCH>cuántos commit está la rama local detrás del remoto (y viceversa)
4. si la sucursal local tiene 1 o más confirmaciones por delante, NO se puede reenviar rápidamente y debe fusionarse o rehacerse manualmente
5. si la rama local tiene 0 confirmaciones por delante y 1 o más confirmaciones por detrás, puede reenviarse rápidamente mediante git branch -f <LOCAL_BRANCH> -t <REMOTE_BRANCH>

el script se puede llamar así:

$ git ffwd-update
Fetching origin
 branch bigcouch was 10 commit(s) behind of origin/bigcouch. resetting local branch to remote
 branch develop was 3 commit(s) behind of origin/develop. resetting local branch to remote
 branch master is 6 commit(s) behind and 1 commit(s) ahead of origin/master. could not be fast-forwarded

El script completo debe guardarse como git-ffwd-updatey debe estar en el PATH.

#!/bin/bash

main() {
  REMOTES="$@";
  if [ -z "$REMOTES" ]; then
    REMOTES=$(git remote);
  fi
  REMOTES=$(echo "$REMOTES" | xargs -n1 echo)
  CLB=$(git rev-parse --abbrev-ref HEAD);
  echo "$REMOTES" | while read REMOTE; do
    git remote update $REMOTE
    git remote show $REMOTE -n \
    | awk '/merges with remote/{print $5" "$1}' \
    | while read RB LB; do
      ARB="refs/remotes/$REMOTE/$RB";
      ALB="refs/heads/$LB";
      NBEHIND=$(( $(git rev-list --count $ALB..$ARB 2>/dev/null) +0));
      NAHEAD=$(( $(git rev-list --count $ARB..$ALB 2>/dev/null) +0));
      if [ "$NBEHIND" -gt 0 ]; then
        if [ "$NAHEAD" -gt 0 ]; then
          echo " branch $LB is $NBEHIND commit(s) behind and $NAHEAD commit(s) ahead of $REMOTE/$RB. could not be fast-forwarded";
        elif [ "$LB" = "$CLB" ]; then
          echo " branch $LB was $NBEHIND commit(s) behind of $REMOTE/$RB. fast-forward merge";
          git merge -q $ARB;
        else
          echo " branch $LB was $NBEHIND commit(s) behind of $REMOTE/$RB. resetting local branch to remote";
          git branch -f $LB -t $ARB >/dev/null;
        fi
      fi
    done
  done
}

main $@

No es tan difícil automatizar:

#!/bin/sh
# Usage: fetchall.sh branch ...

set -x
git fetch --all
for branch in "$@"; do
    git checkout "$branch"      || exit 1
    git rebase "origin/$branch" || exit 1
done

Esto todavía no es automático, ya que desearía que hubiera una opción, y debería haber alguna verificación para asegurarse de que esto solo pueda suceder para las actualizaciones de avance rápido (¡¡por eso es que hacer un tirón manualmente es mucho más seguro !!), pero aparte de las advertencias puedes:

git fetch origin
git update-ref refs/heads/other-branch origin/other-branch

para actualizar la posición de su sucursal local sin tener que verificarlo.

Nota: perderá su posición de sucursal actual y la moverá a donde está la sucursal del origen, lo que significa que si necesita fusionarse, ¡perderá datos!

Aquí hay muchas respuestas, pero ninguna que se use git-fetchpara actualizar el árbitro local directamente, lo cual es mucho más simple que retirar sucursales y más seguro quegit-update-ref .

Aquí usamos git-fetchpara actualizar ramas no actuales y git pull --ff-onlypara la rama actual. Eso:

• No requiere retirar sucursales
• Actualiza las sucursales solo si pueden reenviarse rápidamente
• Informará cuando no pueda avanzar rápidamente

Y aquí está:

#!/bin/bash
currentbranchref="$(git symbolic-ref HEAD 2>&-)"
git branch -r | grep -v ' -> ' | while read remotebranch
do
    # Split <remote>/<branch> into remote and branchref parts
    remote="${remotebranch%%/*}"
    branchref="refs/heads/${remotebranch#*/}"

    if [ "$branchref" == "$currentbranchref" ]
    then
        echo "Updating current branch $branchref from $remote..."
        git pull --ff-only
    else
        echo "Updating non-current ref $branchref from $remote..."
        git fetch "$remote" "$branchref:$branchref"
    fi
done

Desde la página de manual para git-fetch:

   <refspec>
       The format of a <refspec> parameter is an optional plus +, followed by the source ref <src>,
       followed by a colon :, followed by the destination ref <dst>.

       The remote ref that matches <src> is fetched, and if <dst> is not empty string, the local ref
       that matches it is fast-forwarded using <src>. If the optional plus + is used, the local ref is
       updated even if it does not result in a fast-forward update.

Al especificar git fetch <remote> <ref>:<ref>(sin ningún+ ) obtenemos una búsqueda que actualiza la referencia local solo cuando se puede reenviar rápidamente.

Nota : esto supone que las ramas locales y remotas tienen el mismo nombre (y que desea rastrear todas las ramas), realmente debería usar información sobre qué ramas locales tiene y qué están configuradas para rastrear.

Este problema no está resuelto (todavía), al menos no fácilmente / sin secuencias de comandos: vea esta publicación en la lista de correo git de Junio ​​C Hamano explicando la situación y solicitando una solución simple.

El razonamiento principal es que no debería necesitar esto:

Con git que no es antiguo (es decir, v1.5.0 o más reciente), no hay ninguna razón para tener un "dev" local que solo rastree el control remoto. Si solo desea mirar y ver, puede consultar la rama de seguimiento remoto directamente en un HEAD separado con " git checkout origin/dev".

Lo que significa que los únicos casos que necesitamos para que sea conveniente para los usuarios son manejar estas sucursales locales que "rastrean" las remotas cuando tiene cambios locales, o cuando planea tener algunos.

Si tiene cambios locales en "dev" que están marcados para rastrear la eliminación "dev", y si está en una rama diferente de "dev", entonces no deberíamos hacer nada después de " git fetch" actualiza el seguimiento remoto "dev" . No avanzará de todos modos

La llamada para una solución era para una opción o script externo para podar las sucursales locales que siguen ahora las sucursales de seguimiento remoto, en lugar de mantenerlas actualizadas mediante el avance rápido, como se solicitó en el póster original.

Entonces, ¿qué tal " git branch --prune --remote=<upstream>" que itera sobre las ramas locales, y si

(1) no es la rama actual; y
(2) está marcado para rastrear alguna rama tomada de <upstream>; y
(3) no tiene ningún compromiso por sí solo;

entonces quitar esa rama? " git remote --prune-local-forks <upstream>" también está bien; No me importa qué comando implemente tanto la función.

Nota: a partir de git 2.10 no existe tal solución. Tenga en cuenta que elgit remote prunesubcomando, ygit fetch --prunese trata de eliminar la bifurcación de seguimiento remoto para la bifurcación que ya no existe en la remota, no se trata de eliminar la bifurcación local que rastrea la bifurcación de seguimiento remoto (para la cual la bifurcación de seguimiento remoto es la bifurcación ascendente).

Aquí hay muchas respuestas aceptables, pero algunas de las tuberías pueden ser un poco opacas para los no iniciados. Aquí hay un ejemplo mucho más simple que se puede personalizar fácilmente:

$ cat ~/bin/git/git-update-all
#!/bin/bash
# Update all local branches, checking out each branch in succession.
# Eventually returns to the original branch. Use "-n" for dry-run.
git_update_all() {
  local run br
  br=$(git name-rev --name-only HEAD 2>/dev/null)
  [ "$1" = "-n" ] && shift && run=echo

  for x in $( git branch | cut -c3- ) ; do
     $run git checkout $x && $run git pull --ff-only || return 2
  done

  [ ${#br} -gt 0 ] && $run git checkout "$br"
}

git_update_all "$@"

Si agrega ~/bin/gita su PATH(suponiendo que el archivo es ~/bin/git/git-update-all), puede ejecutar:

$ git update-all

Agregue este script a .profileen Mac OS X:

# Usage:
#   `git-pull-all` to pull all your local branches from origin
#   `git-pull-all remote` to pull all your local branches from a named remote

function git-pull-all() {
    START=$(git symbolic-ref --short -q HEAD);
    for branch in $(git branch | sed 's/^.//'); do
        git checkout $branch;
        git pull ${1:-origin} $branch || break;
    done;
    git checkout $START;
};

function git-push-all() {
    git push --all ${1:-origin};
};

Aquí hay una buena respuesta: cómo obtener todas las ramas git

for remote in `git branch -r`; do git branch --track $remote; done
git pull --all

Un guión que escribí para mi GitBash . Logra lo siguiente:

• De manera predeterminada, el origen de todas las ramas que están configuradas para rastrear el origen le permite especificar un control remoto diferente si lo desea.
• Si su rama actual está en un estado sucio, oculta sus cambios e intentará restaurarlos al final.
• Para cada sucursal local que esté configurada para rastrear una sucursal remota:
  • git checkout branch
  • git pull origin
• Finalmente, lo regresará a su rama original y restaurará el estado.

** Lo uso pero no lo he probado completamente, uso bajo su propio riesgo. Vea un ejemplo de este script en un archivo .bash_alias aquí .

    # Do a pull on all branches that are tracking a remote branches, will from origin by default.
    # If current branch is dirty, will stash changes and reply after pull.
    # Usage: pullall [remoteName]
    alias pullall=pullAll
    function pullAll (){
     # if -h then show help
     if [[ $1 == '-h' ]]
    then
      echo "Description: Pulls new changes from upstream on all branches that are tracking remotes."
      echo 
      echo "Usage: "
      echo "- Default: pullall"
      echo "- Specify upstream to pull from: pullall [upstreamName]"
      echo "- Help: pull-all -h"
    else

     # default remote to origin
     remote="origin"
     if [ $1 != "" ]
     then
       remote=$1
     fi

     # list all branches that are tracking remote
     # git branch -vv : list branches with their upstreams
     # grep origin : keep only items that have upstream of origin
     # sed "s/^.."... : remove leading *
     # sed "s/^"..... : remove leading white spaces
     # cut -d" "..... : cut on spaces, take first item
     # cut -d splits on space, -f1 grabs first item
     branches=($(git branch -vv | grep $remote | sed "s/^[ *]*//" | sed "s/^[ /t]*//" | cut -d" " -f1))

     # get starting branch name
     startingBranch=$(git rev-parse --abbrev-ref HEAD)

     # get starting stash size
     startingStashSize=$(git stash list | wc -l)

     echo "Saving starting branch state: $startingBranch"
     git stash

     # get the new stash size
     newStashSize=$(git stash list | wc -l)

     # for each branch in the array of remote tracking branches
     for branch in ${branches[*]}
     do
       echo "Switching to $branch"
       git checkout $branch

       echo "Pulling $remote"
       git pull $remote

     done

     echo "Switching back to $startingBranch"
     git checkout $startingBranch

     # compare before and after stash size to see if anything was stashed
     if [ "$startingStashSize" -lt "$newStashSize" ]
     then
       echo "Restoring branch state"
       git stash pop
     fi
    fi
    }

Si está en Windows, puede usar PyGitUp, que es un clon de git-upPython. Puede instalarlo usando pip con pip install --user git-upo a través de Scoop usandoscoop install git-up

[

Solo publicando una respuesta actualizada. git-upya no se mantiene y si lee la documentación, mencionan que la funcionalidad ahora está disponible en git .

A partir de Git 2.9, git pull --rebase --autostash hace básicamente lo mismo.

En consecuencia, si actualiza a Git 2.9 o posterior, puede usar este alias en lugar de instalar git-up:

git config --global alias.up 'pull --rebase --autostash'

También puede configurar esto para cada git pullGit 2.9 también (gracias @VonC, consulte su respuesta aquí )

git config --global pull.rebase true
git config --global rebase.autoStash true

Me encontré con el mismo problema de esta pregunta ...

Preguntándome al respecto, hice una pequeña función de alias dentro de mi .bashrcarchivo:

gitPullAll() {
    for branch in `git branch | sed -E 's/^\*/ /' | awk '{print $1}'`; do
        git checkout $branch
        git pull -p
        printf "\n"
    done
    echo "Done"
}

Trabajó para mi (:

Si las referencias / cabezas / maestro se pueden reenviar rápidamente a referencias / controles remotos / foo / maestro , la salida de

git merge-base refs/heads/master refs/remotes/foo/master

debería devolver la identificación SHA1 a la que hace referencia las referencias / cabezas / puntos maestros . Con esto, puede armar una secuencia de comandos que actualice automáticamente todas las sucursales locales a las que no se les han aplicado confirmaciones de desvío.

Este pequeño script de shell (lo llamé git-can-ff ) ilustra cómo se puede hacer.

#!/bin/sh

set -x

usage() {
    echo "usage: $(basename $0) <from-ref> <to-ref>" >&2
    exit 2
}

[ $# -ne 2 ] && usage

FROM_REF=$1
TO_REF=$2

FROM_HASH=$(git show-ref --hash $FROM_REF)
TO_HASH=$(git show-ref --hash $TO_REF)
BASE_HASH=$(git merge-base $FROM_REF $TO_REF)

if [ "$BASE_HASH" = "$FROM_HASH" -o \
     "$BASE_HASH" = "$FROM_REF" ]; then
    exit 0
else
    exit 1
fi

Para completar la respuesta de Matt Connolly, esta es una forma más segura de actualizar las referencias de sucursales locales que pueden reenviarse rápidamente, sin consultar la sucursal. No actualiza las ramas que no pueden reenviarse rápidamente (es decir, que han divergido), y no actualiza la rama que está actualmente desprotegida (porque entonces la copia de trabajo también debe actualizarse).

git fetch

head="$(git symbolic-ref HEAD)"
git for-each-ref --format="%(refname) %(upstream)" refs/heads | while read ref up; do
    if [ -n "$up" -a "$ref" != "$head" ]; then
        mine="$(git rev-parse "$ref")"
        theirs="$(git rev-parse "$up")"
        base="$(git merge-base "$ref" "$up")"
        if [ "$mine" != "$theirs" -a "$mine" == "$base" ]; then
            git update-ref "$ref" "$theirs"
        fi
    fi
done

Un script ligeramente diferente que solo adelanta rápidamente las ramas cuyos nombres coinciden con su rama ascendente. También actualiza la rama actual si es posible el avance rápido.

Asegúrese de que todas las ramas aguas arriba de sus ramas estén configuradas correctamente al ejecutarlas git branch -vv. Establecer la rama aguas arriba congit branch -u origin/yourbanchname

Copie y pegue en un archivo y chmod 755:

#!/bin/sh

curbranch=$(git rev-parse --abbrev-ref HEAD)

for branch in $(git for-each-ref refs/heads --format="%(refname:short)"); do
        upbranch=$(git config --get branch.$branch.merge | sed 's:refs/heads/::');
        if [ "$branch" = "$upbranch" ]; then
                if [ "$branch" = "$curbranch" ]; then
                        echo Fast forwarding current branch $curbranch
                        git merge --ff-only origin/$upbranch
                else
                        echo Fast forwarding $branch with origin/$upbranch
                        git fetch . origin/$upbranch:$branch
                fi
        fi
done;

El siguiente one-liner avanza rápidamente todas las ramas que tienen una rama ascendente si es posible, e imprime un error de lo contrario:

git branch \
  --format "%(if)%(upstream:short)%(then)git push . %(upstream:short):%(refname:short)%(end)" |
  sh

¿Como funciona?

Utiliza un formato personalizado con el git branchcomando. Para cada rama que tiene una rama ascendente, imprime una línea con el siguiente patrón:

git push . <remote-ref>:<branch>

Esto se puede canalizar directamente sh(suponiendo que los nombres de las ramas estén bien formados). Omitir el| sh para ver lo que está haciendo.

Advertencias

El one-liner no contactará con sus controles remotos. Emita uno git fetcho git fetch --allantes de ejecutarlo.

La rama actualmente desprotegida no se actualizará con un mensaje como

! [remote rejected] origin/master -> master (branch is currently checked out)

Para esto, puede recurrir a regular git pull --ff-only.

Alias

Agregue lo siguiente a su .gitconfigpara que git fftrealice este comando:

[alias]
        fft = !sh -c 'git branch --format \"%(if)%(upstream:short)%(then)git push . %(upstream:short):%(refname:short)%(end)\" | sh' -

Ver también mi .gitconfig. El alias es una forma abreviada de "seguimiento rápido (ramas)".

El script de @larsmans, un poco mejorado:

#!/bin/sh

set -x
CURRENT=`git rev-parse --abbrev-ref HEAD`
git fetch --all
for branch in "$@"; do
  if ["$branch" -ne "$CURRENT"]; then
    git checkout "$branch" || exit 1
    git rebase "origin/$branch" || exit 1
  fi
done
git checkout "$CURRENT" || exit 1
git rebase "origin/$CURRENT" || exit 1

Esto, después de que termina, deja la copia de trabajo desprotegida de la misma rama que estaba antes de que se llamara al script.

La git pullversión:

#!/bin/sh

set -x
CURRENT=`git rev-parse --abbrev-ref HEAD`
git fetch --all
for branch in "$@"; do
  if ["$branch" -ne "$CURRENT"]; then
    git checkout "$branch" || exit 1
    git pull || exit 1
  fi
done
git checkout "$CURRENT" || exit 1
git pull || exit 1

Parece que muchos otros han aportado soluciones similares, pero pensé en compartir lo que se me ocurrió e invitar a otros a contribuir. Esta solución tiene una salida agradable y colorida, maneja con gracia su directorio de trabajo actual, y es rápido porque no hace ningún pago y deja su directorio de trabajo intacto. Además, es solo un script de shell sin dependencias distintas de git. (Solo probado en OSX hasta ahora)

#!/usr/bin/env bash

gitup(){    
RED='\033[33;31m'
YELLO='\033[33;33m'
GREEN='\033[33;32m'
NC='\033[0m' # No Color

HEAD=$(git rev-parse HEAD)
CHANGED=$(git status --porcelain | wc -l)

echo "Fetching..."
git fetch --all --prune &>/dev/null
for branch in `git for-each-ref --format='%(refname:short)' refs/heads`; do

    LOCAL=$(git rev-parse --quiet --verify $branch)
    if [ "$HEAD" = "$LOCAL" ] && [ $CHANGED -gt 0 ]; then
        echo -e "${YELLO}WORKING${NC}\t\t$branch"
    elif git rev-parse --verify --quiet $branch@{u}&>/dev/null; then
        REMOTE=$(git rev-parse --quiet --verify $branch@{u})
        BASE=$(git merge-base $branch $branch@{u})

        if [ "$LOCAL" = "$REMOTE" ]; then
           echo -e "${GREEN}OK${NC}\t\t$branch" 
        elif [ "$LOCAL" = "$BASE" ]; then
            if [ "$HEAD" = "$LOCAL" ]; then
                git merge $REMOTE&>/dev/null
            else
                git branch -f $branch $REMOTE
            fi
            echo -e "${GREEN}UPDATED${NC}\t\t$branch"
        elif [ "$REMOTE" = "$BASE" ]; then
            echo -e "${RED}AHEAD${NC}\t\t$branch"
        else
            echo -e "${RED}DIVERGED${NC}\t\t$branch"
        fi
    else
        echo -e "${RED}NO REMOTE${NC}\t$branch"
    fi
done
}

https://github.com/davestimpert/gitup

Lo siento, también parece que se me ocurrió el mismo nombre que la otra herramienta anterior.

Se puede hacer usando el siguiente script ... Primero buscará todas las ramas y pagará una por una y se actualizará solo.

#!/bin/bash
git branch -r | grep -v '\->' | while read remote; do git branch --track 
"${remote#origin/}" "$remote"; done

set -x
CURRENT=`git rev-parse --abbrev-ref HEAD`
git fetch --all
branch_name=$(git branch | awk '{print $1" "}' | grep -v '*' | xargs)
for branch in $branch_name; do
   git checkout "$branch" || exit 1
   git rebase "origin/$branch" || exit 1
   git pull origin $branch|| exit 1
done
git checkout "$CURRENT" || exit 1
git pull || exit 1

No puede hacerlo con un solo comando git, pero puede automatizarlo con una línea bash.

Para actualizar de forma segura todas las ramas con una línea, esto es lo que hago:

git fetch --all && for branch in $(git branch | sed '/*/{$q;h;d};$G' | tr -d '*') ; do git checkout $branch && git merge --ff-only || break ; done

• Si no puede avanzar rápidamente una rama o encontrar un error, se detendrá y lo dejará en esa rama para que pueda recuperar el control y fusionarse manualmente.

• Si todas las ramas se pueden reenviar rápidamente, finalizará con la rama en la que se encontraba actualmente, dejándolo donde estaba antes de la actualización.

Explicaciones:

Para una mejor legibilidad, se puede dividir en varias líneas:

git fetch --all && \
for branch in $(git branch | sed '/*/{$q;h;d};$G' | tr -d '*')
    do git checkout $branch && \
    git merge --ff-only || break
done

1. git fetch --all && ... => Obtiene todas las referencias de todos los controles remotos y continúa con el siguiente comando si no ha habido ningún error.

2. git branch | sed '/*/{$q;h;d};$G' | tr -d '*'=> Desde la salida de git branch, sedtome la línea con a *y muévala hasta el final (para que la rama actual se actualice por última vez). Luego trsimplemente quite el *.

3. for branch in $(...) ; do git checkout $branch && git merge --ff-only || break ; done=> Para cada nombre de rama obtenido del comando anterior, desproteja esta rama e intente fusionarse con un avance rápido. Si falla, breakse llama y el comando se detiene aquí.

Por supuesto, puede reemplazar git merge --ff-onlycon git rebasesi es lo que desea.

Finalmente, puedes ponerlo en tu bashrc como un alias:

alias git-pull-all='git fetch --all && for branch in $(git branch | sed '\''/*/{$q;h;d};$G'\'' | tr -d "*") ; do git checkout $branch && git merge --ff-only || break ; done'

O si tiene miedo de equivocarse con 'y', o simplemente prefiere mantener la legibilidad sintáctica en su editor, puede declararlo como una función:

git-pull-all()
{
    git fetch --all && for branch in $(git branch | sed '/*/{$q;h;d};$G' | tr -d '*') ; do git checkout $branch && git merge --ff-only || break ; done
}

Prima:

Para aquellos que deseen la explicación por sed '/*/{$q;h;d};$G'parte:

• /*/=> Busque la línea con a *.

• {$q => Si está en la última línea, salga (no necesitamos hacer nada porque la rama actual ya es la última en la lista).

• ;h;d} => De lo contrario, almacene la línea en el búfer de retención y elimínela en la posición actual de la lista.

• ;$G => Cuando llegue a la última línea, agregue el contenido del búfer de retención.

¿Puede "git pull --all" actualizar todas mis sucursales locales?

No, no puede. Para el avance rápido, acabo de escribir una pequeña herramienta para hacerlo. https://github.com/changyuheng/git-fast-forward-all

Ventajas de esta herramienta:

1. Admite múltiples controles remotos en un repositorio. ( hub syncno admite múltiples controles remotos por el momento).
2. Admite tener diferentes nombres en la sucursal local y la correspondiente sucursal de seguimiento remoto.
3. Mucho más rápido que otros scripts que recuperan remotamente para cada rama.
4. Sin análisis / edición de expresiones regulares propensas a errores.

A partir de git 2.9:

git pull --rebase --autostash

Ver https://git-scm.com/docs/git-rebase

Cree automáticamente un alijo temporal antes de que comience la operación y aplíquelo después de que finalice la operación. Esto significa que puede ejecutar rebase en un árbol de trabajo sucio. Sin embargo, utilice con cuidado: la aplicación de almacenamiento final después de un cambio de versión exitoso puede dar lugar a conflictos no triviales.

De hecho, con git version 1.8.3.1, funciona:

[root@test test]# git br
* master
  release/0.1
  update
[root@test test]# git pull --rebase
remote: Enumerating objects: 9, done.
remote: Counting objects: 100% (9/9), done.
remote: Compressing objects: 100% (9/9), done.
remote: Total 9 (delta 2), reused 0 (delta 0)
Unpacking objects: 100% (9/9), done.
From http://xxx/scm/csdx/test-git
   d32ca6d..2caa393  release/0.1 -> origin/release/0.1
Current branch master is up to date.
[root@test test]# git --version
git version 1.8.3.1

En la rama maestra, puede actualizar todas las demás ramas. @Cascabel

No sé qué versión romperlo / arreglarlo, en 2.17 (que uso), puede funcionar.