Peut “git pull --tous les” mettre à jour tous mes branches locales?

Le comportement que vous décrivez pour pull --all est exactement comme prévu, mais pas forcément utile. L'option est passée à git fetch, qui extrait toutes les références de toutes les télécommandes, au lieu d'un seul; pull fusionne (ou dans votre cas, rebases) la seule branche.

Si vous souhaitez consulter d'autres branches, vous allez avoir à le consulter. Et oui, la fusion (et complet) absolument exiger un arbre, de sorte qu'ils ne peuvent pas être fait sans vérifier les autres branches. Vous pouvez rassembler vos décrit les étapes à un script/alias si vous le souhaitez, mais je vous suggère de rejoindre les commandes avec && de sorte que si l'un d'eux échoue, il ne sera pas essayer de labourer le.

Je sais que cette question est de presque 3 ans, mais je me suis posé la même question et n'a pas trouvé tout prêt de solution toute faite. Donc, j'ai créé une coutume commande git script shell mon auto.

Ici ça va, la git-ffwd-update script effectue les opérations suivantes...

1. un git remote update pour aller chercher le lates régime
2. utilise ensuite git remote show pour obtenir une liste des succursales locales de la piste une branche distante (par exemple les agences qui peuvent être utilisés avec git pull)
3. elle vérifie ensuite avec git rev-list --count <REMOTE_BRANCH>..<LOCAL_BRANCH> combien d'engager la succursale locale est derrière la télécommande (à l'avance et vice versa)
4. si la branche locale est de 1 ou plus s'engage à l'avance, il peut PAS être avancé rapidement et a besoin d'être fusionné ou relocalisée à la main
5. si la branche locale est 0 s'engage à l'avance et 1 ou plus s'engage derrière, il peut être rapidement acheminés par git branch -f <LOCAL_BRANCH> -t <REMOTE_BRANCH>

le script peut être appelé comme:

$ git ffwd-update
Fetching origin
 branch bigcouch was 10 commit(s) behind of origin/bigcouch. resetting local branch to remote
 branch develop was 3 commit(s) behind of origin/develop. resetting local branch to remote
 branch master is 6 commit(s) behind and 1 commit(s) ahead of origin/master. could not be fast-forwarded

Le script complet, doit être enregistré comme git-ffwd-update et doit être sur la PATH.

#!/bin/bash

main() {
  REMOTES="$@";
  if [ -z "$REMOTES" ]; then
    REMOTES=$(git remote);
  fi
  REMOTES=$(echo "$REMOTES" | xargs -n1 echo)
  CLB=$(git rev-parse --abbrev-ref HEAD);
  echo "$REMOTES" | while read REMOTE; do
    git remote update $REMOTE
    git remote show $REMOTE -n \
    | awk '/merges with remote/{print $5" "$1}' \
    | while read RB LB; do
      ARB="refs/remotes/$REMOTE/$RB";
      ALB="refs/heads/$LB";
      NBEHIND=$(( $(git rev-list --count $ALB..$ARB 2>/dev/null) +0));
      NAHEAD=$(( $(git rev-list --count $ARB..$ALB 2>/dev/null) +0));
      if [ "$NBEHIND" -gt 0 ]; then
        if [ "$NAHEAD" -gt 0 ]; then
          echo " branch $LB is $NBEHIND commit(s) behind and $NAHEAD commit(s) ahead of $REMOTE/$RB. could not be fast-forwarded";
        elif [ "$LB" = "$CLB" ]; then
          echo " branch $LB was $NBEHIND commit(s) behind of $REMOTE/$RB. fast-forward merge";
          git merge -q $ARB;
        else
          echo " branch $LB was $NBEHIND commit(s) behind of $REMOTE/$RB. resetting local branch to remote";
          git branch -f $LB -t $ARB >/dev/null;
        fi
      fi
    done
  done
}

main $@

Ce n'est toujours pas automatique, et que je souhaite qu'il y avait une option pour - et il devrait y avoir des contrôles pour s'assurer que cela ne peut se faire pour avancer rapidement les mises à jour (c'est pourquoi manuellement en faisant un pull est beaucoup plus sûr!!), mais les mises en garde de côté, vous pouvez:

git fetch origin
git update-ref refs/heads/other-branch origin/other-branch

pour mettre à jour la position de votre branche locale sans avoir à le vérifier.

Remarque: vous fera perdre votre actuelle direction de la position et de la déplacer à l'endroit où l'origine de la branche est, ce qui signifie que si vous avez besoin de fusionner, vous risquez de perdre des données!

Ce problème n'est pas résolu (encore), au moins pas facilement /sans script: voir ce post sur git liste de diffusion par Junio C Hamano expliquant la situation et de fournir d'appel pour une solution simple.

La majeure du raisonnement, c'est que vous ne devriez pas en avoir besoin:

Avec git qui n'est pas ancienne (c'est à dire v1.5.0 ou plus récent), il n'y a pas de raison de
locaux "dev" que purement piste à la distance de plus. Si vous ne voulez
aller-chercher-et-voir, vous pouvez consulter le suivi à distance directement la direction
d'un décollement de la TÊTE avec de la "git checkout origin/dev".

Ce qui signifie que le seul cas, nous avons besoin de rendre plus pratique pour les utilisateurs
sont à manipuler ces branches locales que la "voie" à distance lorsque vous n'
avoir des modifications locales, ou lorsque vous prévoyez d'en avoir.

Si vous avez des modifications locales "dev" qui est marqué pour suivre le supprimer
les "dev", et si vous êtes sur une branche différente de "dev", alors nous ne devrions pas
faire quelque chose après "git fetch" mises à jour du suivi à distance "dev". Il
n'aurez pas d'avance rapide, de toute façon

L'appel pour une solution a été d'une option ou d'un script externe pour pruneau branches locales qui suivent maintenant à distance-suivi des branches, plutôt que de les garder à jour par l'avance rapide, comme l'original de l'affiche de la demande.

Alors, comment au sujet de "git branch --prune --remote=<upstream>" qui effectue une itération sur
les branches locales, et si

(1) il n'est pas la branche courante; et

(2) il est marqué pour suivre une des branches prises à partir de la <en amont>; et

(3) il ne dispose d'aucun s'engage sur son propre;

puis supprimer cette branche? "git remote --prune-local-forks <upstream>" est
aussi, très bien; je ne se soucient pas de la commande qui implémente la fonctionnalité que
beaucoup.

Remarque: de git 2.10 absence d'une telle solution existe. Notez que le git remote prune sous-commande, et git fetch --prune sont sur la suppression à distance de suivi de la succursale de la direction générale qui n'existe plus sur la télécommande, et non pas sur la suppression de la succursale locale qui assure le suivi à distance de suivi de branche (pour lequel la distance de suivi de la branche est en amont de la branche).

Ici est une bonne réponse: Comment récupérer toutes les branches git

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

Un script que j'ai écrit pour mon GitBash. Accomplit les tâches suivantes:

• Par défaut tire d'origine pour toutes les branches qui sont de l'installation de la piste d'origine, vous permet de spécifier un autre à distance si vous le souhaitez.
• Si votre branche courante est dans un sale état alors il vous permet de ranger votre vos modifications et va tenter de rétablir ces changements à la fin.
• Pour chaque branche locale qui est mis en place pour suivre une branche distante sera:
  • git checkout branch
  • git pull origin
• Enfin, vous permettra de revenir à l'original de votre branche et de la restauration de l'état.

