it-swarm-fr.com

Comment cloner toutes les branches distantes dans Git?

J'ai une branche master et une branche development, toutes deux poussées vers GitHub . J'ai cloned, pulled et fetched, mais je ne peux obtenir d'autre que la branche master.

Je suis sûr que quelque chose d’évident me manque, mais j’ai lu le manuel et je ne ressens aucune joie.

3746
Peter Coulton

Commencez par cloner un répertoire Git repository et cd dans:

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

Ensuite, regardez les branches locales dans votre référentiel:

$ git branch
* master

Mais il y a d'autres branches cachées dans votre référentiel! Vous pouvez les voir en utilisant l'indicateur -a:

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

Si vous voulez juste jeter un coup d’œil sur une branche en amont, vous pouvez le vérifier directement:

$ git checkout Origin/experimental

Mais si vous souhaitez travailler sur cette branche, vous devez créer une branche de suivi locale, qui se fait automatiquement par:

$ git checkout experimental

et vous allez voir

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

Cette dernière ligne lance certaines personnes: "Nouvelle branche" - hein? Cela signifie vraiment que la branche est extraite de l'index et créée localement pour vous. La ligne previous est en réalité plus informative, car elle vous indique que la branche est en cours de configuration pour suivre la branche distante, ce qui signifie généralement la branche Origine/nom de la branche 

Maintenant, si vous regardez vos succursales locales, voici ce que vous verrez:

$ git branch
* experimental
  master

En réalité, vous pouvez suivre plusieurs référentiels distants à l'aide de 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

À ce stade, les choses deviennent assez folles, alors lancez gitk pour voir ce qui se passe:

$ gitk --all &
4191
emk

Si vous souhaitez extraire plusieurs branches distantes simultanément, procédez comme suit:

$ git pull --all

Maintenant, vous pouvez extraire n'importe quelle branche à votre guise, sans frapper le référentiel distant.

763
Gabe Kopley

Ce Bash script m'a aidé à sortir:

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

Il créera des branches de suivi pour toutes les branches distantes, à l'exception de maître (que vous avez probablement obtenue à l'aide de la commande de clonage d'origine). Je pense que vous pourriez encore avoir besoin de faire un 

git fetch --all
git pull --all

pour être sûr.

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 Comme d'habitude: testez dans votre configuration avant de copier l'univers rm -rf tel que nous le connaissons 

