Comment cloner toutes les branches distantes dans Git?

J'ai un masteret une developmentbranche, tous deux poussés vers GitHub . J'ai cloned, pulled et fetched, mais je ne peux rien récupérer d'autre que la masterbranche.

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

Tout d'abord, clonez un référentiel Git distant et un CD dedans:

$ 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 qui se cachent dans votre référentiel! Vous pouvez les voir en utilisant le -adrapeau:

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

Si vous voulez simplement jeter un coup d'œil à une succursale en amont, vous pouvez le vérifier directement:

$ git checkout origin/experimental

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

$ 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 jette quelques personnes: "Nouvelle branche" - hein? Ce que cela signifie vraiment, c'est que la branche est extraite de l'index et créée localement pour vous. La ligne précédente est en fait 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_branche

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

$ git branch
* experimental
  master

Vous pouvez effectivement 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 courez gitkpour voir ce qui se passe:

$ gitk --all &

Si vous souhaitez récupérer simultanément plusieurs branches distantes, procédez comme suit:

$ git pull --all

Vous pouvez maintenant extraire n'importe quelle branche selon vos besoins, sans toucher au référentiel distant.

Ce script Bash m'a aidé:

#!/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 master (que vous avez probablement obtenu à partir de la commande de clonage d'origine). Je pense que vous devrez peut-être encore

git fetch --all
git pull --all

ê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 votre configuration avant de copier l'univers rm -rf tel que nous le connaissons

Les crédits pour un aller simple vont à l'utilisateur cfi

L'utilisation de l' --mirroroption semble copier remotecorrectement les branches de suivi. Cependant, il définit le référentiel comme un référentiel nu, vous devez donc le reconvertir en référentiel normal par la suite.

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?}

Vous pouvez facilement passer à une branche sans utiliser la syntaxe fantaisie "git checkout -b somebranch origin / somebranch". Vous pouvez simplement faire:

git checkout somebranch

Git fera automatiquement la bonne chose:

$ 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 avec le même nom existe dans exactement une télécommande, et si c'est le cas, il la suit de la même manière que si vous aviez explicitement spécifié qu'il s'agit d'une branche distante. Depuis la page de manuel git-checkout de Git 1.8.2.1:

Si <branch> 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 comme équivalent à

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

En ce qui concerne,

$ git checkout -b origine expérimentale / expérimental

en utilisant

$ git checkout -t origin/experimental

ou le plus verbeux mais plus facile à retenir

$ git checkout --track origin/experimental

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

L'extraction que vous faites devrait obtenir toutes les branches distantes, mais elle 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, faites quelque chose comme:

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

Qui devrait renvoyer quelque chose comme:

Configuration de la branche configurée pour suivre les références / télécommandes de branche distante / origine / dev.
Passé à une nouvelle branche "dev"

Maintenant, lorsque vous êtes sur la branche de développement, "git pull" mettra à jour votre développeur local au même point que la branche de développement distante. Notez qu'il récupérera toutes les branches, mais tirez uniquement celle sur laquelle vous vous trouvez au sommet de l'arbre.

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

Afin de travailler au-dessus d'une branche distante spécifique, en supposant que c'est la télécommande d'origine:

git checkout -b branch origin/branchname

Utilisez des alias. Bien qu'il n'y ait pas de lignes natives Git, vous pouvez définir les vôtres comme

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

puis l'utiliser comme

git clone-branches

Pourquoi vous ne voyez que "maître"

git clonetélécharge toutes les branches distantes mais les considère toujours comme "distantes", même si les fichiers se trouvent dans votre nouveau référentiel. Il y a une exception à cela, c'est que le processus de clonage crée une branche locale appelée "master" à partir de la branche distante appelée "master". Par défaut, git branchne montre que les branches locales, c'est pourquoi vous ne voyez que "master".

git branch -aaffiche toutes les branches, y compris les branches distantes .

Comment obtenir des succursales locales

