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

https://stackoverflow.com/questions/67699

09-06-2019
|

Pergunta

eu tenho um master e um development ramo, ambos empurrados para GitHub.Eu tenho cloned, pulled, e fetched, mas continuo incapaz de obter outra coisa senão o master ramificar para trás.

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

Solução

Primeiro, clone um controle remoto Git repositório e cd afim disso:

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

A seguir, observe as ramificações locais em seu repositório:

$ git branch
* master

Mas existem outros ramos escondidos no seu repositório!Você pode ver isso 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 uma ramificação upstream, você pode conferir diretamente:

$ git checkout origin/experimental

Mas se quiser trabalhar nessa filial, você precisará criar uma filial de rastreamento local, o 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 confunde algumas pessoas:"Nova filial" - hein?O que isso realmente significa é que o branch é retirado do índice e criado localmente para você.O anterior linha é na verdade mais informativa, pois informa 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ê observar suas filiais locais, verá o seguinte:

$ git branch
* experimental
  master

Na verdade, 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 gitk para ver o que está acontecendo:

$ gitk --all &

Outras dicas

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

$ git pull --all

Agora você pode fazer check-out de qualquer branch conforme necessário, sem acessar o repositório remoto.

Esse 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 pode precisar fazer um

git fetch --all
git pull --all

para ter certeza.

Um forro: 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 rm -rf universo como o conhecemos

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

Usando o --mirror opção parece copiar o remote rastreando filiais corretamente.No entanto, ele configura o repositório como um repositório vazio, então você terá que 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: Perguntas frequentes sobre o Git:Como clonar um repositório com todas as ramificações rastreadas remotamente?}

Você pode facilmente mudar para um branch sem usar a sintaxe sofisticada "git checkout -b somebranch origin/somebranch".Você pode simplesmente 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 existe um branch com o mesmo nome em exatamente um branch remoto e, se existir, ele o rastreará da mesma maneira como se você tivesse especificado explicitamente que é um branch remoto.Na página de manual git-checkout do Git 1.8.2.1:

Seu003Cbranch> não é encontrado, mas existe um ramo de rastreamento em exatamente um controle remoto (chameu003Cremote> ) 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ê usar o gitk, deverá ver as ramificações remotas descritas como "remotes/origin/dev" ou algo semelhante.

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

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

Que deve retornar algo como:

Branch dev set up to track remote branch refs/remotes/origin/dev.
Switched to a new branch "dev"

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

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, assumindo que seja a origem remota:

git checkout -b branch origin/branchname

Use apelidos.Embora não haja nenhuma linha nativa do Git, você pode definir a sua como

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

e então use-o como

git clone-branches

Por que você só vê "mestre"

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

git branch -a mostra todos os ramos, incluindo filiais remotas.

Como obter filiais locais

Se você realmente deseja trabalhar em um branch, provavelmente desejará uma versão "local" dele.Para simplesmente criar filiais locais a partir de filiais remotas (sem verificá-los 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 uma filial local que você está criando com base em origin/branchone;se você quiser criar filiais locais com nomes diferentes, você pode fazer o seguinte:

git branch localbranchname origin/branchone

Depois de criar uma filial local, você poderá vê-la com git branch (lembre-se, você não precisa -a para ver filiais locais).

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

git fetch origin Isso trará todas as filiais remotas para o seu local.

git branch -a Isso mostrará todas as filiais remotas.

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

Verifique se você está no branch desejado 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 --mirror em vez de --bare se o seu repositório remoto tiver controles remotos próprios.

Basta fazer 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

Veja bem, 'git clone git://example.com/myprojectt' busca tudo, até mesmo as ramificações, basta fazer o check-out e sua ramificação local será criada.

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

git clone <your_http_url>

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

git branch -a

E você pode mudar para qualquer filial que já possua.

git checkout <your_branch_name>

Não se preocupe, pois depois de "git clone", você não precisará se conectar ao repositório remoto, "git branch -a" e "git checkout" poderão ser executados com sucesso quando você fechar seu wifi.Então está 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 repositório remoto, seu local já possui todos os códigos das filiais.

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

Use minha ferramenta git_remote_branch (você precisa do Ruby instalado em sua máquina).Ele foi desenvolvido especificamente para facilitar a manipulação remota de filiais.

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

Se você não quiser que o grb execute comandos em seu nome, basta usar o recurso 'explicar'.Os comandos serão impressos em seu console em vez de executados para você.

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

Observe que isso é software alfa ;-)

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