_ {Crédits pour one-liner aller à l'utilisateur cfi} _

388
bigfish

L'utilisation de l'option --mirror semble copier les branches de suivi remote correctement ..____. Cependant, le référentiel est configuré en tant que référentiel nu, vous devez donc le reconvertir en référentiel normal.

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

Référence: FAQ Git: Comment cloner un référentiel avec toutes les branches suivies à distance?

300
Dave

Vous pouvez facilement basculer vers une branche sans utiliser la syntaxe sophistiquée "git checkout -b une origine/une branche". Vous pouvez juste faire:

git checkout somebranch

Git fera automatiquement le bon choix:

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

Git vérifiera si une branche du même nom existe dans exactement une télécommande et si c'est le cas, il la suivra de la même manière que si vous aviez explicitement spécifié qu'il s'agissait d'une branche distante. Depuis la page de manuel git-checkout de Git 1.8.2.1:

Si <branche> n'est pas trouvé mais qu'il existe une branche de suivi dans exactement une télécommande (appelez-la <remote>) avec un nom correspondant, traitez-la comme équivalent à

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

En ce qui concerne,

$ git checkout -b expérimental Origine/expérimental

en utilisant

$ git checkout -t Origin/experimental

ou le plus bavard mais plus facile à retenir

$ git checkout --track Origin/experimental

pourrait être mieux, en termes de suivi d'un référentiel distant. 

90
murphytalk

L'extraction que vous effectuez devrait obtenir toutes les branches distantes, mais ne créera pas de branches locales pour elles. Si vous utilisez gitk, vous devriez voir les branches distantes décrites comme "télécommandes/Origine/dev" ou quelque chose de similaire.

Pour créer une branche locale basée sur une branche distante, procédez comme suit:

git checkout -b dev réfs/télécommandes/origine/dev

Ce qui devrait retourner quelque chose comme:

Branch dev mis en place pour suivre les références/télécommandes/Origin/dev .

Maintenant, lorsque vous êtes sur la branche dev, "git pull" mettra à jour votre dev local au même point que la branche dev distante. Notez que toutes les branches seront récupérées, mais ne tirez que celle que vous avez en haut de l'arbre.

78
Luuk Paulussen

Lorsque vous faites "git clone git: // location", toutes les branches et les balises sont récupérées.

Pour pouvoir travailler sur une branche distante spécifique, en supposant qu'il s'agisse de la télécommande d'origine:

git checkout -b branch Origin/branchname
57
elmarco

Utilisez des alias. Bien qu’il n’y ait pas de one-liners Git natifs, vous pouvez définir votre propre

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

et ensuite l'utiliser comme

git clone-branches
49
nobody

Ce n'est pas trop compliqué, très simple et les étapes simples sont les suivantes;

git fetch Origin Ceci amènera toutes les succursales distantes chez vous.

git branch -a Ceci vous montrera toutes les branches distantes.

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

Vérifiez si vous êtes dans la branche souhaitée à l'aide de la commande suivante.

git branch

La sortie sera comme ça;

*your current branch 
some branch2
some branch3 

Notez le signe * qui indique la branche actuelle.

44
Sam

Pourquoi vous ne voyez que "maître"

git clone télécharge toutes les branches distantes distantes mais les considère toujours comme "distantes", même si les fichiers se trouvent dans votre nouveau référentiel. Il existe une exception à cela: le processus de clonage crée une branche locale appelée "maître" à partir de la branche distante appelée "maître". Par défaut, git branch affiche uniquement les branches locales, raison pour laquelle vous ne voyez que "maître".

git branch -a affiche toutes les branches, y compris les branches distantes .


Comment obtenir des branches locales

Si vous voulez réellement travailler sur une branche, vous voudrez probablement une version "locale" de celle-ci. Pour créer simplement des branches locales à partir de branches distantes (sans les extraire et donc modifier le contenu de votre répertoire de travail) , vous pouvez le faire comme ceci:

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

Dans cet exemple, branchone est le nom d'une branche locale que vous créez en fonction de Origin/branchone; Si vous voulez plutôt créer des branches locales avec des noms différents, vous pouvez le faire:

git branch localbranchname Origin/branchone

Une fois que vous avez créé une branche locale, vous pouvez la voir avec git branch (rappelez-vous que vous n'avez pas besoin de -a pour voir les branches locales).

43
Cerran

Mieux vaut tard que jamais, mais voici le meilleur moyen de le faire:

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

À ce stade, vous avez une copie complète du référentiel distant avec toutes ses branches (vérifiez avec git branch). Vous pouvez utiliser --mirror au lieu de --bare si votre repo distant a ses propres télécommandes.

42
Jacob Fike

Faites juste ceci:

$ 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

Vous voyez, 'git clone git: //example.com/myprojectt' récupère tout, même les branches, il vous suffit de les commander, votre branche locale sera alors créée.

38
rapher

Il vous suffit d'utiliser "git clone" pour obtenir toutes les branches.

git clone <your_http_url>

Même si vous ne voyez que les branches master, vous pouvez utiliser "git branch -a" pour voir toutes les branches.

git branch -a

Et vous pouvez passer à n’importe quelle branche que vous avez déjà.

git checkout <your_branch_name>

Ne vous inquiétez pas qu'après avoir "cloué git", vous n'avez pas besoin de vous connecter au référentiel distant, "git branch -a" et "git checkout" peuvent être exécutés avec succès lorsque vous fermez votre réseau wifi. Il est donc prouvé que lorsque vous faites "git clone", il a déjà copié toutes les branches du dépôt distant. Après cela, vous n'avez plus besoin du référentiel distant, votre section locale possède déjà tous les codes des branches. 

23
Haimei

Un git clone est censé copier l'intégralité du référentiel. Essayez de le cloner, puis exécutez git branch -a. Il devrait énumérer toutes les branches. Si ensuite vous voulez passer à la branche "foo" au lieu de "master", utilisez git checkout foo.

22
MattoxBeckman

Utilisez mon outil git_remote_branch (vous devez installer Ruby sur votre machine). Il a été spécialement conçu pour faciliter les manipulations de branche distante.

Chaque fois qu'il effectue une opération en votre nom, il l'imprime en rouge sur la console. Au fil du temps, ils ont finalement collé dans votre cerveau :-)

Si vous ne voulez pas que grb exécute des commandes en votre nom, utilisez simplement la fonction 'expliquer'. Les commandes seront imprimées sur votre console au lieu d’être exécutées pour vous.

Enfin, toutes les commandes ont des alias pour faciliter la mémorisation.

Notez qu'il s'agit de logiciel alpha ;-)

