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

Eu tenho um mastere um developmentramo, ambos enviados para o GitHub . Eu tenho cloned, pulled, e fetched, mas permanecem incapazes de obter outra coisa senão a mastervolta ramo.

Tenho certeza de que estou perdendo algo óbvio, mas li o manual e não estou tendo nenhuma alegria.

Primeiro, clone um repositório Git remoto e um CD nele:

$ git clone git://example.com/myproject
$ cd myproject

Em seguida, observe as ramificações locais no seu repositório:

$ git branch
* master

Mas existem outros ramos escondidos no seu repositório! Você pode vê-los usando o-a bandeira:

$ git branch -a
* master
  remotes/origin/HEAD
  remotes/origin/master
  remotes/origin/v1.0-stable
  remotes/origin/experimental

Se você quiser apenas dar uma olhada rápida em um ramo upstream, pode verificar diretamente:

$ git checkout origin/experimental

Mas se você quiser trabalhar nesse ramo, precisará criar um ramo de rastreamento local, que é feito automaticamente por:

$ git checkout experimental

e você verá

Branch experimental set up to track remote branch experimental from origin.
Switched to a new branch 'experimental'

Essa última linha lança algumas pessoas: "Novo ramo" - hein? O que realmente significa é que a ramificação é retirada do índice e criada localmente para você. o linha anterior é realmente mais informativa, pois indica que a ramificação está sendo configurada para rastrear a ramificação remota, o que geralmente significa a ramificação origin / branch_name

Agora, se você olhar para suas filiais locais, é isso que você verá:

$ git branch
* experimental
  master

Você pode rastrear mais de um repositório remoto usando git remote .

$ git remote add win32 git://example.com/users/joe/myproject-win32-port
$ git branch -a
* master
  remotes/origin/HEAD
  remotes/origin/master
  remotes/origin/v1.0-stable
  remotes/origin/experimental
  remotes/win32/master
  remotes/win32/new-widgets

Neste ponto, as coisas estão ficando muito loucas, então corra gitkpara ver o que está acontecendo:

$ gitk --all &

Se você tiver muitas ramificações remotas que deseja buscar de uma só vez, faça:

$ git pull --all

Agora você pode fazer o checkout de qualquer ramificação conforme necessário, sem acessar o repositório remoto.

Esse script do Bash me ajudou:

#!/bin/bash
for branch in $(git branch --all | grep '^\s*remotes' | egrep --invert-match '(:?HEAD|master)$'); do
    git branch --track "${branch##*/}" "$branch"
done

Ele criará ramificações de rastreamento para todas as ramificações remotas, exceto o mestre (que você provavelmente obteve do comando clone original). Eu acho que você ainda pode precisar fazer uma

git fetch --all
git pull --all

para ter certeza.

Um exemplo : git branch -a | grep -v HEAD | perl -ne 'chomp($_); s|^\*?\s*||; if (m|(.+)/(.+)| && not $d{$2}) {print qq(git branch --track $2 $1/$2\n)} else {$d{$_}=1}' | csh -xfs
Como sempre: teste sua configuração antes de copiar o universo rm -rf como o conhecemos

Créditos para one-liner vão para o usuário cfi

O uso da --mirroropção parece copiar as remoteramificações de rastreamento corretamente. No entanto, ele configura o repositório como um repositório simples, portanto, você deve transformá-lo novamente em um repositório normal posteriormente.

git clone --mirror path/to/original path/to/dest/.git
cd path/to/dest
git config --bool core.bare false
git checkout anybranch

^{Referência: FAQ do Git: Como clonar um repositório com todos os ramos rastreados remotamente?}

Você pode facilmente mudar para um ramo sem usar a sintaxe "git checkout -b somebranch origin / somebranch". Você pode apenas fazer:

git checkout somebranch

O Git fará automaticamente a coisa certa:

$ git checkout somebranch
Branch somebranch set up to track remote branch somebranch from origin.
Switched to a new branch 'somebranch'

