O "git pull --all" pode atualizar todos os meus ramos locais?

Geralmente, tenho pelo menos três filiais remotas: mestre, preparação e produção. Eu tenho três filiais locais que rastreiam essas filiais remotas.

Atualizar todas as minhas filiais locais é entediante:

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

Eu adoraria poder fazer um "git pull-all", mas não consegui fazê-lo funcionar. Parece fazer uma "busca - tudo" e, em seguida, atualiza (avanço rápido ou mescla) o ramo de trabalho atual, mas não os outros ramos locais.

Ainda estou preso alternando manualmente para cada filial local e atualizando.

O comportamento para o qual você descreve pull --allé exatamente como o esperado, embora não seja necessariamente útil. A opção é passada para o git fetch, que busca todos os refs de todos os controles remotos, em vez do necessário; pulldepois mescla (ou, no seu caso, rebase) a ramificação única apropriada.

Se você quiser conferir outras filiais, precisará verificá-las. E sim, a mesclagem (e a reformulação) exige absolutamente uma árvore de trabalho, para que não possam ser feitas sem verificar os outros ramos. Você pode agrupar as etapas descritas em um script / alias, se quiser, embora eu sugira associar os comandos &&para que, caso um deles falhe, ele não tente seguir adiante.

Eu uso o syncsubcomando do hub para automatizar isso. Eu tenho alias git=hubno meu .bash_profile, então o comando que eu digito é:

git sync

Isso atualiza todas as ramificações locais que possuem uma ramificação upstream correspondente. Na página do manual:

• Se a ramificação local estiver desatualizada, avance-a rapidamente;
• Se a filial local contiver trabalho não enviado, avise-o;
• Se a ramificação parecer mesclada e sua ramificação upstream foi excluída, exclua-a.

Ele também lida com as alterações não confirmadas ocultas / desimpedidas na ramificação atual.

Eu costumava usar uma ferramenta semelhante chamada git-up , mas não é mais mantida e git syncfaz quase exatamente a mesma coisa.

Sei que esta pergunta tem quase 3 anos, mas me perguntei a mesma pergunta e não encontrei nenhuma solução pronta. Então, eu criei um script de shell de comando git personalizado.

Aqui está, o git-ffwd-updatescript faz o seguinte ...

1. emite um git remote updatepara buscar as revs lates
2. depois usa git remote showpara obter uma lista de ramificações locais que rastreiam uma ramificação remota (por exemplo, ramificações que podem ser usadas com git pull)
3. depois, verifica com git rev-list --count <REMOTE_BRANCH>..<LOCAL_BRANCH>quantos commit a filial local está atrás do controle remoto (e vice-versa)
4. se a filial local for 1 ou mais confirmada adiante, NÃO poderá ser encaminhada com rapidez e precisará ser mesclada ou reformulada manualmente
5. se a ramificação local for 0 confirmada adiante e 1 ou mais confirmada atrasada, poderá ser encaminhada rapidamente por git branch -f <LOCAL_BRANCH> -t <REMOTE_BRANCH>

o script pode ser chamado como:

$ 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

O script completo deve ser salvo como git-ffwd-updatee precisa estar no 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 $@

Não é tão difícil de 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

Isso ainda não é automático, como eu gostaria que houvesse uma opção para - e deve haver alguma verificação para garantir que isso só ocorra em atualizações de avanço rápido (e é por isso que fazer um pull manualmente é muito mais seguro !!), mas ressalvas, você pode:

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

para atualizar a posição de sua filial local sem precisar fazer check-out.

Nota: você estará perdendo sua posição atual de ramificação e movendo-a para onde está a ramificação de origem, o que significa que, se você precisar mesclar, perderá dados!

Há muitas respostas aqui, mas nenhuma é usada git-fetchpara atualizar diretamente a referência local, o que é muito mais simples do que verificar filiais e mais segura do que git-update-ref.

Aqui usamos git-fetchpara atualizar ramificações não atuais e git pull --ff-onlypara a ramificação atual. Isto:

• Não requer check out branches
• Atualiza ramificações somente se elas puderem avançar rapidamente
• Relatará quando não puder avançar rapidamente

e aqui 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

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

Ao especificar git fetch <remote> <ref>:<ref>(sem nenhum +), obtemos uma busca que atualiza a ref local apenas quando ela pode ser encaminhada rapidamente.

Nota : isso pressupõe que as ramificações locais e remotas tenham o mesmo nome (e que você deseja rastrear todas as ramificações); deve realmente usar informações sobre quais ramificações locais você possui e o que elas estão configuradas para rastrear.

Esse problema ainda não está resolvido, pelo menos não com facilidade / sem script: veja este post na lista de discussão git de Junio ​​C Hamano explicando a situação e fornecendo uma solução simples.

O principal raciocínio é que você não precisa disso:

Com o git que não é antigo (por exemplo, v1.5.0 ou mais recente), não há razão para ter um "dev" local que rastreie mais o controle remoto. Se você quiser apenas ver e ver, é possível verificar o ramo de rastreamento remoto diretamente em um HEAD desanexado com " git checkout origin/dev".

O que significa que os únicos casos que precisamos tornar conveniente para os usuários são lidar com essas filiais locais que "rastreiam" as remotas quando você tem alterações locais ou quando planeja ter algumas.

Se houver alterações locais em "dev" marcadas para rastrear a remoção "dev" e se você estiver em um ramo diferente de "dev", não faremos nada depois " git fetch" de atualizar o rastreamento remoto "dev" . Não vai avançar de qualquer maneira

A chamada para uma solução era uma opção ou script externo para remover as ramificações locais que seguem agora as ramificações de rastreamento remoto, em vez de mantê-las atualizadas pelo avanço rápido, como o pôster original solicitado.

Então, que tal " git branch --prune --remote=<upstream>" que itera nas filiais locais e se

(1) não é o ramo atual; e
(2) está marcado para rastrear algum ramo retirado do <upstream>; e
(3) não possui nenhum compromisso por si só;

então remover esse ramo? " git remote --prune-local-forks <upstream>" também está bem; Eu não ligo para qual comando implementa tanto esse recurso.

Nota: a partir do git 2.10, essa solução não existe. Observe que ogit remote prunesubcomando, egit fetch --prunetrata da remoção da ramificação de rastreamento remoto da ramificação que não existe mais no controle remoto, não trata da remoção da ramificação local que rastreia a ramificação de rastreamento remoto (para a qual a ramificação de rastreamento remoto é a ramificação upstream).

Há muitas respostas aceitáveis ​​aqui, mas parte do encanamento pode ser um pouco opaca para os não iniciados. Aqui está um exemplo muito mais simples que pode ser facilmente personalizado:

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

Se você adicionar ~/bin/gitao seu PATH(assumindo que o arquivo seja ~/bin/git/git-update-all), basta executar:

$ git update-all

Adicionar este script para .profileno 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};
};

Aqui está uma boa resposta: Como buscar todos os ramos git

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

Um script que escrevi para o meu GitBash . Realiza o seguinte:

• Por padrão, puxa da origem para todas as ramificações configuradas para rastrear a origem, permite especificar um controle remoto diferente, se desejado.
• Se o seu ramo atual estiver em um estado sujo, ele ocultará suas alterações e tentará restaurá-las no final.
• Para cada filial local configurada para rastrear uma filial remota:
  • git checkout branch
  • git pull origin
• Finalmente, você retornará ao seu ramo original e restaurará o estado.

** Eu uso isso, mas não testei completamente, use por sua conta e risco. Veja um exemplo desse script em um arquivo .bash_alias aqui .

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

Se você estiver no Windows, poderá usar o PyGitUp, que é um clone do git-upPython. Você pode instalá-lo usando pip com pip install --user git-upou através do Scoop usandoscoop install git-up