Si vous voulez réellement travailler sur une branche, vous en voudrez probablement une version "locale". Pour créer simplement des branches locales à partir de branches distantes (sans les extraire et donc changer 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, branchoneest le nom d'une branche locale sur laquelle vous créez origin/branchone; si vous souhaitez 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, vous n'avez pas besoin -ade voir les branches locales).

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

git fetch origin Cela apportera toutes les succursales distantes à votre section locale.

git branch -a Cela 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 par la commande suivante;

git branch

La sortie sera comme ça;

*your current branch 
some branch2
some branch3 

Remarquez le signe * qui indique la branche actuelle.

Mieux vaut tard que jamais, mais voici la meilleure façon de procéder:

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 --mirrorau lieu de --baresi votre dépôt à distance a ses propres télécommandes.

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 extraire, puis votre branche locale sera créée.

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

git clone <your_http_url>

Même si vous ne voyez que la branche principale, 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 "git clone", vous n'avez pas besoin de vous connecter avec le dépôt à distance, "git branch -a" et "git checkout" peuvent être exécutés avec succès lorsque vous fermez votre 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 dépôt à distance, votre section locale a déjà tous les codes des succursales.

A git cloneest censé copier l'intégralité du référentiel. Essayez de le cloner, puis exécutez git branch -a. Il doit répertorier toutes les branches. Si vous souhaitez ensuite passer à la branche "foo" au lieu de "master", utilisez git checkout foo.

Utilisez mon outil git_remote_branch (vous devez installer Ruby sur votre machine). Il est spécialement conçu pour simplifier les manipulations de succursales à distance.

Chaque fois qu'il effectue une opération en votre nom, il l'imprime en rouge sur la console. Au fil du temps, ils restent finalement 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 d' un logiciel alpha ;-)

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

git_remote_branch version 0.2.6

  Usage:

  grb create nom_branche [serveur_origine] 

  grb publish nom_branche [serveur_origine] 

  grb renommer branch_name [serveur_origine] 

  grb delete nom_branche [serveur_origine] 

  grb track nom_branche [serveur_origine] 



  Remarques:
  - Si origin_server n'est pas spécifié, le nom 'origin' est supposé 
    (par défaut de git)
  - La fonctionnalité renommer renomme la branche courante

  La méta-commande d'explication: vous pouvez également ajouter n'importe quelle commande 
mot-clé «expliquer». Au lieu d'exécuter la commande, git_remote_branch
affichera simplement la liste des commandes que vous devez exécuter pour accomplir 
cet objectif.

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

  Toutes les commandes ont également des alias:
  créer: créer, nouveau
  supprimer: supprimer, détruire, tuer, supprimer, rm
  publier: publier, remotiser
  renommer: renommer, rn, mv, déplacer
  suivre: suivre, suivre, saisir, récupérer

toutes les réponses que j'ai vues ici sont valables mais il existe un moyen beaucoup plus propre 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 réellement téléchargées mais les branches sont masquées. Avec 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 par un.

Cependant, lorsque vous voulez cloner un dépôt avec beaucoup de branches, toutes les façons illustrées ci-dessus sont longues et fastidieuses en ce qui concerne une manière beaucoup plus propre et plus rapide que je vais montrer, bien que ce soit un peu compliqué. Pour ce faire, vous avez besoin de trois étapes:

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 dépôt local à l'intérieur du dossier my_repo_folder est toujours vide, il y a juste un dossier .git caché que vous pouvez voir avec une commande "ls -alt" du terminal.

2. Deuxième étape

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

$ git config --bool core.bare false

3. Troisième étape

Saisissez tout ce qui se trouve dans le dossier actuel et créez toutes les branches sur la machine locale, ce qui en fait un repo normal.

$ git reset --hard

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

C'est la manière rapide dont 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 façon.

Le clonage à partir d'un référentiel 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 balises.

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

Pour obtenir un clone avec toutes les branches et balises 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