O Git verificará se uma ramificação com o mesmo nome existe em exatamente um controle remoto e, se existir, a rastreará da mesma maneira como se você tivesse especificado explicitamente que é uma ramificação remota. Na página de manual do git-checkout do Git 1.8.2.1:

Se <branch> não for encontrado, mas existir um ramo de rastreamento em exatamente um controle remoto (chame-o <remote>) com um nome correspondente, trate como equivalente a

$ git checkout -b <branch> --track <remote>/<branch>

A respeito de,

$ git checkout -b origem experimental / experimental

usando

$ git checkout -t origin/experimental

ou o mais detalhado, mas mais fácil de lembrar

$ git checkout --track origin/experimental

pode ser melhor em termos de rastreamento de um repositório remoto.

A busca que você está fazendo deve obter todas as ramificações remotas, mas não criará ramificações locais para elas. Se você usa o gitk, verá as ramificações remotas descritas como "remotes / origin / dev" ou algo semelhante.

Para criar uma filial local com base em uma filial remota, faça algo como:

git checkout -b dev refs / remotes / origin / dev

O que deve retornar algo como:

Desenvolvedor de filial configurado para rastrear refs / remotes / origin / dev.
Mudou para um novo ramo "dev"

Agora, quando você estiver no ramo de desenvolvimento, "git pull" atualizará seu desenvolvedor local para o mesmo ponto que o ramo de desenvolvimento remoto. Observe que ele buscará todos os galhos, mas puxe apenas o que você está no topo da árvore.

Quando você faz o "git clone git: // location", todas as ramificações e tags são buscadas.

Para trabalhar em cima de uma ramificação remota específica, supondo que seja a origem remota:

git checkout -b branch origin/branchname

Use aliases. Embora não haja nenhuma linha nativa do Git, você pode definir seu próprio como

git config --global alias.clone-branches '! git branch -a | sed -n "/\/HEAD /d; /\/master$/d; /remotes/p;" | xargs -L1 git checkout -t'

e depois use-o como

git clone-branches

Por que você vê apenas "mestre"

git clonebaixa todas as ramificações remotas, mas ainda as considera "remotas", mesmo que os arquivos estejam localizados no seu novo repositório. Há uma exceção a isso: o processo de clonagem cria uma ramificação local chamada "mestre" a partir da ramificação remota chamada "mestre". Por padrão, git branchmostra apenas ramificações locais, e é por isso que você vê apenas "mestre".

git branch -amostra todas as ramificações, incluindo ramificações remotas .

Como obter filiais locais

Se você realmente deseja trabalhar em uma ramificação, provavelmente desejará uma versão "local" dela. Para simplesmente criar ramificações locais a partir de ramificações remotas (sem retirá-las e, assim, alterar o conteúdo do seu diretório de trabalho) , você pode fazer o seguinte:

git branch branchone origin/branchone
git branch branchtwo origin/branchtwo
git branch branchthree origin/branchthree

Neste exemplo, branchoneé o nome de uma ramificação local na qual você está criando, com base origin/branchone; se você deseja criar ramificações locais com nomes diferentes, pode fazer o seguinte:

git branch localbranchname origin/branchone

Depois de criar uma ramificação local, você poderá vê-la com git branch(lembre-se, você não precisa -aver ramificações locais).

Isso não é muito complicado, as etapas muito simples e diretas são as seguintes;

git fetch origin Isso trará todas as ramificações remotas para o seu local.

git branch -a Isso mostrará todas as ramificações remotas.

git checkout --track origin/<branch you want to checkout>

Verifique se você está na ramificação desejada pelo seguinte comando;

git branch

A saída será assim;

*your current branch 
some branch2
some branch3 

Observe o sinal * que indica a ramificação atual.

Antes tarde do que nunca, mas aqui está a melhor maneira de fazer isso:

mkdir repo
cd repo
git clone --bare path/to/repo.git .git
git config --unset core.bare
git reset --hard

