it-swarm-pt.tech

Como clonar todos os ramos remotos no Git?

Eu tenho uma ramificação master e development, ambas enviadas para GitHub . Eu cloned, pulled e fetched, mas continuo sem conseguir obter nada além da ramificação master.

Tenho certeza de que estou sentindo falta de algo óbvio, mas li o manual e não estou nem um pouco satisfeito.

3746
Peter Coulton

Primeiro, clone um remoto Git repository e cd nele:

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

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

$ git branch
* master

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

$ 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 branch upstream, você pode conferir diretamente:

$ git checkout Origin/experimental

Mas se você quiser trabalhar nesse ramo, precisará criar um ramo de rastreamento local que seja 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: "Nova ramificação" - hein? O que isso realmente significa é que a ramificação é retirada do índice e criada localmente para você. A linha previous é realmente mais informativa, já que informa que a ramificação está sendo configurada para rastrear a ramificação remota, o que geralmente significa a ramificação Origem/branch_name 

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

$ git branch
* experimental
  master

Você pode realmente 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 gitk para ver o que está acontecendo:

$ gitk --all &
4191
emk

Se você tem muitos ramos remotos que deseja buscar de uma só vez, faça:

$ git pull --all

Agora você pode fazer o checkout de qualquer filial, sem precisar acessar o repositório remoto.

763
Gabe Kopley

Este Bash script 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 master (que você provavelmente obteve do comando clone original). Eu acho que você ainda precisa fazer um 

git fetch --all
git pull --all

para ter certeza.

One liner: 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 de costume: teste na sua configuração antes de copiar rm -rf universe como a conhecemos 

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

388
bigfish

Usar a opção --mirror parece copiar os ramos de rastreamento remote apropriadamente. No entanto, ele configura o repositório como um repositório vazio, então você tem que transformá-lo novamente em um repositório normal depois.

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: Git FAQ: Como faço para clonar um repositório com todas as ramificações rastreadas remotamente?

300
Dave

Você pode facilmente mudar para um branch sem usar a sintaxe fantasia "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 irá verificar se existe uma ramificação com o mesmo nome em exatamente um controle remoto, e se isso acontecer, ele o rastreará da mesma maneira como se você tivesse especificado explicitamente que é uma ramificação remota. Na página man do git-checkout do Git 1.8.2.1:

Se <ramificação> não for encontrado, mas existir um ramo de rastreamento em Exatamente um controle remoto (chame-o <remoto>) com um nome correspondente, trate como Equivalente a

$ git checkout -b <branch> --track <remote>/<branch>
208
Nikos C.

A respeito de,

$ git checkout -b experimental Origem/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. 

90
murphytalk

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

Para criar uma ramificação local com base em uma ramificação remota, faça algo como:

git checkout -b dev refs/remotos/Origem/dev

Qual deve retornar algo como:

Branch dev configurado para rastrear refs remotos/remotos/Origin/dev. 
 Comutado para uma nova ramificação "dev"

Agora, quando você está na ramificação dev, "git pull" atualizará seu dev local para o mesmo ponto que a ramificação dev remota. Note que ele irá buscar todos os ramos, mas apenas puxe aquele no qual você está para o topo da árvore.

78
Luuk Paulussen

Quando você faz "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 o controle remoto Origin:

git checkout -b branch Origin/branchname
57
elmarco

Use aliases. Embora não haja nenhum one-liners nativo do Git, você pode definir o 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 usá-lo como

git clone-branches
49
nobody

Isso não é muito complicado, passos muito simples e diretos são os seguintes;

git fetch Origin Isso trará todos os ramos remotos para o seu local.

git branch -a Isso mostrará todos os ramos remotos.

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

Verifique se você está no ramo desejado pelo seguinte comando;

git branch

A saída vai gostar disso;

*your current branch 
some branch2
some branch3 

Observe o sinal * que indica o ramo atual.

44
Sam