Voici l'aide lorsque vous exécutez grb help:

 git_remote_branch version 0.2.6 

 Usage:

 grb crée un nom de branche [serveur_origine] 

 grb publish nom_branche [serveur_origine] 

 grb renomme le nom de la branche [serveur_origine] 

 grb delete nom_branche [serveur_origine] 

 grb suivi nom_branche [serveur_origine] 


.____. Remarques:
 - Si Origin_server n'est pas spécifié, le nom 'Origin' est utilisé 
 (valeur par défaut de git) 
 - La fonctionnalité de changement de nom renomme la branche actuelle 

 La méta-commande d'expliquer: vous pouvez également ajouter n'importe quelle commande avec le mot-clé 
 'Expliquer'. Au lieu d'exécuter la commande, git_remote_branch 
 Affichera simplement la liste des commandes à exécuter pour atteindre 
 Cet objectif .

 Exemple: 
 grb expliquer créer 
 grb explique create my_branch github 

 Toutes les commandes ont également des alias: 
 créer: créer, nouveau 
 delete: supprime, détruit, tue, supprime, rm 
 publier: publier, supprimer 
 renommer: renommer, rn, mv, move 
 suivre: suivre, suivre, saisir, récupérer 
19
webmat

toutes les réponses que j'ai vues ici sont valables, mais il existe un moyen beaucoup plus simple de cloner un référentiel et de tirer toutes les branches à la fois. 

Lorsque vous clonez un référentiel, toutes les informations des branches sont effectivement téléchargées, mais les branches sont masquées. À la commande

$ git branch -a

vous pouvez afficher toutes les branches du référentiel, et avec la commande

$ git checkout -b branchname Origin/branchname

vous pouvez ensuite les "télécharger" manuellement, un à la fois. 


Cependant, lorsque vous voulez cloner une prise en pension avec beaucoup de branches, toutes les manières illustrées ci-dessus sont longues et fastidieuses en ce qui concerne une manière beaucoup plus propre et rapide que je vais montrer, même si c'est un peu compliqué. Vous avez besoin de trois étapes pour y parvenir:

  1. Premier pas

créez un nouveau dossier vide sur votre ordinateur et clonez une copie miroir du dossier .git à partir du référentiel:

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

le référentiel local à l'intérieur du dossier my_repo_folder est toujours vide, il ne reste plus qu'un dossier .git caché que vous pouvez voir avec une commande "ls -alt" depuis le terminal.

  1. Deuxième étape

basculez ce référentiel d'un référentiel vide vers un référentiel normal en basculant la valeur booléenne "bare" des configurations git sur false:

$ git config --bool core.bare false
  1. Troisième étape

Prenez tout ce qui se trouve dans le dossier en cours et créez toutes les branches sur la machine locale, ce qui en fait un référentiel normal. 

$ git reset --hard