** J'utilise ce mais ne l'ai pas testé à fond, de l'utiliser à vos propres risques. Voir un exemple de ce script dans un .bash_alias fichier ici.

    # Do a pull on all branches that are tracking a remote branches, will from origin by default.
    # If current branch is dirty, will stash changes and reply after pull.
    # Usage: pullall [remoteName]
    alias pullall=pullAll
    function pullAll (){
     # if -h then show help
     if [[ $1 == '-h' ]]
    then
      echo "Description: Pulls new changes from upstream on all branches that are tracking remotes."
      echo 
      echo "Usage: "
      echo "- Default: pullall"
      echo "- Specify upstream to pull from: pullall [upstreamName]"
      echo "- Help: pull-all -h"
    else

     # default remote to origin
     remote="origin"
     if [ $1 != "" ]
     then
       remote=$1
     fi

     # list all branches that are tracking remote
     # git branch -vv : list branches with their upstreams
     # grep origin : keep only items that have upstream of origin
     # sed "s/^.."... : remove leading *
     # sed "s/^"..... : remove leading white spaces
     # cut -d" "..... : cut on spaces, take first item
     # cut -d splits on space, -f1 grabs first item
     branches=($(git branch -vv | grep $remote | sed "s/^[ *]*//" | sed "s/^[ /t]*//" | cut -d" " -f1))

     # get starting branch name
     startingBranch=$(git rev-parse --abbrev-ref HEAD)

     # get starting stash size
     startingStashSize=$(git stash list | wc -l)

     echo "Saving starting branch state: $startingBranch"
     git stash

     # get the new stash size
     newStashSize=$(git stash list | wc -l)

     # for each branch in the array of remote tracking branches
     for branch in ${branches[*]}
     do
       echo "Switching to $branch"
       git checkout $branch

       echo "Pulling $remote"
       git pull $remote

     done

     echo "Switching back to $startingBranch"
     git checkout $startingBranch

     # compare before and after stash size to see if anything was stashed
     if [ "$startingStashSize" -lt "$newStashSize" ]
     then
       echo "Restoring branch state"
       git stash pop
     fi
    fi
    }

Simplement poster une mise à jour de réponse. git-up n'est plus maintenu et si vous lisez la documentation, ils parler de la fonctionnalité est maintenant disponible dans git.

De Git 2.9, git pull --rebase --autostash fait la même chose.

En conséquence, si vous mettez à jour vers Git 2.9 ou version ultérieure, vous pouvez utiliser cet alias au lieu d'installer git-up:

git config --global alias.up 'pull --rebase --autostash'

Vous pouvez également définir pour chaque git pull de Git 2.9 ainsi (merci @VonC veuillez voir sa réponse ici)

git config --global pull.rebase true
git config --global rebase.autoStash true

Si refs/heads/master peut être rapidement acheminés vers refs/remotes/foo/master, la sortie de

git merge-base refs/heads/master refs/remotes/foo/master

doit retourner le SHA1 id refs/heads/master points. Avec cela, vous pouvez mettre en place un script qui met à jour automatiquement toutes les branches locales qui n'ont pas eu de détourner s'engage à eux.