Por que você só vê "mestre"

git clone baixa todas as ramificações remotas remotas, mas ainda as considera "remotas", embora os arquivos estejam localizados em seu novo repositório. Há uma exceção a isso, que é que o processo de clonagem cria uma ramificação local chamada "master" da ramificação remota chamada "master". Por padrão, git branch mostra apenas ramificações locais, e é por isso que você só vê "mestre".

git branch -a mostra todas as ramificações, incluindo filiais remotas .


Como obter filiais locais

Se você realmente quiser trabalhar em um ramo, provavelmente vai querer uma versão "local" dele. Para simplesmente criar ramificações locais a partir de filiais remotas (sem verificá-las e assim alterar o conteúdo do seu diretório de trabalho) , você pode fazer isso assim:

git branch branchone Origin/branchone
git branch branchtwo Origin/branchtwo
git branch branchthree Origin/branchthree

Neste exemplo, branchone é o nome de um branch local que você está criando com base em Origin/branchone; Se você quiser criar ramificações locais com nomes diferentes, você pode fazer isso:

git branch localbranchname Origin/branchone

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

43
Cerran

Melhor 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 --mirror em vez de --bare se seu repo remoto tiver remotas próprias.

42
Jacob Fike

Apenas faça isso:

$ 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

Você vê, 'git clone git: //example.com/myprojectt' busca tudo, até mesmo as ramificações, você só precisa fazer o checkout delas, então sua filial local será criada.

38
rapher

Você só precisa usar o "git clone" para obter todos os branches.

git clone <your_http_url>

Mesmo que você veja apenas o 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á tem.

git checkout <your_branch_name>

Não se preocupe que depois de "git clone", você não precisa se conectar com o repositório remoto, "git branch -a" e "git checkout" pode ser executado com sucesso quando você fechar o seu wifi. Então, é provado que quando você faz "git clone", ele já copiou todas as ramificações do repositório remoto. Depois disso, você não precisa do repo remoto, o seu local já tem todos os códigos das agências. 

23
Haimei

Um git clone deve copiar todo o repositório. Tente cloná-lo e, em seguida, execute git branch -a. Deve listar todos os ramos. Se, então, você quiser alternar para a ramificação "foo" em vez de "master", use git checkout foo.

22
MattoxBeckman

Use minha ferramenta git_remote_branch (você precisa do Ruby instalado na sua máquina). Ele é construído especificamente para tornar as manipulações de ramificações remotas fáceis.

Cada vez que faz uma operação em seu nome, imprime em vermelho no console. Com o tempo, eles finalmente ficam no seu cérebro :-)

Se você não quer que a grb execute comandos em seu nome, apenas use o recurso 'explain'. Os comandos serão impressos no seu console ao invés de serem executados para você.

Finalmente, todos os comandos possuem aliases para facilitar a memorização.