Alors maintenant, vous pouvez simplement taper la commande "branche git" et vous pouvez voir que toutes les branches sont téléchargées. 

C'est le moyen rapide par lequel vous pouvez cloner un référentiel git avec toutes les branches à la fois, mais ce n'est pas quelque chose que vous voulez faire pour chaque projet de cette manière. 

15
FedericoCapaldo

En regardant l'une des réponses à la question, j'ai remarqué qu'il était possible de la raccourcir:

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

Mais méfiez-vous, si l’une des branches distantes est nommée par exemple. admin_master ça ne sera pas téléchargé!

Merci à bigfish pour son idée originale

12
Tebe

OK, quand vous clonez votre repo, vous y avez toutes les branches ...

Si vous ne faites que git branch, ils sont en quelque sorte cachés ...

Donc, si vous souhaitez voir le nom de toutes les branches, ajoutez simplement le drapeau --all comme ceci:

git branch --all ou git branch -a

Si vous venez de passer à la succursale, vous aurez tout ce dont vous avez besoin.

Mais qu'en est-il de la branche créée par quelqu'un d'autre après votre clonage?

Dans ce cas, il suffit de faire:

git fetch

et vérifiez à nouveau toutes les branches ...

Si vous aimez aller chercher et commander en même temps, vous pouvez faire:

git fetch && git checkout your_branch_name

Également créé l'image ci-dessous pour vous simplifier ce que j'ai dit:

 git branch --all to get all branches

12
Alireza

Le clonage depuis un dépôt local ne fonctionnera pas avec git clone & git fetch: de nombreuses branches/balises resteront non récupérées.

Pour obtenir un clone avec toutes les branches et les tags.

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

Pour obtenir un clone avec toutes les branches et les tags, mais aussi avec une copie de travail:

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

Ces codes vont extraire tous les codes des branches distantes vers le dépôt local.

11
Albert.Qing

Pour copier-coller dans la ligne de commande:

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

Pour plus de lisibilité:

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


Cette volonté:

  1. check master (pour que nous puissions supprimer la branche sur laquelle nous nous trouvons)
  2. sélectionnez la télécommande pour passer à la caisse (changez-la pour votre télécommande)
  3. boucle dans toutes les branches de la télécommande sauf maître et HEAD
    1. delete branche locale (afin que nous puissions vérifier les branches mises à jour de force)
    2. check out branche de la télécommande
  4. check out master (pour le plaisir de le voir)

Basé sur réponse de VonC .

10
ikaruss

J'ai écrit cette petite fonction Powershell pour pouvoir extraire toutes mes branches git, qui se trouvent sur la télécommande Origin.

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>' #>
}

Vous trouverez plus de fonctions git sur mon rapport de paramètres git

8
gringo_dave

Je devais faire exactement la même chose. Voici mon 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

Généralement, lorsque Git (non spécifié) récupère toutes les branches et/ou les balises (réfs, voir: git ls-refs) dans un ou plusieurs autres référentiels ainsi que les objets nécessaires pour compléter leur historique. En d'autres termes, il récupère les objets accessibles par les objets déjà téléchargés. Voir: Que fait réellement git fetch?

Parfois, vous pouvez avoir des branches/étiquettes qui ne sont pas directement connectées à celle en cours, donc git pull --allgit fetch --all ne vous aidera pas dans ce cas, mais vous pouvez les lister par:

git ls-remote -h -t Origin

et aller les chercher manuellement en connaissant les noms des références.

Donc, pour _/aller les chercher tous, essayez:

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

Le paramètre --depth=10000 peut vous aider si vous avez réduit le référentiel.

Puis vérifiez à nouveau toutes vos branches:

git branch -avv

Si ci-dessus ne vous aide pas, vous devez ajouter manuellement les branches manquantes à la liste de suivi (car elles se sont égarées):

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

par git remote set-branches comme:

git remote set-branches --add Origin missing_branch

il peut donc apparaître sous remotes/Origin après la récupération:

$ 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

Dépannage

