it-swarm-eu.dev

Jak klonovat všechny vzdálené pobočky v Gitu?

Mám master a development větev, obě tlačené do GitHub . Mám cloned, pulled a fetched, ale nemohu získat nic jiného, ​​než je master větev zpět.

Jsem si jistý, že něco chybí, ale přečetl jsem si manuál a nemám vůbec žádnou radost.

3746
Peter Coulton

Nejprve klonujte vzdálený Git repository a cd do něj:

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

Dále se podívejte na místní pobočky ve vašem úložišti:

$ git branch
* master

Ve vašem úložišti se skrývají i další pobočky! Můžete je vidět pomocí příznaku -a:

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

Chcete-li se rychle podívat na pobočku, můžete si ji zkontrolovat přímo:

$ git checkout Origin/experimental

Pokud však chcete na této pobočce pracovat, budete muset vytvořit lokální větev sledování, kterou provede automaticky:

$ git checkout experimental

a uvidíte

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

Ten poslední řádek hodí některé lidi: "Nová větev" - huh? Co to vlastně znamená, že větev je převzata z indexu a vytvořena pro vás lokálně. Řádek previous je ve skutečnosti informativnější, protože říká, že pobočka je nastavena tak, aby sledovala vzdálenou větev, což obvykle znamená větev Origin/branch_name 

Pokud se podíváte na místní pobočky, uvidíte to takto:

$ git branch
* experimental
  master

Pomocí git remote můžete skutečně sledovat více než jedno vzdálené úložiště.

$ 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

V tuto chvíli se věci dostávají do šílenství, takže spusťte gitk a zjistěte, co se děje:

$ gitk --all &
4191
emk

Pokud máte mnoho vzdálených poboček, které chcete načíst najednou, postupujte takto:

$ git pull --all

Nyní si můžete vyzkoušet jakoukoliv pobočku, kterou potřebujete, aniž byste museli zasáhnout vzdálené úložiště.

763
Gabe Kopley

Tento Bash skript mi ​​pomohl:

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

Vytvoří sledovací větve pro všechny vzdálené pobočky, s výjimkou masteru (který jste pravděpodobně dostali z původního příkazu klon). Myslím, že ještě budete muset udělat 

git fetch --all
git pull --all

si být jisti.

Jeden 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 Jako obvykle: testujte v nastavení před kopírováním vesmíru rm -rf, jak ho známe 

Kredity pro jednoho uživatele přejdou na uživatele cfi

388
bigfish

Zdá se, že pomocí volby --mirror se řádně zkopírují sledovací větve remote. Nastaví však úložiště jako nahé úložiště, takže ho musíte později vrátit do normálního úložiště.

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

Reference: Git FAQ: Jak mohu klonovat úložiště se všemi vzdáleně sledovanými větvemi?

300
Dave

Můžete snadno přepnout na pobočku bez použití fantázní syntaxe "git checkout -b somebranch Origin/somebranch". Stačí to udělat:

git checkout somebranch

Git automaticky udělá správnou věc:

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

Git zkontroluje, zda větev se stejným názvem existuje v přesně jednom vzdáleném prostředí, a pokud ano, sleduje ji stejným způsobem, jako kdybyste explicitně zadali, že se jedná o vzdálenou pobočku. Z manuálové stránky git-checkout Git 1.8.2.1:

Pokud <branch> nebyl nalezen, ale existuje větev pro sledování v Přesně jeden vzdálený (volejte <remote>) s odpovídajícím názvem, považujte se za ekvivalentní

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

Ohledně,

$ git checkout -b Experimentální Původ/experiment

použitím

$ git checkout -t Origin/experimental

nebo více verbose, ale lépe zapamatovatelné

$ git checkout --track Origin/experimental

může být lepší, pokud jde o sledování vzdáleného úložiště. 

90
murphytalk