OK, quand vous clonez votre repo, vous avez toutes les succursales là-bas ...

Si vous le faites git branch, ils sont un peu cachés ...

Donc, si vous souhaitez voir le nom de toutes les branches, ajoutez simplement un --allindicateur comme celui-ci:

git branch --all ou git branch -a

Si vous venez de commander à la succursale, vous obtenez tout ce dont vous avez besoin.

Mais que diriez-vous si la branche créée par quelqu'un d'autre après votre clonage?

Dans ce cas, faites simplement:

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

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

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

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

Mais attention, si l'une des branches distantes est nommée par exemple admin_master, elle ne sera pas téléchargée!

Merci à bigfish pour l'idée originale

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

Ce code tirera tous les codes de succursales distantes vers le référentiel local.

Pour copier-coller en 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

1. consultez master (afin que nous puissions supprimer la branche sur laquelle nous sommes)
2. sélectionnez la télécommande à commander (remplacez-la par la télécommande que vous possédez)
3. boucle à travers toutes les branches de la télécommande sauf master et HEAD
   1. supprimer la branche locale (afin que nous puissions vérifier les branches mises à jour de force)
   2. vérifier la branche de la télécommande
4. consultez le maître (pour le plaisir)

Basé sur la réponse de VonC .

J'ai écrit ces petites fonctions Powershell pour pouvoir vérifier toutes mes branches git, qui sont à distance d'origine.

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

Plus de fonctions git peuvent être trouvées sur mon dépôt de paramètres git

Voici une réponse qui utilise awk. Cette méthode devrait suffire si elle est utilisée sur un nouveau dépôt.

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

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

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

Cette réponse fait suite à Nikos C. l » idée .

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

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

Il lance des messages d'erreur fatals sur les conflits mais je les vois inoffensifs.

Les deux commandes peuvent être aliasées.

L' utilisation personne de » réponse 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-allou track-all-branches.

J'avais besoin de faire exactement la même chose. Voici mon script Ruby .

#!/usr/bin/env ruby

local = []
remote = {}

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

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

J'avais du mal à déplacer un dépôt d'un serveur / système à un autre. Lorsque j'ai cloné le référentiel, cela n'a créé qu'une branche locale pour le maître, donc 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

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

Git récupère généralement (lorsqu'il n'est pas spécifié) toutes les branches et / ou balises (réfs, voir:) git ls-refsd'un ou plusieurs autres référentiels avec les objets nécessaires pour compléter leurs historiques. En d'autres termes, il récupère les objets accessibles par les objets déjà téléchargés. Voir: Que fait git fetchvraiment?

Parfois, vous pouvez avoir des branches / balises qui ne sont pas directement connectées à la branche actuelle, donc git pull --all/ git fetch --alln'aidera pas dans ce cas, mais vous pouvez les répertorier en:

git ls-remote -h -t origin

et les récupérer manuellement en connaissant les noms de référence.

Donc, pour les récupérer tous , essayez:

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

^{Le --depth=10000paramètre peut aider si vous avez un référentiel superficiel.}

Vérifiez à nouveau toutes vos succursales:

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 perdues d'une manière ou d'une autre):

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

par git remote set-branchescomme:

git remote set-branches --add origin missing_branch

il peut donc apparaître sous remotes/originaprè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
  • Valider qui git config branch.master.remoteest origin.
  • Vérifiez s'il originpointe vers la bonne URL via: git remote show origin(voir cet article ).

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

git fetch <origin-name> <branch-name>fait descendre la branche pour vous. Bien que cela ne tire pas toutes les branches à la fois, vous pouvez exécuter cette branche par branche.

Voici une autre commande courte à 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 également correctement si le suivi des branches locales est déjà créé. Vous pouvez l'appeler après la première fois git cloneou à tout moment plus tard.

Si vous n'avez pas besoin de mastervérifier la branche après le clonage, utilisez

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