Como buscar todos os ramos Git

Eu clonei um repositório Git, que contém cerca de cinco ramos. No entanto, quando eu git branchvejo apenas um deles:

$ git branch
* master

Sei que posso fazer git branch -apara ver todos os galhos, mas como eu puxaria todos os galhos localmente; assim, quando o faço git branch, mostra o seguinte?

$ git branch
* master
* staging
* etc...

Você pode buscar todas as ramificações de todos os controles remotos como este:

git fetch --all

É basicamente uma jogada de poder .

fetchatualiza cópias locais de filiais remotas para que seja sempre seguro para suas filiais locais, MAS :

1. fetchnão atualizará ramificações locais (que rastreiam ramificações remotas); se você quiser atualizar suas ramificações locais, ainda precisará extrair todas as ramificações.

2. fetchnão criará ramificações locais (que rastreiam ramificações remotas), você deve fazer isso manualmente. Se você deseja listar todas as ramificações remotas: git branch -a

Para atualizar ramificações locais que rastreiam ramificações remotas:

git pull --all

No entanto, isso ainda pode ser insuficiente. Ele funcionará apenas para suas filiais locais que rastreiam filiais remotas. Para rastrear todas as ramificações remotas, execute este oneliner ANTES git pull --all :

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

Versão TL; DR

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

(Parece que o pull busca todos os ramos de todos os controles remotos, mas eu sempre busco primeiro apenas para ter certeza.)

Execute o primeiro comando apenas se houver ramificações remotas no servidor que não sejam rastreadas por suas ramificações locais.

PS AFAIK git fetch --alle git remote updatesão equivalentes.

O comentário de Kamil Szot , que as pessoas acharam úteis.

Eu tive que usar:

for remote in `git branch -r`; do git branch --track ${remote#origin/} $remote; done

porque seu código criou ramificações locais nomeadas origin/branchnamee eu estava recebendo "refname 'origin / branchname' é ambíguo sempre que me referi a ela.

Para listar ramificações remotas:
git branch -r

Você pode vê-los como filiais locais com:
git checkout -b LocalName origin/remotebranchname

Você precisará criar filiais locais que rastreiam filiais remotas.

Supondo que você tenha apenas um controle remoto chamado origin, esse snippet criará ramificações locais para todas as de rastreamento remoto:

for b in `git branch -r | grep -v -- '->'`; do git branch --track ${b##origin/} $b; done

Depois disso, git fetch --allatualizará todas as cópias locais das ramificações remotas.

Além disso, git pull --allatualizará suas ramificações de rastreamento local, mas, dependendo das confirmações locais e de como a opção de configuração 'mesclar' estiver definida, isso poderá criar uma confirmação de mesclagem, avanço rápido ou falha.

Se você fizer:

git fetch origin

então eles estarão todos lá localmente. Se você executar:

git branch -a

você os verá listados como controles remotos / origem / nome da filial. Uma vez que eles estão lá localmente, você pode fazer o que quiser com eles. Por exemplo:

git diff origin/branch-name 

ou

git merge origin/branch-name

ou

git checkout -b some-branch origin/branch-name

$ git remote update
$ git pull --all

Isso pressupõe que todas as ramificações são rastreadas.

Se não estiverem, você pode disparar isso no Bash:

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

Em seguida, execute o comando

O forloop Bash não estava funcionando para mim, mas isso fez exatamente o que eu queria. Todos os ramos da minha origem espelhavam o mesmo nome localmente.

git checkout --detach
git fetch origin '+refs/heads/*:refs/heads/*'

Veja o comentário de Mike DuPont abaixo. Acho que estava tentando fazer isso em um servidor Jenkins, que o deixa no modo de cabeça desanexada.

Use git fetch && git checkout RemoteBranchName.

Funciona muito bem para mim...

Quando você clona um repositório, todas as informações dos ramos são realmente baixadas, mas os ramos ficam ocultos. Com o comando

$ git branch -a

você pode mostrar todas as ramificações do repositório e com o comando

$ git checkout -b branchname origin/branchname

você pode "baixá-los" manualmente, um de cada vez.

No entanto, existe uma maneira muito mais limpa e rápida, embora seja um pouco complicado. Você precisa de três etapas para fazer isso:

1. Primeiro passo

   crie uma nova pasta vazia na sua máquina e clone uma cópia espelhada da pasta .git do repositório:

   $ cd ~/Desktop && mkdir my_repo_folder && cd my_repo_folder
   $ git clone --mirror https://github.com/planetoftheweb/responsivebootstrap.git .git
   

   o repositório local dentro da pasta my_repo_folder ainda está vazio, existe apenas uma pasta .git oculta agora que você pode ver com um comando "ls -alt" no terminal.

2. Segundo passo

   alterne este repositório de um repositório vazio (vazio) para um repositório regular alternando o valor booleano "bare" das configurações do git para false:

   $ git config --bool core.bare false
   

3. Terceiro passo

   Pegue tudo o que está dentro da pasta atual e crie todas as ramificações na máquina local, tornando isso um repositório normal.

   $ git reset --hard
   

Então agora você pode apenas digitar o comando git branch e pode ver que todos os ramos foram baixados.

Essa é a maneira rápida em que você pode clonar um repositório git com todos os ramos de uma só vez, mas não é algo que você deseja fazer para cada projeto dessa maneira.

Você pode buscar todos os ramos por:

git fetch --all

ou:

git fetch origin --depth=10000 $(git ls-remote -h -t origin)

^{O --depth=10000parâmetro pode ajudar se você tiver um repositório raso.}

Para puxar todos os galhos, use:

git pull --all

Se o acima não funcionar, preceda o comando acima com:

git config remote.origin.fetch '+refs/heads/*:refs/remotes/origin/*'

pois ele remote.origin.fetchpode suportar apenas um ramo específico durante a busca, especialmente quando você clonou seu repositório --single-branch. Verifique isso: git config remote.origin.fetch.

Depois disso, você poderá fazer checkout de qualquer agência.

Veja também:

• Como buscar todas as ramificações remotas?
• Como clonar todas as ramificações remotas no Git?

Para enviar todas as ramificações para o controle remoto, use:

git push --all

eventualmente --mirrorpara espelhar todos os árbitros.

Se seu objetivo é duplicar um repositório, consulte: Duplicando um artigo de repositório no GitHub.

Eu costumo usar nada além de comandos como este:

git fetch origin
git checkout --track origin/remote-branch

Uma versão um pouco mais curta:

git fetch origin
git checkout -t origin/remote-branch

Acredito que você clonou o repositório por:

git clone https://github.com/pathOfrepository

Agora vá para essa pasta usando o cd:

cd pathOfrepository

Se você digitar, git statuspoderá ver tudo:

   On branch master
Your branch is up-to-date with 'origin/master'.
nothing to commit, working directory clean

Para ver todos os tipos de ramificação ocultos:

 git branch -a

Ele listará todas as ramificações remotas.

Agora, se você quiser fazer o checkout em qualquer filial em particular, digite:

git checkout -b localBranchName origin/RemteBranchName

Se você está aqui procurando uma solução para obter todas as filiais e depois migrar tudo para outro servidor Git, montei o processo abaixo. Se você deseja atualizar todos os ramos localmente, pare na primeira linha vazia.

git clone <ORIGINAL_ORIGIN>
git branch -r | awk -F'origin/' '!/HEAD|master/{print $2 " " $1"origin/"$2}' | xargs -L 1 git branch -f --track 
git fetch --all --prune --tags
git pull --all

git remote set-url origin <NEW_ORIGIN>
git pull
<resolve_any_merge_conflicts>
git push --all
git push --tags
<check_NEW_ORIGIN_to_ensure_it_matches_ORIGINAL_ORIGIN>

Depois de clonar o repositório principal, você pode executar

git fetch && git checkout <branchname>

Verifique se todas as ramificações remotas são buscáveis .git/config arquivo.

Neste exemplo, apenas a origin/productionramificação é buscável, mesmo se você tentar fazer git fetch --allnada acontecerá, além de buscar a productionramificação:

[origin]
fetch = +refs/heads/production:refs/remotes/origin/production

Esta linha deve ser substituída por:

[origin]
fetch = +refs/heads/*:refs/remotes/origin/*

Então execute git fetchetc ...

Looping não parecia funcionar para mim e eu queria ignorar a origem / mestre. Aqui está o que funcionou para mim.

git branch -r | grep -v HEAD | awk -F'/' '{print $2 " " $1"/"$2}' | xargs -L 1 git branch -f --track

Depois disso:

git fetch --all
git pull --all

Apenas estes três comandos obterão todos os ramos:

git clone --mirror repo.git  .git     (gets just .git  - bare repository)

git config --bool core.bare false

git reset --hard

Por que ninguém responde à pergunta dos caras e explica o que está acontecendo?

1. Verifique se você está acompanhando todas as ramificações remotas (ou as que você deseja rastrear) .
2. Atualize suas ramificações locais para refletir as ramificações remotas.

Acompanhe todas as ramificações remotas:

Rastreie todas as ramificações existentes no repositório remoto.

Faça manualmente:

Você substituiria <branch>por uma ramificação exibida na saída de git branch -r.

git branch -r
git branch --track <branch>

Faça isso com um script bash

for i in $(git branch -r | grep -vE "HEAD|master"); do git branch --track ${i#*/} $i; done

Atualize as informações sobre as ramificações remotas no seu computador local:

Isso busca atualizações nas ramificações do repositório remoto que você está rastreando no repositório local. Isso não altera suas filiais locais. Seu repositório git local agora está ciente das coisas que aconteceram nas ramificações remotas. Um exemplo seria que uma nova confirmação foi enviada ao mestre remoto, ao fazer uma busca agora o alertará de que seu mestre local está atrasado em 1 confirmação.

git fetch --all

Atualize as informações sobre as ramificações remotas no computador local e atualize as ramificações locais:

Faz uma busca seguida por uma mesclagem para todas as ramificações do controle remoto para a ramificação local. Um exemplo seria que uma nova confirmação foi enviada ao mestre remoto, fazendo uma solicitação atualizará seu repositório local sobre as alterações na ramificação remota e, em seguida, mesclará essas alterações na ramificação local. Isso pode criar uma bagunça devido a conflitos de mesclagem.

git pull --all

Escrevi um pequeno script para gerenciar a clonagem de um novo repositório e criar ramificações locais para todas as ramificações remotas.

Você pode encontrar a versão mais recente aqui :

#!/bin/bash

# Clones as usual but creates local tracking branches for all remote branches.
# To use, copy this file into the same directory your git binaries are (git, git-flow, git-subtree, etc)

clone_output=$((git clone "$@" ) 2>&1)
retval=$?
echo $clone_output
if [[ $retval != 0 ]] ; then
    exit 1
fi
pushd $(echo $clone_output | head -1 | sed 's/Cloning into .\(.*\).\.\.\./\1/') > /dev/null 2>&1
this_branch=$(git branch | sed 's/^..//')
for i in $(git branch -r | grep -v HEAD); do
  branch=$(echo $i | perl -pe 's/^.*?\///')
  # this doesn't have to be done for each branch, but that's how I did it.
  remote=$(echo $i | sed 's/\/.*//')
  if [[ "$this_branch" != "$branch" ]]; then
      git branch -t $branch $remote/$branch
  fi
done
popd > /dev/null 2>&1

Para usá-lo, basta copiá-lo para o diretório git bin (para mim C:\Program Files (x86)\Git\bin\git-cloneall) e, em seguida, na linha de comando:

git cloneall [standard-clone-options] <url>

Ele clona como de costume, mas cria ramificações de rastreamento local para todas as ramificações remotas.

Como buscar todas as ramificações do Git que seguem o controle remoto único.

Isso foi testado e funciona no Red Hat e no Git Bash no Windows 10.

TLDR:

for branch in `git branch -r|grep -v ' -> '|cut -d"/" -f2`; do git checkout $branch; git fetch; done;

Explicação:

O liner único faz check-out e busca todos os ramos, exceto HEAD.

Listar as ramificações de rastreamento remoto.

git branch -r

Ignore HEAD.

grep -v ' -> '

Retire o nome da filial do (s) controle (s) remoto (s).

cut -d"/" -f2

Faça o check-out de todas as filiais que acompanham um único controle remoto.

git checkout $branch

Buscar ramificação com check-out.

git fetch

Tecnicamente, a busca não é necessária para novas ramificações locais.

Isto pode ser utilizado para qualquer fetchoupull ramos que são novos e têm mudanças em remotas (s).

Apenas certifique-se de puxar apenas se estiver pronto para mesclar.

Configuração de teste

Confira um repositório com URL SSH.

git clone [email protected]

Antes

Verifique as agências no local.

$ git branch
* master

Executar comandos

Execute o liner único.

for branch in `git branch -r|grep -v ' -> '|cut -d"/" -f2`; do git checkout $branch; git fetch; done;

Depois de

Verifique se as ramificações locais incluem ramificações remotas.

$ git branch
  cicd
  master
* preprod

Para usuários do Windows que usam o PowerShell:

git branch -r | ForEach-Object {
    # Skip default branch, this script assumes
    # you already checked-out that branch when cloned the repo
    if (-not ($_ -match " -> ")) {
        $localBranch = ($_ -replace "^.*?/", "")
        $remoteBranch = $_.Trim()
        git branch --track "$localBranch" "$remoteBranch"
    }
}
git fetch --all
git pull --all

Aqui está algo que eu consideraria robusto:

• Não atualiza o rastreamento remoto para filiais existentes
• Não tenta atualizar HEAD para acompanharorigin/HEAD
• Permite controles remotos nomeados que não sejam origin
• Shell corretamente citado

for b in $(git branch -r --format='%(refname:short)'); do
  [[ "${b#*/}" = HEAD ]] && continue
  git show-ref -q --heads "${b#*/}" || git branch --track "${b#*/}" "$b";
done
git pull --all

Não é necessário, git fetch --allcomo passar -allpara git pullpassar essa opção para o interno fetch.

Crédito para esta resposta .

Aqui está uma versão Perl do one-liner fornecida na resposta aceita:

git branch -r | perl -e 'while(<>) {chop; my $remote = $_; my ($local) = ($remote =~ /origin\/(.*)/); print "git branch --track $local $remote\n";}' > some-output-file

Você pode executar o arquivo de saída como um script do Shell, se desejar.

Excluímos nosso repositório de projetos Stash por acidente. Felizmente, alguém havia criado um garfo antes da perda acidental. Eu clonei o garfo no meu local (omitir os detalhes de como eu fiz isso). Depois de colocar o garfo totalmente no meu local, executei uma linha. Modifiquei a URL do controle remoto (origem no meu caso) para apontar para o repositório de destino para o qual estávamos recuperando:

git remote set-url origin <remote-url>

E finalmente empurrou todos os ramos para a origem da seguinte maneira:

git push --all origin

e estávamos de volta aos negócios.

Podemos colocar todos os nomes de ramificações ou tags em um arquivo temporário e, em seguida, git pull para cada nome / tag:

git branch -r | grep origin | grep -v HEAD| awk -F/ '{print $NF}' > /tmp/all.txt
git tag -l >> /tmp/all.txt
for tag_or_branch in `cat /tmp/all.txt`; do git checkout $tag_or_branch; git pull origin $tag_or_branch; done

Se você tiver problemas fetch --all, acompanhe sua ramificação remota:

git checkout --track origin/%branchname%

Para evitar a mensagem de erro 'fatal: já existe uma ramificação chamada' origin / master '.', É necessário:

git branch -r | grep -v '\->'  | grep -v `git branch | awk '/\*/ { print $2; }'`| while read remote; do git branch --track "${remote#origin/}" "$remote"; done

Com base na resposta de Learath2, aqui está o que eu fiz depois de fazer git clone [...]e cdinserir o diretório criado:

git branch -r | grep -v master | awk {print\$1} | sed 's/^origin\/\(.*\)$/\1 &/' | xargs -n2 git checkout -b

Trabalhou para mim, mas não sei se funcionará para você. Seja cuidadoso.

git remote add origin https://yourBitbucketLink

git fetch origin

git checkout -b yourNewLocalBranchName origin/requiredRemoteBranch (use tab :D)

Agora localmente, você yourNewLocalBranchNameé seu requiredRemoteBranch.

Para usuários do Visual Studio, no console do Gerenciador de Pacotes:

ramo git | % {git buscar a montante; git mesclar upstream / master}

Já tentei de várias maneiras, apenas esta é simples e funciona para mim.

for branch in $(git ls-remote -h git@<your_repository>.git | awk '{print $2}' | sed 's:refs/heads/::')
do
  git checkout "$branch"
  git pull
done

Definir alias: (com base na resposta superior)

git config --global alias.track-all-branches '!git fetch --all && for remote in `git branch -r`; do git branch --track ${remote#origin/} $remote; done && git fetch --all'

Agora, para acompanhar todos os ramos:

git track-all-branches