Fetch, který děláte, by měl dostat všechny vzdálené pobočky, ale nebude pro ně vytvářet místní pobočky. Pokud používáte gitk, měli byste vidět vzdálené větve popsané jako "remotes/Origin/dev" nebo něco podobného.

Chcete-li vytvořit místní pobočku založenou na vzdálené pobočce, proveďte něco jako:

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

Co by mělo vrátit něco jako:

Pobočka dev nastavena na sledování vzdálené větve refs/remotes/Origin/dev. 
 Přepnuto na novou pobočku "dev"

Nyní, když jste na větvi dev, bude "git pull" aktualizovat váš lokální dev na stejný bod jako vzdálená pobočka dev. Všimněte si, že načte všechny větve, ale pouze táhne ten, na kterém se nacházíte.

78
Luuk Paulussen

Když provedete "git clone git: // location", budou načteny všechny větve a značky.

Chcete-li pracovat navrchu určité vzdálené pobočky, za předpokladu, že je vzdálený:

git checkout -b branch Origin/branchname
57
elmarco

Použít aliasy. Ačkoli tam nejsou žádné nativní Git one-liners, můžete definovat své vlastní jako

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

a pak jej použijte jako

git clone-branches
49
nobody

To není příliš složité, velmi jednoduché a přímé kroky jsou následující;

git fetch Origin Tím se přivedou všechny vzdálené pobočky na místní.

git branch -a Zobrazí všechny vzdálené pobočky.

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

Ověřte, zda se nacházíte v požadované větvi následujícím příkazem;

git branch

Výstup se to bude líbit;

*your current branch 
some branch2
some branch3 

Všimněte si znak *, který označuje aktuální větev.

44
Sam

Proč vidíte jen "mistra"

git clone stáhne všechny vzdálené vzdálené pobočky, ale přesto je považuje za "vzdálené", i když jsou soubory umístěny ve vašem novém úložišti. Existuje jedna výjimka, která spočívá v tom, že proces klonování vytvoří lokální větev nazvanou "master" ze vzdálené větve nazvané "master". Ve výchozím nastavení zobrazuje git branch pouze lokální větve, proto vidíte pouze "master".

git branch -a zobrazuje všechny pobočky, včetně vzdálených poboček.


Jak získat místní pobočky

Pokud skutečně chcete pracovat na větvi, budete pravděpodobně chtít její "místní" verzi. Chcete-li jednoduše vytvořit místní pobočky ze vzdálených poboček (aniž byste je zkontrolovali a tím změnili obsah vašeho pracovního adresáře), můžete tak učinit takto:

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

V tomto příkladu je branchone název místní větve, kterou vytváříte na základě Origin/branchone; pokud chcete vytvořit místní pobočky s různými názvy, můžete to provést takto:

git branch localbranchname Origin/branchone

Jakmile vytvoříte místní pobočku, můžete ji vidět pomocí git branch (nezapomeňte, že pro zobrazení místních poboček nepotřebujete -a).

43
Cerran

Pozdnější než nikdy, ale tady je nejlepší způsob, jak toho dosáhnout:

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

V tomto okamžiku máte kompletní kopii vzdáleného repo se všemi jeho větvemi (ověřte pomocí git branch). Můžete použít --mirror namísto --bare, pokud má vaše vzdálené repo vlastní ovladače.

42
Jacob Fike

Udělejte to takto:

$ 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

Vidíte, 'git clone git: //example.com/myprojectt' vyvolá všechno, dokonce i větve, stačí si je vyzkoušet, pak bude vytvořena vaše místní pobočka.

38
rapher

K získání všech větví stačí použít "git klon".

git clone <your_http_url>

I když vidíte pouze hlavní větev, můžete použít "git branch -a" pro zobrazení všech větví.

git branch -a

A můžete přepnout na kteroukoli pobočku, kterou již máte.

git checkout <your_branch_name>