Si vous ne pouvez toujours pas obtenir autre chose que la branche principale, vérifiez les points suivants:

  • Vérifiez vos télécommandes (git remote -v), par exemple ..____.
    • Validez que git config branch.master.remote est Origin.
    • Vérifiez si Origin pointe vers la bonne URL via: git remote show Origin (voir this post ).
6
kenorb

A partir de début 2017, la réponse dans ce commentaire fonctionne:

git fetch <Origin-name> <branch-name> met la branche vers le bas pour vous. Bien que cela ne tire pas toutes les branches à la fois, vous pouvez exécuter cette opération individuellement.

6
ashes999

Aucune de ces réponses ne le coupe, sauf que l'utilisateur n'est sur la bonne voie.

J'avais des problèmes pour déplacer un dépôt d'un serveur/système à un autre. Lorsque j'ai cloné le référentiel, il n'a créé qu'une branche locale pour le maître. Ainsi, lorsque j'ai poussé vers la nouvelle télécommande, seule la branche principale a été poussée.

J'ai donc trouvé ces deux méthodes TRÈS utiles. J'espère qu'ils aident quelqu'un d'autre.

Méthode 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éthode 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

Voici une autre commande courte dans une ligne qui Crée des branches locales pour toutes les branches distantes:

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

Cela fonctionne aussi correctement si le suivi des branches locales est déjà créé . Vous pouvez l'appeler après le premier git clone ou à tout moment plus tard.

Si vous n'avez pas besoin d'avoir la branche master extraite après le clonage, utilisez 

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

Voici une réponse qui utilise awk. Cette méthode devrait suffire si elle est utilisée sur un nouveau référentiel.

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

Les branches existantes seront simplement extraites ou déclarées comme telles, mais des filtres peuvent être ajoutés pour éviter les conflits.

Il peut également être modifié pour appeler une commande explicite git checkout -b <branch> -t <remote>/<branch>.

Cette réponse suit Nikos C. 's idea .


Alternativement, nous pouvons spécifier la branche distante à la place. Ceci est basé sur murphytalkréponse .

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

Il jette des messages d'erreur fatale sur les conflits mais je les vois inoffensifs.


Les deux commandes peuvent être aliasées.

En utilisant nobody 's answer comme référence, nous pouvons avoir les commandes suivantes pour créer les alias:

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) }"'

Personnellement, j'utiliserais track-all ou track-all-branches.

4
konsolebox

git clone --mirror sur le dépôt d'origine fonctionne bien pour cela.

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

Je vais ajouter mes 2 centimes ici parce que je suis arrivé ici pour essayer de trouver comment supprimer une branche distante que j'avais supprimée localement. L'origine n'était pas la mienne, et je ne voulais pas traverser les tracas de tout re-cloner 

Cela a fonctionné pour moi:

en supposant que vous ayez besoin de recréer la branche localement:

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

Donc, si je passais de gituser/master à sjp puis que je le ramifiais à sjp/mynewbranch cela ressemblerait à ceci:

$ 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

Un peu tard pour la fête, mais je pense que cela fait l'affaire:

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

Si cela fait quelque chose de indésirable, j'aimerais bien le savoir. Cependant, jusqu'à présent, cela fonctionne pour moi.

0
Andy

Cette variante permet de cloner un dépôt distant avec toutes les branches disponibles localement sans avoir à extraire chaque branche une par une. Aucun script de fantaisie nécessaire.

Créez par exemple un dossier portant le même nom que celui du référentiel que vous souhaitez copier et cd:

mkdir somerepo
cd somerepo

Maintenant, faites ces commandes mais avec repo nom d'utilisateur/reponame 

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

Voiala! vous avez toutes les branches là-bas!

0
lacostenycoder

Voici un script bash pour récupérer toutes les branches et les balises d'un projet git sous forme d'instantanés dans des dossiers distincts. 

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

Peut-être pas ce qui a été demandé directement, mais certaines personnes pourraient venir ici pour chercher cette solution.

0
hfossli