Suivre toutes les branches git distantes en tant que branches locales

Le suivi d'une seule branche distante en tant que branche locale est assez simple.

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

Pousser toutes les branches locales vers la télécommande, créer de nouvelles branches distantes selon les besoins est également facile.

$ git push --all origin

Je veux faire l'inverse. Si j'ai un nombre X de succursales distantes à 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 des RTM, mais je suis venu jusqu'à présent.

Utilisation de bash:

for i in `git branch -a | grep remote | grep -v HEAD | grep -v master`; do git branch --track ${i#remotes/origin/} $i; done

crédits: Val Blant, elias et Hugo

Remarque: le code suivant s'il est utilisé dans les versions ultérieures de git (> v1.9.1) provoque

1. (bug) Toutes les branches créées pour suivre le master
2. (ennui) Tous les noms de succursales locales créés doivent être préfixés avec origin/

for remote in `git branch -r `; do git branch --track $remote; done

Mettez à jour les succursales, en supposant qu'il n'y a pas de changements sur vos succursales de suivi locales:

for remote in `git branch -r `; do git checkout $remote ; git pull; done

Ignorez les avertissements ambigus de refname, git semble préférer la branche locale comme il se doit.

La réponse d'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 vos noms de branche résultants, utilisez ceci:

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

Il a également l'avantage de ne vous donner aucun avertissement sur les références ambiguës.

La plupart des réponses ici compliquent trop l'analyse de la sortie de git branch -r. Vous pouvez utiliser la forboucle suivante pour créer les branches de suivi contre toutes les branches de la télécommande comme ceci.

Exemple

Disons que j'ai ces succursales éloignées.

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

Confirmez que nous ne suivons déjà rien d'autre que le maître, localement:

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

Vous pouvez utiliser cette seule ligne 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 -vvcommutateur pour, git branchvous 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 ....

Répartition de la boucle for

La boucle appelle essentiellement la commande git branch -r, filtrant toutes les branches HEAD ou master dans la sortie en utilisant grep -vE "HEAD|master". Pour obtenir les noms des seules branches moins la origin/sous - chaîne, 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.

REMARQUE: vous pouvez également utiliser git checkout --track ...pour faire ceci:

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

Mais je ne me soucie pas particulièrement de cette méthode, car elle vous permet de basculer entre les branches lors de la vérification. Une fois terminé, il vous laissera sur la dernière branche créée.

Références

• 10.1. Manipulation de chaînes - Guide de création de scripts Bash avancés
• 3.5 Git Branching - Branches distantes

Mise à jour Q1 2020: Mohsen Abasi propose dans les commentaires , sur la base des 2014 slm de réponse , l'alternative plus simple:

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

Et il utilise à la $()place des backticks obsolètes .

Comme je l'ai mentionné dans une autre vieille réponse , l'utilisation git for-each-refest probablement plus rapide .
Et j'utiliser la nouvelle (Git 2.23+) git switchcommande , qui remplace la confusiongit checkout .

for i in $(git for-each-ref --format=%(refname:short) \
  --no-merged=origin/HEAD refs/remotes/origin); do \
    git switch --track $i; \
done

De cette façon, pas grepnécessaire.

Ancienne réponse originale (2011):

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 remotevariable (cela peut être ' origin' ou le nom que vous avez défini pour l'une des télécommandes de votre dépôt Git actuel).
• il va extraire le nom de la branche: origin/a/Branch/Name => a/Branch/Namevia l' awkexpression.

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

  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 leur paramètre distant et de fusion sur cette branche distante.

Vous pourriez écrire cela assez facilement, mais je ne sais pas quand cela serait utile. Ces succursales prendraient assez rapidement du retard et vous deviez les mettre à jour tout le temps.

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

for i in `git branch -a | grep remote`; do git branch --track ${i#remotes/origin/} $i; done

sans aucun script (dans un répertoire vide):

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

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

original (en russe) .

Si vous souhaitez utiliser PowerShell et que votre télécommande s'appelle origin. Ensuite, cela fonctionne.

git fetch    
git branch -r  | %{$_ -replace "  origin/"} | %{git branch --track $_ "origin/$_"}

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 n'aurez pas d'avertissement tel que: refname 'origin / dev' est ambigu

Voici ma solution de la commande BASH faisant référence par @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 que toutes les branches créées auront "origin /" comme début du nom, car j'ai testé que $ variables distantes incluent toujours "origin /":

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

Pour faire la même chose que la réponse de tjmcewan mais sous Windows, appelez ceci à partir d'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

À partir de git 2.23:

for branch in `git branch -r | grep origin/`; do git switch -t -C ${branch#origin/} $branch; git pull; done

L' -Cindicateur de git switchcréation ou de réinitialisation s'il existe déjà.

documentation du commutateur git

Dans le cas où vous avez déjà vérifié certaines branches et que vous souhaitez

• vérifiez toutes les branches restantes de la télécommande
• assurez-vous que toutes les succursales locales suivent les succursales 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

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 à remote) répertorie toutes les branches distantes; «egrep -vw» est utilisé pour frapper les entrées ayant HEAD et master dans le résultat.

ligne 3: suivez la branche distante nommée tout en la récupérant localement. Un simple awk est utilisé pour éviter que «origin /» ne soit le suffixe des branches locales.

En utilisant bash, si vous souhaitez vérifier 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 fait tomber de nouvelles branches de suivi à distance, vous n'en avez pas automatiquement de copies locales modifiables.