Nebojte se, že po "git klon", nemusíte se spojit se vzdáleným repo, "git větev -a" a "git checkout" lze úspěšně spustit, když zavřete wifi. Je tedy prokázáno, že když děláte "git clone", zkopíruje již všechny větve ze vzdáleného repo. Po tom, nepotřebujete vzdálené repo, místní má již všechny pobočky kódy. 

23
Haimei

git clone má kopírovat celé úložiště. Zkuste to klonovat a pak spusťte git branch -a. Měla by obsahovat seznam všech větví. Pokud chcete přepnout do větve "foo" namísto "master", použijte git checkout foo.

22
MattoxBeckman

Použijte můj nástroj git_remote_branch (musíte mít na svém počítači nainstalován Ruby). Je postaven speciálně pro snadnou manipulaci vzdálených poboček.

Pokaždé, když provede operaci ve vašem zastoupení, vytiskne ji v konzole červeně. Postupem času se konečně drží v mozku :-)

Pokud nechcete, aby příkaz grb spouštěl příkazy ve vašem zastoupení, použijte funkci „vysvětlit“. Příkazy budou vytištěny na konzoli namísto spuštění pro vás.

Nakonec mají všechny příkazy aliasy, které usnadňují zapamatování.

Všimněte si, že se jedná o software alpha ;-)