Neste ponto, você tem uma cópia completa do repositório remoto com todas as suas ramificações (verifique com git branch). Você pode usar em --mirrorvez de --barese o seu repo remoto tiver controles remotos próprios.

Apenas faça o seguinte:

$ git clone git://example.com/myproject
$ cd myproject
$ git checkout branchxyz
Branch branchxyz set up to track remote branch branchxyz from origin.
Switched to a new branch 'branchxyz'
$ git pull
Already up-to-date.
$ git branch
* branchxyz
  master
$ git branch -a
* branchxyz
  master
  remotes/origin/HEAD -> origin/master
  remotes/origin/branchxyz
  remotes/origin/branch123

Veja, 'git clone git: //example.com/myprojectt' busca tudo, mesmo os ramos, você só precisa fazer check-out deles, e seu ramo local será criado.

Você só precisa usar o "git clone" para obter todas as ramificações.

git clone <your_http_url>

Mesmo que você veja apenas branch master, você pode usar "git branch -a" para ver todos os branches.

git branch -a

E você pode mudar para qualquer ramo que você já possui.

git checkout <your_branch_name>

Não se preocupe, pois depois de "git clone", você não precisa se conectar ao repositório remoto, "git branch -a" e "git checkout" podem ser executados com êxito quando você fechar o wifi. Portanto, está provado que, quando você faz o "git clone", ele já copiou todos os ramos do repositório remoto. Depois disso, você não precisa do repositório remoto, seu local já possui todos os códigos das agências.

A git clonedeve copiar todo o repositório. Tente cloná-lo e, em seguida, execute git branch -a. Ele deve listar todos os ramos. Se você deseja mudar para a ramificação "foo" em vez de "master", use git checkout foo.

Use minha ferramenta git_remote_branch (você precisa do Ruby instalado na sua máquina). Ele foi desenvolvido especificamente para facilitar as manipulações remotas de ramificações.

Cada vez que realiza uma operação em seu nome, ela é impressa em vermelho no console. Com o tempo, eles finalmente aderem ao seu cérebro :-)

Se você não quiser que o grb execute comandos em seu nome, use o recurso 'explicação'. Os comandos serão impressos no seu console em vez de executados por você.

Por fim, todos os comandos têm aliases, para facilitar a memorização.

Observe que este é um software alfa ;-)

Aqui está a ajuda quando você executa o grb help:

git_remote_branch versão 0.2.6

  Uso:

  grb criar nome_da_ ramificação [origin_server] 

  grb publica branch_name [origin_server] 

  grb renomear branch_name [origin_server] 

  grb excluir nome_da_ filial [origin_server] 

  faixa grb nome_da_ filial [origin_server] 



  Notas:
  - Se origin_server não for especificado, o nome 'origin' será assumido 
    (padrão do git)
  - A funcionalidade de renomeação renomeia a ramificação atual

  O meta-comando de explicação: você também pode anexar qualquer comando com o comando 
palavra-chave 'explicar'. Em vez de executar o comando, git_remote_branch
simplesmente emitirá a lista de comandos que você precisa executar para realizar 
esse objetivo.

  Exemplo: 
    grb explicar criar
    grb explicar criar my_branch github

  Todos os comandos também possuem aliases:
  criar: criar, novo
  delete: excluir, destruir, matar, remover, rm
  publicar: publicar, remotizar
  renomear: renomear, rn, mv, mover
  rastrear: rastrear, seguir, pegar, buscar

todas as respostas que vi aqui são válidas, mas há uma maneira muito mais limpa de clonar um repositório e puxar todos os ramos de uma só vez.

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, quando você deseja clonar um repositório com muitos ramos, todas as formas ilustradas acima são longas e tediosas em relação a uma maneira muito mais limpa e rápida que mostrarei, embora seja um pouco complicado. Você precisa de três etapas para fazer isso:

1. Primeiro passo

crie uma nova pasta vazia em 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.

A clonagem de um repositório local não funcionará com o git clone & git fetch: muitos ramos / tags permanecerão não buscados.

