web-dev-qa-db-fra.com

Suivre toutes les branches git distantes en tant que branches locales

Suivre une seule branche distante en tant que branche locale est assez simple. 

$ git checkout --track -b ${branch_name} Origin/${branch_name}

Il est également facile de placer toutes les branches locales sur la télécommande et de créer de nouvelles branches distantes en fonction des besoins.

$ git Push --all Origin

Je veux faire l'inverse. Si j'ai un nombre X de branches distantes d'une seule source: 

$ git branch -r 
branch1
branch2
branch3
.
.
.

Puis-je créer des branches de suivi locales pour toutes ces branches distantes sans avoir à les créer manuellement? Dites quelque chose comme:

$ git checkout --track -b --all Origin

J'ai googlé et RTM, mais je suis monté jusqu'à présent. 

gitbranch
151
Janson

La réponse donnée par Otto est bonne, mais toutes les branches créées auront "Origine /" comme début du nom. Si vous voulez juste que la dernière partie (après le dernier /) soit le nom de votre branche résultante, utilisez ceci:

for remote in `git branch -r | grep -v /HEAD`; do git checkout --track $remote ; done

Il a également l'avantage de ne pas vous avertir des arbitrages ambigus.

181
tjmcewan

Voici mon one-liner que j'utilise (dans un shell bash, testé avec msysgit1.7.4):

Pour copier-coller:

remote=Origin ; for brname in `git branch -r | grep $remote | grep -v master | grep -v HEAD | awk '{gsub(/^[^\/]+\//,"",$1); print $1}'`; do git branch --set-upstream-to $remote/$brname $brname; done

Pour plus de lisibilité:

remote=Origin ; // put here the name of the remote you want
for brname in `
    git branch -r | grep $remote | grep -v master | grep -v HEAD 
    | awk '{gsub(/^[^\/]+\//,"",$1); print $1}'
`; do 
    git branch --set-upstream-to $remote/$brname $brname; 
done
  • il ne sélectionnera que les branches en amont de la télécommande que vous spécifiez dans la variable remote (il peut s'agir de «Origin» ou du nom que vous avez défini pour l'une des télécommandes de votre référentiel Git actuel).
  • il extraira le nom de la branche: Origin/a/Branch/Name => a/Branch/Name via l'expression awk.

  • il va définir la branche en amont à travers --set-upstream-to (ou -u) , pas --track:
    L’avantage est que, si la branche existe déjà, elle n’échouera pas et elle ne changera pas l’origine de la branche, elle ne configurera que le paramètre branch.xxx.(remote|merge).

    branch.aBranchName.remote=Origin
branch.aBranchName.merge=refs/heads/a/Branch/Name

Cette commande créera des branches locales pour toutes les branches en amont distantes et définira leurs paramètres de fusion et de fusion sur cette branche distante.

21
VonC

La plupart des réponses ici compliquent excessivement l'analyse de la sortie de git branch -r. Vous pouvez utiliser la boucle for suivante pour créer les branches de suivi par rapport à toutes les branches de la télécommande.

Exemple

Dis que j'ai ces branches éloignées.

$ git branch -r
  Origin/HEAD -> Origin/master
  Origin/development
  Origin/integration
  Origin/master
  Origin/production
  Origin/staging

Confirmez que nous ne surveillons pas autre chose que le maître, localement:

$ git branch -l    # or using just git branch
* master

Vous pouvez utiliser ce support pour créer les branches de suivi:

$ for i in $(git branch -r | grep -vE "HEAD|master"); do 
    git branch --track ${i#*/} $i; done
Branch development set up to track remote branch development from Origin.
Branch integration set up to track remote branch integration from Origin.
Branch production set up to track remote branch production from Origin.
Branch staging set up to track remote branch staging from Origin.

Maintenant, confirmez:

$ git branch
  development
  integration
* master
  production
  staging

Pour les supprimer:

$ git br -D production development integration staging 
Deleted branch production (was xxxxx).
Deleted branch development (was xxxxx).
Deleted branch integration (was xxxxx).
Deleted branch staging (was xxxxx).

Si vous utilisez le commutateur -vv en git branch, vous pouvez confirmer:

$ git br -vv
  development xxxxx [Origin/development] commit log msg ....
  integration xxxxx [Origin/integration] commit log msg ....
* master      xxxxx [Origin/master] commit log msg ....
  production  xxxxx [Origin/production] commit log msg ....
  staging     xxxxx [Origin/staging] commit log msg ....

Ventilation de la boucle for

La boucle appelle essentiellement la commande git branch -r en filtrant any HEAD ou les branches principales de la sortie à l'aide de grep -vE "HEAD|master". Pour obtenir les noms des branches moins la sous-chaîne Origin/, nous utilisons la manipulation de chaîne de Bash ${var#stringtoremove}. Cela supprimera la chaîne "stringtoremove" de la variable $var. Dans notre cas, nous supprimons la chaîne Origin/ de la variable $i.

NOTE: Vous pouvez aussi utiliser git checkout --track ... pour le faire aussi:

$ for i in $(git branch -r | grep -vE "HEAD|master" | sed 's/^[ ]\+//'); do 
    git checkout --track $i; done

Mais cette méthode ne m’intéresse pas particulièrement, car elle vous permet de basculer d’une branche à l’autre en effectuant une commande. Une fois terminé, il vous laissera sur la dernière branche créée.

Références

19
slm

Vous pouvez écrire un script aussi facilement, mais je ne sais pas quand ce serait utile. Ces branches prendraient assez rapidement du retard et il faudrait les mettre à jour tout le temps.

Les branches distantes seront automatiquement mises à jour, il est donc plus simple de créer la branche locale à l'endroit où vous souhaitez réellement travailler.

12
Dustin
for i in `git branch -a | grep remote`; do git branch --track ${i#remotes/Origin/} $i; done
8
Val Blant

sans script (dans un répertoire vide):

$ git clone --bare repo_url .git
$ git config core.bare false
$ git checkout

après cela, toutes les branches distantes seront considérées comme locales.

original (en russe) .

6
alexander barakin

Si vous souhaitez utiliser Powershell et que votre télécommande s’appelle Origin. Alors ça marche.

git fetch    
git branch -r  | %{$_ -replace "  Origin/"} | %{git branch --track $_ "Origin/$_"}
4
BigMiner

Voici ma solution de commande BASH faisant référence à @tjmcewan:

for remote in `git branch -r | grep -v /HEAD `; do git branch --track ${remote/"Origin/"/""}; done

Mon objectif est de résoudre le problème selon lequel le nom commence par "Origin /" dans toutes les branches créées, car j'ai testé le fait que les variables distantes $ sont toujours incluses dans "Origin /":

for remote in `git branch -r | grep -v /HEAD`; do echo $remote ; done
3
Nick Tsai
for branch in `git branch -a | grep remotes | grep -v HEAD | grep -v master`; do  git branch --track ${branch##*/} $branch; done

Utilisez ceci et vous ne recevrez pas d'avertissement tel que: le nom de référence 'Origin/dev' est ambigu

3
bruziuz

Pour faire la même chose que la réponse de tjmcewan mais sous Windows, appelez ceci depuis un fichier batch:

for /f "delims=" %%r in ('git branch -r ^| grep -v master') do git checkout --track %%r

Ou ceci depuis la ligne de commande :

for /f "delims=" %r in ('git branch -r ^| grep -v master') do git checkout --track %r
2
Hugo

Si vous avez déjà des branches extraites et que vous voulez

  • vérifier toutes les branches restantes de la télécommande
  • assurez-vous que toutes les branches locales suivent les branches distantes

vous pouvez utiliser le script compatible bash et zsh suivant:

git branch -r | while read b; do if git branch | grep -q " ${b##*/}$"; then git branch --set-upstream ${b##*/} $b; else git branch --track ${b##*/} $b; fi; done
0
simonair

Utilisation de bash, Si vous souhaitez extraire toutes les branches:

for remote in `git branch -r`; do git checkout $(echo $remote | cut -d'/' -f 2); done

Il est important de noter que lorsque vous effectuez une extraction qui ramène de nouvelles branches de suivi à distance, vous n’en avez pas automatiquement des copies modifiables locales.

0
Jason Chen
for rembranch in `git remote update 2>&1 > /dev/null ; git branch -r|egrep -wv "HEAD|master"`
do 
    git checkout --track -b `echo $rembranch|awk -F\/ '{print $2}'` $rembranch; 
done

Explication:

ligne 1: 'git branch -r' (suivi de 'git remote update' pour mettre à jour les informations sur les modifications apportées à distance) répertorie toutes les branches distantes; 'egrep -vw' est utilisé pour assommer les entrées ayant HEAD et master dans le résultat.

ligne 3: Suivre la branche distante nommée tout en la récupérant localement. Un simple awk est utilisé pour éviter que 'Origine /' soit le suffixe des branches locales. 

0
ksvrgh