Zde naleznete nápovědu při spuštění grb help:

 git_remote_branch version 0.2.6 
 
 Použití: 
 
 grb create branch_name [Origin_server] 
 
 grb publish branch_name [Origin_server] 
 
 grb přejmenovat branch_name [Origin_server] 
 
 grb delete branch_name [Origin_server] 
 
 grb track branch_name [ Origin_server] 
 
 
 
 Poznámky: 
 - Pokud není hodnota Origin_server zadána, předpokládá se jméno 'Origin' 
 (Git's default] 
 - Funkce přejmenování přejmenuje aktuální větev 
 
 Příkaz explanační meta: můžete také předpsat libovolný příkaz s klíčovým slovem 
. Namísto provedení příkazu git_remote_branch 
 Jednoduše vydá seznam příkazů, které potřebujete spustit, abyste dosáhli cíle 
. 
 
 Příklad: 
 grb vysvětlit vytvořit 
 grb vysvětlit vytvořit my_branch github 
 
 Všechny příkazy mají také aliasy: 
 create: create, new 
 delete: delete, destroy, kill, remove, rm 
 publikovat: publikovat, remotizovat 
 přejmenovat: přejmenovat, rn, mv, přesunout 
 track: track, následovat, chytit, načíst 
19
webmat

všechny odpovědi, které jsem zde viděl, jsou platné, ale existuje mnohem čistší způsob, jak klonovat úložiště a vytáhnout všechny větve najednou. 

Když klonujete úložiště, všechny informace o větvích jsou skutečně staženy, ale větve jsou skryté. S příkazem

$ git branch -a

můžete zobrazit všechny větve úložiště a příkaz

$ git checkout -b branchname Origin/branchname

můžete je pak ručně stahovat ručně. 


Nicméně, když chcete klonovat repo s mnoha pobočkami, všechny výše uvedené způsoby jsou zdlouhavé a zdlouhavé, pokud jde o mnohem čistší a rychlejší způsob, jak to ukážu, i když je to trochu složitější. K dosažení tohoto cíle potřebujete tři kroky:

  1. První krok

vytvořte v počítači novou prázdnou složku a klonujte zrcadlovou kopii složky .git z úložiště:

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

lokální repozitář uvnitř složky my_repo_folder je stále prázdný, nyní je zde jen skrytá složka .git, kterou můžete vidět pomocí příkazu ls -alt z terminálu.

  1. Druhý krok

přepněte toto úložiště z prázdného (holého) úložiště do běžného úložiště přepnutím boolean hodnoty "bare" konfigurací git na false:

$ git config --bool core.bare false
  1. Třetí krok

Uchopte vše, co je v aktuální složce, a vytvořte všechny pobočky na lokálním počítači, takže je to normální repo. 

$ git reset --hard

Nyní tedy stačí zadat příkaz "git branch" a uvidíte, že všechny pobočky jsou staženy. 

Toto je rychlý způsob, jak můžete klonovat úložiště git se všemi větvemi najednou, ale není to něco, co byste chtěli udělat pro každý jednotlivý projekt tímto způsobem. 

15
FedericoCapaldo

Při pohledu na jednu z odpovědí na otázku jsem si všiml, že je možné ji zkrátit:

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

Ale pozor, pokud je jedno ze vzdálených větví pojmenováno jako např. admin_master nebude stažen!

Díky bigfish za originální nápad

12
Tebe

OK, když klonujete své repo, máte tam všechny pobočky ...

Pokud právě děláte git branch, jedná se o skryté ...

Pokud tedy chcete zobrazit všechny názvy poboček, stačí jednoduše přidat příznak --all:

git branch --all nebo git branch -a

Pokud jste jen checkout do pobočky, dostanete vše, co potřebujete.

Ale co kdyby větev vytvořená někým jiným po klonování?

V tomto případě stačí:

git fetch

a znovu zkontrolujte všechny pobočky ...

Pokud chcete najednou načíst a zkontrolovat, můžete provést následující kroky:

git fetch && git checkout your_branch_name

Vytvořili jste také níže uvedený obrázek, abyste zjednodušili, co jsem řekl:

 git branch --all to get all branches

12
Alireza

Klonování z lokálního repo nebude fungovat s git clone & git fetch: mnoho větví/tagů zůstane neotevřených.

Získat klon se všemi větvemi a značkami.

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

Chcete-li získat klon se všemi větvemi a značkami, ale také s pracovní kopií:

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

Tento kód vytáhne všechny kódy vzdálených poboček do místního repo.

11
Albert.Qing

Pro kopírování-vložení do příkazového řádku:

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

Pro lepší přehlednost:

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


Tohle bude:

  1. podívejte se na pána (abychom mohli smazat větev, ve které se nacházíte)
  2. vyberte vzdálené na pokladnu (změňte ji na vzdálené)
  3. smyčka přes všechny větve dálkového ovládání kromě master a HEAD
    1. smazat místní pobočka (abychom mohli zkontrolovat síly aktualizované větve)
    2. check out větev z dálkového ovladače
  4. zkontrolovat mistra (kvůli tomu)

Na základě odpověď z VonC .

10
ikaruss

Napsal jsem tuto malou funkci Powershell, abych mohl vyzkoušet všechny mé git větve, které jsou na 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>' #>
}

Více funkcí git lze nalézt na Moje nastavení GIT nastavení

8
gringo_dave

Potřeboval jsem udělat totéž. Zde je můj Ruby skript.

#!/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 obvykle (když není specifikován) načte všechny větve a/nebo tagy (refs, viz: git ls-refs) z jednoho nebo více jiných repozitářů spolu s objekty nezbytnými pro dokončení jejich historie. Jinými slovy vyvolá objekty, které jsou dosažitelné objekty, které jsou již staženy. Viz: Co dělá git fetch opravdu?

Někdy můžete mít větve/tagy, které nejsou přímo spojeny s aktuálními, takže git pull --allgit fetch --all v tomto případě nepomůže, ale můžete je vypsat podle:

git ls-remote -h -t Origin

a vyzvedněte je manuálně, pokud znáte jména ref.

Chcete-li je _/načíst všechny, zkuste:

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

Parametr --depth=10000 může pomoci v případě, že jste úložiště používali.

Pak znovu zkontrolujte všechny pobočky:

git branch -avv

Pokud výše uvedené nepomůže, musíte ručně přidat chybějící větve do sledovaného seznamu (jak se nějakým způsobem ztratili):

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

podle git remote set-branches jako:

git remote set-branches --add Origin missing_branch

po načtení se může zobrazit pod remotes/Origin:

$ 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

Odstraňování problémů

Pokud stále nemůžete získat nic jiného než hlavní pobočku, zkontrolujte následující:

  • Dvakrát zkontrolujte své dálkové ovladače (git remote -v), např.
    • Ověřte, že git config branch.master.remote je Origin.
    • Zkontrolujte, zda Origin ukazuje na správnou adresu URL pomocí: git remote show Origin (viz příspěvek ).
6
kenorb

Od začátku roku 2017, odpověď v tomto komentáři pracuje:

git fetch <Origin-name> <branch-name> přivádí pobočku dolů. I když to nevytáhne všechny větve najednou, můžete to provést jednotlivě za každou pobočku.

6
ashes999

Žádná z těchto odpovědí ji neřeže, kromě toho, že nikdo není na správné cestě.

Měl jsem problémy s přesunem repo z jednoho serveru/systému do druhého. Když jsem klonoval repo, vytvořil pouze lokální pobočku pro pána, takže když jsem tlačil na nový ovladač, byla stisknuta pouze hlavní větev.

Tak jsem našel tyto dvě metody velmi užitečné. Doufám, že pomohou někomu jinému.

Metoda 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

Metoda 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

Použijte příkazy, které si pamatujete

Používám Bitbucket, službu úložiště úložišť společnosti Atlassian. Tak se snažím sledovat jejich dokumenty. A to funguje perfektně pro mě. Pomocí následujících jednoduchých a krátkých příkazů si můžete vyzkoušet vzdálenou pobočku.

Nejdříve klonujte své úložiště a poté přejděte do cílové složky. A v neposlední řadě načtení a odbavení:

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

A je to. Zde je příklad více reálného světa:

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

Podrobné informace o příkazech naleznete v dokumentech: Příkaz klonování , Příkaz Fetch , Příkaz Checkout

6
Phil

Zde je další krátký příkaz, který Vytvoří místní pobočky pro všechny vzdálené pobočky:

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

Funguje také správně, pokud jsou již vytvořeny lokální pobočky. Můžete jej zavolat za první git clone nebo kdykoliv později.

Pokud nepotřebujete mít master větev odhlášenou po klonování, použijte 

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

git clone --mirror na původní repo funguje dobře.

git clone --mirror /path/to/original.git
git remote set-url Origin /path/to/new-repo.git
git Push -u Origin
3
Bernd Jungblut

Přidám sem své 2 centy, protože jsem se sem snažil zjistit, jak vytáhnout vzdálenou větev, kterou jsem lokálně smazal. Původ nebyl můj, a já jsem nechtěl projít hádkou znovu klonovat všechno 

To fungovalo pro mě:

za předpokladu, že je třeba lokálně znovu vytvořit pobočku:

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

Takže pokud jsem vidličku z gituser/master do sjp a pak rozvětvili na sjp/mynewbranch, vypadalo by to takto:

$ 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

Trochu pozdě na párty, ale myslím, že to dělá trik:

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

Pokud to dělá něco nežádoucího, rád bych to věděl. Nicméně, to funguje pro mě.

0
Andy

Tato variace klonuje vzdálený repo se všemi pobočkami dostupnými lokálně, aniž by museli každou pobočku kontrolovat po jednom. Nejsou potřeba žádné fantastické skripty.

Vytvořte složku se stejným názvem repo, který chcete klonovat a cd, například:

mkdir somerepo
cd somerepo

Nyní proveďte tyto příkazy, ale s aktuálním repo username/reponame 

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

Voiala! máte tam všechny pobočky!

0
lacostenycoder

Zde je bash skript pro načtení všech větví a značek projektu git jako snímků do samostatných složek. 

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

Možná ne to, co bylo položeno přímo, ale někteří lidé by sem mohli přijít hledat toto řešení.

0
hfossli