Para obter um clone com todas as ramificações e tags.

git clone --mirror git://example.com/myproject myproject-local-bare-repo.git

Para obter um clone com todas as ramificações e tags, mas também com uma cópia de trabalho:

git clone --mirror git://example.com/myproject myproject/.git
cd myproject
git config --unset core.bare
git config receive.denyCurrentBranch updateInstead
git checkout master

OK, quando você clona seu repositório, você tem todos os ramos lá ...

Se você apenas faz git branch, eles estão meio que escondidos ...

Portanto, se você quiser ver o nome de todos os ramos, basta adicionar uma --allbandeira como esta:

git branch --all ou git branch -a

Se você apenas fizer o checkout da filial, terá tudo o que precisa.

Mas e se o ramo criado por outra pessoa após você clonar?

Nesse caso, basta fazer:

git fetch

e verifique todos os ramos novamente ...

Se você deseja buscar e fazer checkout ao mesmo tempo, pode:

git fetch && git checkout your_branch_name

Também criou a imagem abaixo para você simplificar o que eu disse:

Olhando para uma das respostas à pergunta, notei que é possível reduzi-la:

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

Mas cuidado, se um dos ramos remotos for nomeado como, por exemplo, admin_master, não será baixado!

Graças ao bigfish pela ideia original

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

Esse código puxará todo o código de ramificações remotas para o repositório local.

Para copiar e colar na linha de comando:

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

Para mais legibilidade:

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

1. confira o master (para que possamos excluir o ramo em que estamos)
2. selecione controle remoto para finalizar a compra (altere para qualquer controle remoto que você tenha)
3. percorrer todas as ramificações do controle remoto, exceto master e HEAD
   1. excluir ramificação local (para que possamos verificar ramificações atualizadas à força)
   2. confira ramificação do controle remoto
4. confira mestre (por uma questão de)

Com base na resposta do VonC .

Eu escrevi essas pequenas funções do Powershell para poder verificar todos os meus ramos git, que estão remotos na origem.

Function git-GetAllRemoteBranches {
     iex "git branch -r"                       <# get all remote branches #> `
     | % { $_ -Match "origin\/(?'name'\S+)" }  <# select only names of the branches #> `
     | % { Out-Null; $matches['name'] }        <# write does names #>
}