Note que este é o software alpha ;-)

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

 git_remote_branch versão 0.2.6 
 
 Uso: 
 
 grb criar nome_do_agrupamento [servidor_em_empresa] 
 
 grb publish branch_name [Origin_server] 
 
 grb renomear branch_name [Origin_server] 
 
 grb deletar branch_name [Origin_server] 
 
 grb seguir branch_name [ Origin_server] 
 
 
 
 Notas: 
 - Se o Origin_server não for especificado, o nome 'Origem' é assumido 
 (Git's default) 
 - A funcionalidade renomear renomeia a ramificação atual 
 
 O meta-comando explain: você também pode prefixar qualquer comando com a palavra-chave 
 'explain'. Em vez de executar o comando, git_remote_branch 
 Simplesmente exibirá a lista de comandos que você precisa executar para realizar 
 Essa meta. 
 
 Exemplo: 
 grb explicar criar 
 grb explain criar my_branch github 
 
 Todos os comandos também têm aliases: 
 create: create, new 
 delete: excluir, destruir, kill, remove, rm 
 publicar: publicar, remotalizar 
 renomear: renomear, rn, mv, mover 
 faixa: seguir, seguir, pegar, buscar 
19
webmat

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 das ramificações são realmente baixadas, mas as ramificações ficam ocultas. Com o comando

$ git branch -a

você pode mostrar todos os ramos 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 vários branches, todas as formas ilustradas acima são demoradas e tediosas em relação a uma maneira muito mais clara e rápida que mostrarei, embora seja um pouco complicado. Você precisa de três etapas para realizar 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, há apenas uma pasta .git oculta agora que você pode ver com um comando "ls -alt" do terminal.

  1. Segundo passo

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

$ git config --bool core.bare false
  1. Terceiro passo

Agarre tudo o que estiver 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 simplesmente digitar o comando "git branch" e você pode ver que todos os branches foram baixados. 

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

15
FedericoCapaldo

Olhando para uma das respostas à pergunta, percebi que é possível encurtá-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 tiver o nome de, e. admin_master não será baixado!

Graças ao bigfish pela ideia original

12
Tebe

OK, quando você clona seu repo, você tem todas as filiais lá ...

Se você acabou de fazer git branch, eles estão escondidos ...

Então, se você quiser ver o nome de todos os ramos, basta adicionar o sinalizador --all desta forma:

git branch --all ou git branch -a

Se você acabou de fazer o checkout no branch, você terá tudo o que precisa.

Mas e se o ramo criado por outra pessoa depois de você clonar?

Neste caso, apenas faça:

git fetch

e verifique todos os ramos novamente ...

Se você gosta de buscar e fazer o checkout ao mesmo tempo, você pode fazer:

git fetch && git checkout your_branch_name

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

git branch --all to get all branches

12
Alireza

A clonagem de um repositório local não funcionará com o git clone & git fetch: muitas ramificações/tags permanecerão sem rastreio.

Para obter um clone com todos os ramos 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
11
raisercostin
#!/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 irá puxar todos os códigos de ramificações remotas para o repositório local.

11
Albert.Qing

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 readability:

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


Isso vai:

  1. confira mestre (para que possamos excluir o ramo em que estamos)
  2. selecione o controle remoto para fazer o checkout (mude para qualquer controle remoto que você tenha)
  3. loop através de todas as ramificações do controle remoto, exceto master e HEAD
    1. delete ramificação local (para que possamos verificar as ramificações atualizadas de força)
    2. check out ramificação do controle remoto
  4. confira master (por causa disso)

Baseado em answer of VonC .

10
ikaruss

Eu escrevi estas pequenas funções Powershell para poder fazer o checkout de todas as minhas ramificações git, que estão no Origin remote.

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 em my reit settings repo

8
gringo_dave

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

#!/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]
8
user43685

Git geralmente (quando não especificado) busca todas as ramificações e/ou tags (refs, veja: git ls-refs) de um ou mais repositórios junto com os objetos necessários para completar suas histórias. Em outras palavras, ele busca os objetos que podem ser acessados ​​pelos objetos que já foram baixados. Veja: O que git fetch realmente faz?

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

git ls-remote -h -t Origin

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

Então, para _/buscar todos eles, tente:

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

O parâmetro --depth=10000 pode ajudar se você tiver um repositório vazio.

Em seguida, verifique todas as suas filiais novamente:

git branch -avv

Se acima não vai ajudar, você precisa adicionar ramos faltando manualmente para a lista rastreada (como eles se perderam de alguma forma):

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

por git remote set-branches gosta:

git remote set-branches --add Origin missing_branch

então pode aparecer em remotes/Origin após buscar:

$ 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 obter algo além da ramificação mestre, verifique o seguinte:

  • Verifique seus controles remotos (git remote -v), por exemplo,
    • Valide que git config branch.master.remote é Origin.
    • Verifique se Origin aponta para o URL correto via: git remote show Origin (veja isto post ).
6
kenorb

A partir do início de 2017, a resposta neste comentário funciona:

git fetch <Origin-name> <branch-name> traz o ramo para você. Embora isso não puxe todas as ramificações de uma vez, você pode executar essa ramificação individualmente.

6
ashes999

Nenhuma dessas respostas corta, exceto que o usuário 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 apenas criou uma ramificação local para o mestre, então, quando eu o empurrei para o novo controle remoto, apenas a ramificação principal foi pressionada.

Então eu achei esses dois métodos muito úteis. Espero que eles ajudem outra pessoa.

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
6
Gaui

Use comandos que você possa lembrar

Estou usando o Bitbucket, um Serviço de Hospedagem de Repositórios da Atlassian. Então eu tento seguir seus documentos. E isso funciona perfeitamente para mim. Com os seguintes comandos fáceis e curtos, você pode verificar sua ramificação remota.

No começo, clone seu repositório e, em seguida, mude para a pasta de destino. E por último, mas não menos importante, busca e saída:

git clone <repo> <destination_folder>
cd <destination_folder>
git fetch && git checkout <branch>

É isso aí. Aqui um pequeno exemplo do mundo real:

git clone https://[email protected]/team/repository.git project_folder
cd project_folder
git fetch && git checkout develop

Você encontrará informações detalhadas sobre os comandos nos documentos: Comando Clone , Comando Buscar , Comando Checkout

6
Phil

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

Ele também funciona corretamente se o rastreamento de ramificações locais já estiver criado. Você pode chamá-lo depois do primeiro git clone ou qualquer momento posterior.

Se você não precisa ter a ramificação master registrada após a clonagem, use 

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

git clone --mirror no repo 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
3
Bernd Jungblut

Vou adicionar meus 2 centavos aqui porque cheguei aqui tentando descobrir como extrair um branch remoto que eu deletei localmente. A origem não era minha, e eu não queria passar pelo incômodo de re-clonar tudo 

Isso funcionou para mim:

supondo que você precisa recriar o ramo localmente:

git checkout -b recreated-branch-name
git branch -a (to list remote branches)
git rebase remotes/remote-Origin/recreated-branch-name

Então, se eu bifurcasse do gituser/master para o sjp e depois o ramificasse para sjp/mynewbranch, ficaria assim:

$ git checkout -b mynewbranch
$ git branch -a
  master
  remotes/sjp/master
  remotes/sjp/mynewbranch
$ git fetch (habit to always do before)
$ git rebase remotes/sjp/mynewbranch
2
Camwyn

Um pouco atrasado para a festa, mas acho que isso faz o truque:

mkdir YourRepo
cd YourRepo
git init --bare .git                       # create a bare repo
git remote add Origin REMOTE_URL           # add a remote
git fetch Origin refs/heads/*:refs/heads/* # fetch heads
git fetch Origin refs/tags/*:refs/tags/*   # fetch tags
git init                                   # reinit work tree
git checkout master                        # checkout a branch

Se isso fizer algo indesejável, eu adoraria saber. No entanto, até agora, isso funciona para mim.

0
Andy

Esta variação irá clonar um repositório remoto com todas as filiais disponíveis localmente sem ter que fazer o checkout de cada ramificação, uma a uma. Nenhum script sofisticado é necessário.

Crie uma pasta com o mesmo nome do repositório que você deseja clonar e digitar, por exemplo:

mkdir somerepo
cd somerepo

Agora faça estes comandos, mas com o reponame usersname real/reponame 

git clone --bare [email protected]:someuser/somerepo.git .git
git config --bool core.bare false
git reset --hard
git branch

Voiala! você tem todos os galhos lá!

0
lacostenycoder

Aqui está um script bash para buscar todos os branches e tags de um projeto git como snapshots em pastas separadas. 

https://Gist.github.com/hfossli/7562257

Talvez não o que foi perguntado diretamente, mas algumas pessoas podem vir aqui procurando por essa solução.

0
hfossli