Rastrear todas as ramificações remotas do git como ramificações locais

O rastreamento de uma única filial remota como uma filial local é bastante direto.

$ git checkout --track -b ${branch_name} origin/${branch_name}

Empurrar todas as ramificações locais para o controle remoto, criando novas ramificações remotas conforme necessário também é fácil.

$ git push --all origin

Eu quero fazer o contrário. Se eu tiver um número X de ramificações remotas em uma única fonte:

$ git branch -r 
branch1
branch2
branch3
.
.
.

Posso criar ramificações de rastreamento local para todas essas ramificações remotas sem a necessidade de criar manualmente cada uma? Diga algo como:

$ git checkout --track -b --all origin

Eu pesquisei no Google e os RTMs, mas acabei ficando um bocado até agora.

Usando o bash:

for i in `git branch -a | grep remote | grep -v HEAD | grep -v master`; do git branch --track ${i#remotes/origin/} $i; done

créditos: Val Blant, elias e Hugo

Nota: o código a seguir, se usado em versões posteriores do git (> v1.9.1), causa

1. (bug) Todos os ramos criados para rastrear o mestre
2. (aborrecimento) Todos os nomes de agências locais criados a serem prefixados com origin/

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

Atualize as ramificações, supondo que não haja alterações em suas ramificações de rastreamento local:

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

Ignore os avisos ambíguos de refname, o git parece preferir o ramo local como deveria.

A resposta dada por Otto é boa, mas todos os ramos criados terão "origem /" como o início do nome. Se você deseja apenas que a última parte (após o último /) seja o seu nome de filial resultante, use este:

for remote in `git branch -r | grep -v /HEAD`; do git checkout --track $remote ; done

Ele também tem o benefício de não fornecer avisos sobre referências ambíguas.

A maioria das respostas aqui está complicando a análise da saída de git branch -r. Você pode usar o seguinte forloop para criar as ramificações de rastreamento em todas as ramificações no controle remoto dessa maneira.

Exemplo

Digamos que eu tenho esses ramos remotos.

$ git branch -r
  origin/HEAD -> origin/master
  origin/development
  origin/integration
  origin/master
  origin/production
  origin/staging

Confirme se não estamos rastreando nada além de mestre, localmente:

$ git branch -l    # or using just git branch
* master

Você pode usar esse liner para criar as ramificações de rastreamento:

$ for i in $(git branch -r | grep -vE "HEAD|master"); do 
    git branch --track ${i#*/} $i; done
Branch development set up to track remote branch development from origin.
Branch integration set up to track remote branch integration from origin.
Branch production set up to track remote branch production from origin.
Branch staging set up to track remote branch staging from origin.

Agora confirme:

$ git branch
  development
  integration
* master
  production
  staging

Para excluí-los:

$ git br -D production development integration staging 
Deleted branch production (was xxxxx).
Deleted branch development (was xxxxx).
Deleted branch integration (was xxxxx).
Deleted branch staging (was xxxxx).

Se você usar a -vvopção, git branchpoderá confirmar:

$ git br -vv
  development xxxxx [origin/development] commit log msg ....
  integration xxxxx [origin/integration] commit log msg ....
* master      xxxxx [origin/master] commit log msg ....
  production  xxxxx [origin/production] commit log msg ....
  staging     xxxxx [origin/staging] commit log msg ....

Repartição do loop for

O loop basicamente chama o comando git branch -r, filtrando qualquer ramo HEAD ou mestre na saída usando grep -vE "HEAD|master". Para obter os nomes apenas dos ramos menos a origin/substring, usamos a manipulação de strings do Bash ${var#stringtoremove}. Isto irá remover a seqüência, "stringtoremove" da variável $var. No nosso caso, estamos removendo a string origin/da variável $i.

NOTA: Como alternativa, você também pode git checkout --track ...fazer isso:

$ for i in $(git branch -r | grep -vE "HEAD|master" | sed 's/^[ ]\+//'); do 
    git checkout --track $i; done

Mas eu particularmente não me importo com esse método, pois ele é alternado entre os ramos enquanto ele faz um checkout. Quando terminar, deixará você no último ramo que ele criou.

Referências

• 10.1 Manipulando seqüências de caracteres - Guia de script avançado Bash
• 3.5 Ramificação Git - Ramificações remotas

Atualização Q1 2020: Mohsen Abasi propõe nos comentários , com base em 2014 SLM 's resposta , a alternativa mais simples:

for i in $(git branch -r | grep -vE "HEAD|master" | sed 's/^[ ]\+//'); 

E usa em $()vez de reticulares obsoletos .

Como mencionei em outra resposta antiga , o uso git for-each-refé provavelmente mais rápido .
E eu usaria o novo git switchcomando (Git 2.23+) , que substitui o confusogit checkout .

for i in $(git for-each-ref --format=%(refname:short) \
  --no-merged=origin/HEAD refs/remotes/origin); do \
    git switch --track $i; \
done

Dessa forma, não é grepnecessário.

Old (2011) resposta original:

Aqui está o meu one-liner que eu uso (em um shell bash, testado com o msysgit1.7.4):

Para copiar e colar:

remote=origin ; for brname in `git branch -r | grep $remote | grep -v master | grep -v HEAD | awk '{gsub(/^[^\/]+\//,"",$1); print $1}'`; do git branch --set-upstream-to $remote/$brname $brname; done

Para mais legibilidade:

remote=origin ; // put here the name of the remote you want
for brname in `
    git branch -r | grep $remote | grep -v master | grep -v HEAD 
    | awk '{gsub(/^[^\/]+\//,"",$1); print $1}'
`; do 
    git branch --set-upstream-to $remote/$brname $brname; 
done

• ele selecionará apenas ramificações upstream do controle remoto especificado na remotevariável (pode ser ' origin' ou qualquer nome que você tenha definido para um dos controles remotos do seu repositório atual do Git).
• extrairá o nome do ramo: origin/a/Branch/Name => a/Branch/Nameatravés da awkexpressão

• ele definirá a ramificação upstream através de --set-upstream-to(ou -u) , não --track:
  A vantagem é que, se a ramificação já existir, ela não falhará e não mudará a origem da ramificação, apenas definirá a branch.xxx.(remote|merge)configuração.

  branch.aBranchName.remote=origin
  branch.aBranchName.merge=refs/heads/a/Branch/Name
  

Esse comando criará ramificações locais para todas as ramificações remotas do upstream e definirá suas configurações remota e de mesclagem para essa ramificação remota.

Você poderia escrever com bastante facilidade, mas não sei quando seria valioso. Esses ramos ficariam para trás rapidamente e você teria que atualizá-los o tempo todo.

As ramificações remotas serão automaticamente atualizadas, portanto, é mais fácil criar a ramificação local no ponto em que você realmente deseja trabalhar nela.

for i in `git branch -a | grep remote`; do git branch --track ${i#remotes/origin/} $i; done

sem nenhum script (em um diretório vazio):

$ git clone --bare repo_url .git
$ git config core.bare false
$ git checkout

depois disso, todas as ramificações remotas serão vistas como locais.

original (em russo) .

Se você deseja usar o PowerShell e seu controle remoto é chamado de origem. Então isso funciona.

git fetch    
git branch -r  | %{$_ -replace "  origin/"} | %{git branch --track $_ "origin/$_"}

for branch in `git branch -a | grep remotes | grep -v HEAD | grep -v master`; do  git branch --track ${branch##*/} $branch; done

Use isso e você não terá um aviso como: refname 'origin / dev' é ambíguo

Aqui está minha solução do comando BASH referente a @tjmcewan:

for remote in `git branch -r | grep -v /HEAD `; do git branch --track ${remote/"origin/"/""}; done

Meu objetivo é resolver o problema de que todas as ramificações criadas terão "origem /" como o início do nome, porque testei que $ variáveis ​​remotas ainda incluem "origem /":

for remote in `git branch -r | grep -v /HEAD`; do echo $remote ; done

Para fazer o mesmo que a resposta de tjmcewan, mas no Windows, chame isso de um arquivo em lotes :

for /f "delims=" %%r in ('git branch -r ^| grep -v master') do git checkout --track %%r

Ou isso na linha de comando :

for /f "delims=" %r in ('git branch -r ^| grep -v master') do git checkout --track %r

Do git 2.23 em diante:

for branch in `git branch -r | grep origin/`; do git switch -t -C ${branch#origin/} $branch; git pull; done

O -Csinalizador para git switchcria ou redefine se ele já existe.

documentação do switch git

Caso você já tenha algumas filiais registradas e queira

• confira todas as ramificações restantes do controle remoto
• verifique se todas as filiais locais rastreiam as filiais remotas

você pode usar o seguinte script compatível com bash e zsh:

git branch -r | while read b; do if git branch | grep -q " ${b##*/}$"; then git branch --set-upstream ${b##*/} $b; else git branch --track ${b##*/} $b; fi; done

for rembranch in `git remote update 2>&1 > /dev/null ; git branch -r|egrep -wv "HEAD|master"`
do 
    git checkout --track -b `echo $rembranch|awk -F\/ '{print $2}'` $rembranch; 
done

Explicação:

linha 1: 'git branch -r' (seguido por 'git remote update' para atualizar as informações sobre alterações no remote) lista todas as ramificações remotas; 'egrep -vw' é usado para bater entradas com HEAD e mestre no resultado.

linha 3: acompanhe a ramificação remota nomeada enquanto a verifica localmente. Um awk simples é usado para evitar 'origin /' sendo o sufixo para ramificações locais.

Usando o bash, se você quiser fazer check-out de todos os ramos:

for remote in `git branch -r`; do git checkout $(echo $remote | cut -d'/' -f 2); done

É importante observar que, quando você faz uma busca que desativa novas ramificações de rastreamento remoto, não possui automaticamente cópias editáveis ​​locais.