Ce petit script shell (je l'ai appelé git-peut-ff) illustre la façon dont il peut être fait.

#!/bin/sh

set -x

usage() {
    echo "usage: $(basename $0) <from-ref> <to-ref>" >&2
    exit 2
}

[ $# -ne 2 ] && usage

FROM_REF=$1
TO_REF=$2

FROM_HASH=$(git show-ref --hash $FROM_REF)
TO_HASH=$(git show-ref --hash $TO_REF)
BASE_HASH=$(git merge-base $FROM_REF $TO_REF)

if [ "$BASE_HASH" = "$FROM_HASH" -o \
     "$BASE_HASH" = "$FROM_REF" ]; then
    exit 0
else
    exit 1
fi

Légèrement différente de script uniquement pour avancer rapidement les branches dont le nom correspond à leur amont de la branche. Il met également à jour la branche courante si rapide est possible.

Assurez-vous que tous vos branches en amont, les branches sont définies correctement en exécutant git branch -vv. Définir en amont de la direction, avec git branch -u origin/yourbanchname

Copier-coller dans un fichier et la commande chmod 755:

#!/bin/sh

curbranch=$(git rev-parse --abbrev-ref HEAD)

for branch in $(git for-each-ref refs/heads --format="%(refname:short)"); do
        upbranch=$(git config --get branch.$branch.merge | sed 's:refs/heads/::');
        if [ "$branch" = "$upbranch" ]; then
                if [ "$branch" = "$curbranch" ]; then
                        echo Fast forwarding current branch $curbranch
                        git merge --ff-only origin/$upbranch
                else
                        echo Fast forwarding $branch with origin/$upbranch
                        git fetch . origin/$upbranch:$branch
                fi
        fi
done;

Il ressemble à beaucoup d'autres ont contribué à des solutions, mais je pensais que je voudrais partager ce que j'ai trouvé et inviter d'autres personnes à contribuer. Cette solution est colorée belle sortie, gracieusement les poignées de votre répertoire de travail courant, et est rapide car il ne fait pas des caisses, et laisse votre répertoire de travail dans le tact. Aussi, il est juste un script shell avec pas de dépendance, autres que git. (testé uniquement sur OSX jusqu'à présent)

#!/usr/bin/env bash

gitup(){    
RED='3[33;31m'
YELLO='3[33;33m'
GREEN='3[33;32m'
NC='3[0m' # No Color

HEAD=$(git rev-parse HEAD)
CHANGED=$(git status --porcelain | wc -l)

echo "Fetching..."
git fetch --all --prune &>/dev/null
for branch in `git for-each-ref --format='%(refname:short)' refs/heads`; do

    LOCAL=$(git rev-parse --quiet --verify $branch)
    if [ "$HEAD" = "$LOCAL" ] && [ $CHANGED -gt 0 ]; then
        echo -e "${YELLO}WORKING${NC}\t\t$branch"
    elif git rev-parse --verify --quiet $branch@{u}&>/dev/null; then
        REMOTE=$(git rev-parse --quiet --verify $branch@{u})
        BASE=$(git merge-base $branch $branch@{u})

        if [ "$LOCAL" = "$REMOTE" ]; then
           echo -e "${GREEN}OK${NC}\t\t$branch" 
        elif [ "$LOCAL" = "$BASE" ]; then
            if [ "$HEAD" = "$LOCAL" ]; then
                git merge $REMOTE&>/dev/null
            else
                git branch -f $branch $REMOTE
            fi
            echo -e "${GREEN}UPDATED${NC}\t\t$branch"
        elif [ "$REMOTE" = "$BASE" ]; then
            echo -e "${RED}AHEAD${NC}\t\t$branch"
        else
            echo -e "${RED}DIVERGED${NC}\t\t$branch"
        fi
    else
        echo -e "${RED}NO REMOTE${NC}\t$branch"
    fi
done
}

https://github.com/davestimpert/gitup

Désolé j'semblent également venir avec le même nom que l'autre outil ci-dessus.

La suite de one-liner pour avancer rapidement toutes les branches qui ont en amont de la branche, si possible, et imprime une erreur dans le cas contraire:

git branch \
  --format "%(if)%(upstream:short)%(then)git push . %(upstream:short):%(refname:short)%(end)" |
  sh

Comment ça fonctionne?

Il utilise un format personnalisé avec le git branch de commande. Pour chaque branche il y a un amont de la branche, il affiche une ligne avec le motif suivant:

git push . <remote-ref>:<branch>

Ce peut être joué directement dans sh (en supposant que les noms de branche sont bien formées). Omettre le | sh pour voir ce qu'il fait.

Mises en garde

Le one-liner sera pas en contact avec vos télécommandes. Question un git fetch ou git fetch --all avant de l'exécuter.

Actuellement extrait de la branche ne sera pas mis à jour avec un message comme

! [remote rejected] origin/master -> master (branch is currently checked out)

Pour cela, vous pouvez recourir à la régulière git pull --ff-only .

Alias

Ajouter les éléments suivants à votre .gitconfig de sorte que git fft exécute cette commande:

[alias]
        fft = !sh -c 'git branch --format \"%(if)%(upstream:short)%(then)git push . %(upstream:short):%(refname:short)%(end)\" | sh' -

Voir aussi mes .gitconfig. L'alias est une abréviation pour "fast-forward de suivi (branches)".

De git 2.9:

git pull --rebase --autostash

Voir https://git-scm.com/docs/git-rebase

Créer automatiquement une cachette temporaire avant le début de l'opération,
et de l'appliquer après la fin des opérations. Cela signifie que vous pouvez l'exécuter
rebase sur un sale worktree. Toutefois, à utiliser avec précaution: la finale de la cachette
application après le succès d'un rebase pourrait entraîner la non-trivial
les conflits.