git_remote_branch version 0.2.6

  Usage:

  grb create branch_name [origin_server] 

  grb publish branch_name [origin_server] 

  grb rename branch_name [origin_server] 

  grb delete branch_name [origin_server] 

  grb track branch_name [origin_server] 



  Notes:
  - If origin_server is not specified, the name 'origin' is assumed 
    (git's default)
  - The rename functionality renames the current branch

  The explain meta-command: you can also prepend any command with the 
keyword 'explain'. Instead of executing the command, git_remote_branch 
will simply output the list of commands you need to run to accomplish 
that goal.

  Example: 
    grb explain create
    grb explain create my_branch github

  All commands also have aliases:
  create: create, new
  delete: delete, destroy, kill, remove, rm
  publish: publish, remotize
  rename: rename, rn, mv, move
  track: track, follow, grab, fetch

todas as respostas que vi aqui são válidas, mas existe uma maneira muito mais limpa de clonar um repositório e extrair todas as ramificações de uma vez.

Quando você clona um repositório, todas as informações das ramificações são 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 então “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 demoradas e tediosas em relação a uma forma muito mais limpa e rápida que irei mostrar, embora seja um pouco complicada.Você precisa de três etapas para fazer isso:

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.

Segundo passo

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

$ git config --bool core.bare false

Terceiro passo

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

$ git reset --hard

Agora você pode simplesmente digitar o comando "git branch" e verá que todos os ramos foram baixados.

Esta é a maneira rápida de clonar um repositório git com todas as ramificações de uma vez, mas não é algo que você queira fazer para cada projeto dessa forma.

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 uma das filiais remotas for nomeada como, por exemplo.admin_master não será baixado!

Obrigado ao bigfish pela ideia original

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

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 todas as ramificações lá...

Se você apenas fizer git branch, eles ficam meio escondidos...

Então, se você quiser ver o nome de todos os ramos, basta adicionar --all bandeira assim:

git branch --all ou git branch -a

Se você apenas finalizar a compra na agência, terá tudo o que precisa.

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

Neste caso, basta fazer:

git fetch

e verifique todos os ramos novamente ...

Se você gosta de buscar e finalizar a compra ao mesmo tempo, você pode fazer:

git fetch && git checkout your_branch_name

Criei também a imagem abaixo para você simplificar o que falei:

#!/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á todos os códigos de filiais 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

Isso vai:

verifique master (para que possamos excluir o branch em que estamos)
selecione remoto para finalizar a compra (altere para qualquer controle remoto que você tenha)
percorrer todos os ramos do controle remoto, exceto master e HEAD
1. excluir filial local (para que possamos verificar as filiais com atualização forçada)
2. Confira ramificação do controle remoto
confira mestre (só por fazer)

Baseado em responder de VonC.

Eu precisava fazer exatamente o mesmo.Aqui está o meu Rubi roteiro.

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

Eu escrevi este pequeno Powershell funções para poder verificar todas as minhas ramificações git, que estão na origem remota.

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 meu repositório de configurações do git

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

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

git ls-remote -h -t origin

e busque-os manualmente conhecendo os nomes das referências.

Então para pegue todos eles, tentar:

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

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

Em seguida, verifique todas as suas filiais novamente:

git branch -avv

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

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

por git remote set-branches como:

git remote set-branches --add origin missing_branch

então pode aparecer abaixo remotes/origin depois de 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 nada além do branch master, verifique o seguinte:

Verifique seus controles remotos (git remote -v), por exemplo.
- Valide isso git config branch.master.remote é origin.
- Verifique se origin aponta para o URL correto por meio de: git remote show origin (Veja isso publicar).

Nenhuma dessas respostas foi suficiente, 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 clonei o repositório, ele criou apenas uma ramificação local para o master, portanto, quando enviei para o novo controle remoto, apenas a ramificação master foi enviada.

Então 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

Use comandos que você possa lembrar

Estou usando o Bitbucket, um serviço de hospedagem de repositório da Atlassian.Então tento seguir seus documentos.E isso funciona perfeitamente para mim.Com os seguintes comandos fáceis e curtos você pode verificar sua filial remota.

Primeiro, clone seu repositório e depois mude para a pasta de destino.E por último, mas não menos importante, buscar e finalizar a compra:

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

É isso.Aqui está um exemplo um pouco mais do mundo real:

git clone https://username@bitbucket.org/team/repository.git project_folder
cd project_folder
git fetch && git checkout develop

Você encontrará informações detalhadas sobre os comandos nos documentos:Comando Clonar, Comando de busca, Comando de check-out

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

git fetch <origin-name> <branch-name> traz o galho para você.Embora isso não extraia todas as ramificações de uma vez, você pode executar isso individualmente por ramificação.

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

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

Também funciona corretamente se o rastreamento de filiais locais já tiver sido criado.Você pode chamá-lo após o primeiro git clone ou a qualquer momento depois.

Se você não precisa ter master branch verificado após a clonagem, use

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

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

Licenciado em: CC-BY-SA com atribuição

Não afiliado a StackOverflow