Function git-CheckoutAllBranches {
    git-GetAllRemoteBranches `
        | % { iex "git checkout $_" }          <# execute ' git checkout <branch>' #>
}

Mais funções git podem ser encontradas no repositório de configurações do git

Aqui está uma resposta que usa awk. Esse método deve ser suficiente se usado em um novo repositório.

git branch -r | awk -F/ '{ system("git checkout " $NF) }'

As ramificações existentes serão simplesmente retiradas ou declaradas como já nela, mas filtros podem ser adicionados para evitar conflitos.

Também pode ser modificado para chamar um git checkout -b <branch> -t <remote>/<branch>comando explícito .

Esta resposta segue Nikos C. 's idéia .

Como alternativa, podemos especificar a ramificação remota. Isto é baseado em murphytalk 's resposta .

git branch -r | awk '{ system("git checkout -t " $NF) }'

Ele lança mensagens de erro fatais em conflitos, mas eu as vejo inofensivas.

Ambos os comandos podem ser alternativos.

Usando a resposta de ninguém como referência, podemos ter os seguintes comandos para criar os aliases:

git config --global alias.clone-branches '! git branch -r | awk -F/ "{ system(\"git checkout \" \$NF) }"'
git config --global alias.clone-branches '! git branch -r | awk "{ system(\"git checkout -t \" \$NF) }"'

Pessoalmente eu usaria track-allou track-all-branches.

Eu precisava fazer exatamente o mesmo. Aqui está o meu script Ruby .

#!/usr/bin/env ruby

local = []
remote = {}

# Prepare
%x[git reset --hard HEAD]
%x[git checkout master] # Makes sure that * is on master.
%x[git branch -a].each_line do |line|
  line.strip!
  if /origin\//.match(line)
     remote[line.gsub(/origin\//, '')] = line
   else
     local << line
   end
end
# Update 
remote.each_pair do |loc, rem|
  next if local.include?(loc)
  %x[git checkout --track -b #{loc} #{rem}]
end
%x[git fetch]

Nenhuma dessas respostas foi suficiente, exceto o usuário que ninguém está no caminho certo.

Eu estava tendo problemas para mover um repositório de um servidor / sistema para outro. Quando eu clonei o repositório, ele criou apenas uma ramificação local para mestre. Por isso, quando fui pressionado para o novo controle remoto, apenas a ramificação principal foi enviada.

Então eu achei esses dois métodos MUITO úteis. Espero que eles ajudem alguém.

Método 1:

git clone --mirror OLD_REPO_URL
cd new-cloned-project
mkdir .git
mv * .git
git config --local --bool core.bare false
git reset --hard HEAD
git remote add newrepo NEW_REPO_URL
git push --all newrepo
git push --tags newrepo

Método 2:

git config --global alias.clone-branches '! git branch -a | sed -n "/\/HEAD /d; /\/master$/d; /remotes/p;" | xargs -L1 git checkout -t'
git clone OLD_REPO_URL
cd new-cloned-project
git clone-branches
git remote add newrepo NEW_REPO_URL
git push --all newrepo
git push --tags newrepo

git clone --mirror no repositório original funciona bem para isso.

git clone --mirror /path/to/original.git
git remote set-url origin /path/to/new-repo.git
git push -u origin

O Git geralmente (quando não especificado) busca todas as ramificações e / ou tags (refs, consulte:) git ls-refsde um ou mais outros repositórios junto com os objetos necessários para completar seus históricos. Em outras palavras, ele busca os objetos que são alcançáveis ​​pelos objetos que já foram baixados. Veja: O que git fetchrealmente faz?

Às vezes, você pode ter ramificações / tags que não estão diretamente conectadas à atual, então git pull --all/ git fetch --allnão ajudará nesse caso, mas você pode listá-las da seguinte forma:

git ls-remote -h -t origin

e buscá-los manualmente, conhecendo os nomes das referências.

Então, para buscar todos eles , tente:

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

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

Em seguida, verifique todas as suas ramificações novamente:

git branch -avv

Se o procedimento acima não ajudar, você precisará adicionar ramificações ausentes manualmente à lista rastreada (pois elas se perderam de alguma forma):

$ git remote -v show origin
...
  Remote branches:
    master      tracked

por git remote set-brancheslike:

git remote set-branches --add origin missing_branch

para que apareça abaixo da remotes/originbusca:

$ git remote -v show origin
...
  Remote branches:
    missing_branch new (next fetch will store in remotes/origin)
$ git fetch
From github.com:Foo/Bar
 * [new branch]      missing_branch -> origin/missing_branch

Solução de problemas

Se você ainda não conseguir nada além da ramificação principal, verifique o seguinte:

• Verifique seus controles remotos ( git remote -v), por exemplo
  • Validar que git config branch.master.remoteé origin.
  • Verifique se originaponta para o URL correto via: git remote show origin(veja esta postagem ).

No início de 2017, a resposta neste comentário funciona:

git fetch <origin-name> <branch-name>derruba o ramo para você. Embora isso não puxe todas as ramificações de uma só vez, você pode executar essa ramificação por singularidade.

Aqui está outro comando curto de uma linha que cria ramificações locais para todas as ramificações remotas:

(git branch -r | sed -n '/->/!s#^  origin/##p' && echo master) | xargs -L1 git checkout

Também funciona corretamente se o rastreamento de ramificações locais já estiver criado. Você pode chamá-lo após o primeirogit clone ou a qualquer momento depois.

Se você não precisar fazer o mastercheck-out da ramificação após a clonagem, use

git branch -r | sed -n '/->/!s#^  origin/##p'| xargs -L1 git checkout