[

Apenas postando uma resposta atualizada. git-upnão é mais mantido e, se você ler a documentação, eles mencionam que a funcionalidade agora está disponível no git .

A partir do Git 2.9, o git pull --rebase --autostash faz basicamente a mesma coisa.

Portanto, se você atualizar para o Git 2.9 ou posterior, poderá usar esse alias em vez de instalar o git-up:

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

Você também pode definir isso para todos os git pullitens do Git 2.9 (obrigado @VonC, veja a resposta aqui )

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

Me deparei com o mesmo problema desta pergunta ...

Pensando nisso, fiz uma pequena função de alias dentro do meu .bashrcarquivo:

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

Trabalhou para mim (:

Se refs / heads / master puder ser encaminhado rapidamente para refs / remotes / foo / master , a saída de

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

deve retornar o ID SHA1 ao qual refs / heads / master aponta. Com isso, é possível montar um script que atualize automaticamente todas as ramificações locais que não tiveram confirmação de desvio aplicada a elas.

Este pequeno script de shell (eu chamei de git-can-ff ) ilustra como isso pode ser feito.

#!/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 concluir a resposta de Matt Connolly, esta é uma maneira mais segura de atualizar as referências da filial local que podem ser encaminhadas rapidamente, sem fazer check-out da filial. Ele não atualiza ramificações que não podem ser encaminhadas rapidamente (ou seja, que divergiram) e não atualiza a ramificação que está com check-out no momento (porque a cópia de trabalho também deve ser atualizada).

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

Um script um pouco diferente que apenas encaminha antecipadamente ramificações cujos nomes correspondem à ramificação upstream. Ele também atualiza a ramificação atual, se for possível avançar rapidamente.

Verifique se todas as ramificações upstream de suas ramificações estão definidas corretamente executando git branch -vv. Defina o ramo upstream comgit branch -u origin/yourbanchname

Copie e cole em um arquivo e 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;

O one-liner a seguir encaminha rapidamente todas as ramificações que possuem uma ramificação upstream, se possível, e imprime um erro caso contrário:

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

Como funciona?

Ele usa um formato personalizado com o git branchcomando Para cada ramificação que possui uma ramificação upstream, ela imprime uma linha com o seguinte padrão:

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

Isso pode ser canalizado diretamente sh(assumindo que os nomes das ramificações estejam bem formados). Omita o | shpara ver o que está fazendo.

Ressalvas

O one-liner não entrará em contato com seus controles remotos. Emita um git fetchou git fetch --allantes de executá-lo.

A filial com check-out atualmente não será atualizada com uma mensagem como

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

Para isso, você pode recorrer a regular git pull --ff-only.

Alias

Adicione o seguinte ao seu .gitconfigpara git fftexecutar este comando:

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

Veja também o meu .gitconfig. O alias é uma abreviação de "fast-forward tracking (branches)".

O script de @larsmans, melhorou um pouco:

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

Depois que termina, deixa a cópia de trabalho com check-out do mesmo ramo que estava antes do nome do script.

A git pullversão:

#!/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 muitos outros contribuíram com soluções semelhantes, mas pensei em compartilhar o que descobri e convidar outras pessoas a contribuir. Esta solução possui uma boa saída colorida, lida com o seu diretório de trabalho atual graciosamente e é rápida porque não faz checkout e deixa seu diretório de trabalho intacto. Além disso, é apenas um script de shell sem outras dependências além do git. (testado apenas no OSX até agora)

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

Desculpe, também parece ter surgido com o mesmo nome da outra ferramenta acima.

Isso pode ser feito usando o script abaixo ... Ele primeiro buscará todos os ramos e fará o checkout um por um e atualizará por si próprio.

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

Você não pode fazer isso com apenas um comando git, mas pode automatizá-lo com uma linha bash.

Para atualizar com segurança todos os ramos com uma linha, eis o que eu faço:

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

• Se não conseguir avançar rapidamente um ramo ou encontrar um erro, ele o interromperá e o deixará nesse ramo, para que você possa retomar o controle e mesclar manualmente.

• Se todas as ramificações puderem avançar rapidamente, ela terminará com a ramificação em que você estava atualmente, deixando-o onde estava antes de atualizar.

Explicações:

Para uma melhor legibilidade, ele pode ser dividido em várias linhas:

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 && ... => Busca todas as referências de todos os controles remotos e continua com o próximo comando, se não houver erro.

2. git branch | sed '/*/{$q;h;d};$G' | tr -d '*'=> Na saída de git branch, sedpegue a linha com a *e mova-a para o final (para que a ramificação atual seja atualizada por último). Em seguida, trbasta remover o *.

3. for branch in $(...) ; do git checkout $branch && git merge --ff-only || break ; done=> Para cada nome de ramificação obtido do comando anterior, faça check-out dessa ramificação e tente mesclar com um avanço rápido. Se falhar, breaké chamado e o comando para aqui.

Claro, você pode substituir git merge --ff-onlypor git rebasese é o que você deseja.

Finalmente, você pode colocá-lo no seu bashrc como um 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'

Ou, se você tem medo de estragar o 'e ​​", ou simplesmente prefere manter a legibilidade sintática no seu editor, pode declarar isso como uma função:

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
}

Bônus:

Para aqueles que gostariam da explicação da sed '/*/{$q;h;d};$G'parte:

• /*/=> Procure a linha com a *.

• {$q => Se estiver na última linha, saia (não precisamos fazer nada porque o ramo atual já é o último na lista).

• ;h;d} => Caso contrário, armazene a linha no buffer de espera e exclua-a na posição atual da lista.

• ;$G => Quando atingir a última linha, acrescente o conteúdo do buffer de retenção.

O "git pull --all" pode atualizar todos os meus ramos locais?

Não, eu não posso. Para o avanço rápido, acabei de escrever uma pequena ferramenta para fazer isso. https://github.com/changyuheng/git-fast-forward-all

Vantagens desta ferramenta:

1. Suporta vários controles remotos em um repositório. ( hub syncnão suporta vários controles remotos no momento.)
2. Suporta nomes diferentes na ramificação local e na ramificação de rastreamento remoto correspondente.
3. Muito mais rápido que outros scripts que buscam remotamente para cada ramo.
4. Sem regex propenso a erros de análise / edição.

A partir do git 2.9:

git pull --rebase --autostash

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

Crie automaticamente um stash temporário antes do início da operação e aplique-o após o término da operação. Isso significa que você pode executar o rebase em uma árvore de trabalho suja. No entanto, use com cuidado: o aplicativo stash final após uma nova recuperação bem-sucedida pode resultar em conflitos não triviais.

De fato, com o git version 1.8.3.1, ele 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

Na ramificação mestre, você pode atualizar todas as outras ramificações. @Cascabel

Eu não sei qual versão quebrar / corrigi-lo, em 2.17 (que eu uso), ele pode funcionar.