Что делает `git pull -all` на самом деле? [Дубликат]

Просто отправьте обновленный ответ. git-up больше не поддерживается, и если вы читаете документацию, они упоминают, что функциональность теперь доступна в git .

Начиная с Git 2.9, git pull - rebad -autostash делает в основном то же самое.

Соответственно, если вы обновляете Git 2.9 или новее, вы можете использовать этот псевдоним вместо установки git-up:

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

Вы также можете установить это для каждого git pull по Git 2.9 (спасибо @VonC, см. его ответ здесь )

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

Чтобы ответить на этот вопрос Мэттом Коннолли, это более безопасный способ обновить локальные ссылки, которые можно быстро перенаправить, не проверяя ветвь. Он не обновляет ветви, которые не могут быть быстро перенаправлены (т. Е. Расходились), и не обновляет ветвь, которая в настоящее время проверена (потому что тогда рабочая копия также должна быть обновлена).

git fetch

head="$(git symbolic-ref HEAD)"
git for-each-ref --format="%(refname) %(upstream)" refs/heads | while read ref up; do
    if [ -n "$up" -a "$ref" != "$head" ]; then
        mine="$(git rev-parse "$ref")"
        theirs="$(git rev-parse "$up")"
        base="$(git merge-base "$ref" "$up")"
        if [ "$mine" != "$theirs" -a "$mine" == "$base" ]; then
            git update-ref "$ref" "$theirs"
        fi
    fi
done

Вот хороший ответ: Как получить все ветви git

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

Это не так сложно автоматизировать:

#!/bin/sh
# Usage: fetchall.sh branch ...

set -x
git fetch --all
for branch in "$@"; do
    git checkout "$branch"      || exit 1
    git rebase "origin/$branch" || exit 1
done

Если refs / heads / master может быть быстро перенаправлен на refs / remotes / foo / master, вывод

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

должен вернуть идентификатор SHA1, который ссылается на / heads / master points. С этим вы можете собрать скрипт, который автоматически обновляет все локальные ветви, у которых не было никаких отвлекающих коммитов.

Этот маленький скрипт оболочки (я назвал его git-can-ff) иллюстрирует, как он может

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

Я использую подкоманду sync hub для автоматизации этого. Хаб псевдонимов как git, поэтому введите команду:

git sync

Это обновляет все локальные ветви, имеющие соответствующую ветку вверх по течению. На странице man:

• Если локальная ветка устарела, перетащите ее вперед,
• Если локальная ветка содержит непроверенную работу, предупредите об этом; / g4]
• Если ветка кажется объединенной, и ее ветвь восходящего потока была удалена, удалите ее.

Он также обрабатывает фиксированные / неработающие незафиксированные изменения в текущей ветке.

Я использовал подобный инструмент под названием git-up , но он больше не поддерживается, а git sync выполняет почти то же самое.

Это все еще не автоматическое, так как я хочу, чтобы была опция - и должна быть какая-то проверка, чтобы убедиться, что это может произойти только для быстрых обновлений (поэтому вручную делать притяжение намного безопаснее! !), но предостережения в стороне вы можете:

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

обновить позицию вашего локального отделения, не проверяя его.

Примечание: вы потеряете свою текущую ветку положение и перемещение его туда, где находится ветвь происхождения, а это означает, что если вам нужно слить, вы потеряете данные!

Здесь есть много приемлемых ответов, но некоторые из сантехники могут быть немного непрозрачными для непосвященных. Вот еще более простой пример, который можно легко настроить:

$ cat ~/bin/git/git-update-all
#!/bin/bash
# Update all local branches, checking out each branch in succession.
# Eventually returns to the original branch. Use "-n" for dry-run.
git_update_all() {
  local run br
  br=$(git name-rev --name-only HEAD 2>/dev/null)
  [ "$1" = "-n" ] && shift && run=echo

  for x in $( git branch | cut -c3- ) ; do
     $run git checkout $x && $run git pull --ff-only || return 2
  done

  [ ${#br} -gt 0 ] && $run git checkout "$br"
}

git_update_all "$@"

Если вы добавите ~/bin/git в свой PATH (при условии, что файл ~/bin/git/git-update-all), вы можете просто запустить:

$ git update-all

Добавьте этот скрипт в .profile в Mac OS X:

# Usage:
#   `git-pull-all` to pull all your local branches from origin
#   `git-pull-all remote` to pull all your local branches from a named remote

function git-pull-all() {
    START=$(git symbolic-ref --short -q HEAD);
    for branch in $(git branch | sed 's/^.//'); do
        git checkout $branch;
        git pull ${1:-origin} $branch || break;
    done;
    git checkout $START;
};

function git-push-all() {
    git push --all ${1:-origin};
};

Примечание. Несмотря на то, что я разместил собственное решение, я бы рекомендовал использовать git-up , что также является принятым ответом.

Я знаю, что этот вопрос почти 3 года, но я задал себе тот же вопрос и не нашел готового решения. Итак, я создал собственный скрипт командной оболочки git.

Здесь он идет, скрипт git-ffwd-update делает следующее ...

1. он выдает git remote update, чтобы получить значения lates revs
2. , затем использует git remote show, чтобы получить список локальных ветвей, отслеживающих удаленную ветвь (например, ветви, которые могут использоваться с git pull)
3. , затем он проверяет с помощью git rev-list --count <REMOTE_BRANCH>..<LOCAL_BRANCH>, сколько из них фиксирует локальную ветвь за пультом (и наоборот наоборот)
4. , если локальная ветвь 1 или более совершает движение вперед, она НЕ может быть переадресована и должна быть объединены или переустановлены вручную
5. , если локальная ветвь равна 0, и вперед 1 и более, она может быть быстро переадресована git branch -l -f <LOCAL_BRANCH> -t <REMOTE_BRANCH>

скрипт можно вызвать как:

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

Полный скрипт должен быть сохранен как git-ffwd-update и должен находиться на PATH.

#!/bin/bash

main() {
  REMOTES="$@";
  if [ -z "$REMOTES" ]; then
    REMOTES=$(git remote);
  fi
  REMOTES=$(echo "$REMOTES" | xargs -n1 echo)
  CLB=$(git branch -l|awk '/^\*/{print $2}');
  echo "$REMOTES" | while read REMOTE; do
    git remote update $REMOTE
    git remote show $REMOTE -n \
    | awk '/merges with remote/{print $5" "$1}' \
    | while read line; do
      RB=$(echo "$line"|cut -f1 -d" ");
      ARB="refs/remotes/$REMOTE/$RB";
      LB=$(echo "$line"|cut -f2 -d" ");
      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. reseting local branch to remote";
          git branch -l -f $LB -t $ARB >/dev/null;
        fi
      fi
    done
  done
}

main $@

Начиная с git 2.9:

git pull --rebase --autostash

См. https://git-scm.com/docs/git-rebase

Автоматически создавать временный тайник перед началом операции и применять его после завершения операции. Это означает, что вы можете запустить rebase на грязной worktree. Тем не менее, используйте с осторожностью: окончательное приложение с приложением после успешной перезагрузки может привести к нетривиальным конфликтам.

Сценарий, который я написал для моего GitBash . Выполняет следующее:

• По умолчанию тянет из источника для всех ветвей, которые настроены для отслеживания начала координат, позволяет при желании указать другой пульт.
• Если ваша текущая ветка находится в грязном состоянии, тогда он задерживает ваши изменения и попытается восстановить эти изменения в конце.
• Для каждой локальной ветви, которая настроена для отслеживания удаленной ветки, будет: git checkout branch git pull origin
• Наконец, вернем вас в исходное состояние ветви и восстановления.

** Я использую это, но не тестировал полностью, используйте на свой страх и риск. Пример этого скрипта в файле .bash_alias здесь .

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

Здесь много ответов, но никто не использует git-fetch для непосредственного обновления локального рефлекса, что намного проще, чем проверка ветвей, и более безопасная, чем git-update-ref.

Здесь мы используйте git-fetch для обновления не текущих ветвей и git pull --ff-only для текущей ветви. Это:

• Не требует проверки ветвей
• Обновляет ветви только в том случае, если они могут быть быстро переадресованы
• Будет сообщать, когда он не может fast-forward

, и вот он:

#!/bin/bash
currentbranchref="$(git symbolic-ref HEAD 2>&-)"
git branch -r | grep -v ' -> ' | while read remotebranch
do
    # Split <remote>/<branch> into remote and branchref parts
    remote="${remotebranch%%/*}"
    branchref="refs/heads/${remotebranch#*/}"

    if [ "$branchref" == "$currentbranchref" ]
    then
        echo "Updating current branch $branchref from $remote..."
        git pull --ff-only
    else
        echo "Updating non-current ref $branchref from $remote..."
        git fetch "$remote" "$branchref:$branchref"
    fi
done

Из справочной страницы для git-fetch:

   <refspec>
       The format of a <refspec> parameter is an optional plus +, followed by the source ref <src>,
       followed by a colon :, followed by the destination ref <dst>.

       The remote ref that matches <src> is fetched, and if <dst> is not empty string, the local ref
       that matches it is fast-forwarded using <src>. If the optional plus + is used, the local ref is
       updated even if it does not result in a fast-forward update.

Указывая git fetch <remote> <ref>:<ref> (без каких-либо +), мы получаем выборку, которая обновляет локальный рефер, только когда его можно быстро пересылать.

Примечание: это предполагает, что локальная и удаленная ветви называются одинаковыми (и что вы хотите отслеживать все ветви), он должен действительно использовать информацию о том, какие локальные филиалы у вас есть и что они настроены для отслеживания.