“git pull --all”可以更新我所有的本地分支吗？

Question

我经常有至少 3 个远程分支：master、staging 和 production。我有 3 个本地分支跟踪这些远程分支。

更新我所有的本地分支很乏味：

git fetch --all
git rebase origin/master
git checkout staging
git rebase origin/staging
git checkout production
git rebase origin/production

我很想能够做一个“git pull -all”，但我无法让它工作。它似乎做了一个“fetch --all”，然后更新（快进或合并）当前工作分支，而不是其他本地分支。

我仍然无法手动切换到每个本地分支并进行更新。

Answer 1

不知道这是否好的，但如果我想快进多个分支，我通常会调用

git pull origin master staging production

另外，如果我想推送多个分支，我会打电话

git push origin master staging production

但只有在所有提到的分支都不需要任何类型的合并时，两者才有效。

Answer 2

你不能只用一个 git 命令来完成它，但你可以用一个 bash 行来自动化它。

为了安全地用一行更新所有分支，我这样做：

git fetch --all && for branch in $(git branch | sed '/*/{$q;h;d};$G' | tr -d '*') ; do git checkout $branch && git merge --ff-only || break ; done

• 如果它不能快进一个分支或遇到错误，它将停止并将您留在该分支中，以便您可以收回控制权并手动合并。

• 如果所有分支都可以快进，它将以您当前所在的分支结束，让您留在更新前的位置。

解释：

为了更好的可读性，它可以分成几行：

git fetch --all && \
for branch in $(git branch | sed '/*/{$q;h;d};$G' | tr -d '*')
    do git checkout $branch && \
    git merge --ff-only || break
done

1. git fetch --all && ... => 从所有远程获取所有引用，如果没有错误则继续执行下一个命令。

2. git branch | sed '/*/{$q;h;d};$G' | tr -d '*' => 从git branch、sed 的输出中取出带有* 的行并将其移至末尾（这样当前分支将最后更新）。然后tr 只需删除*。

3. for branch in $(...) ; do git checkout $branch && git merge --ff-only || break ; done = > 对于从上一条命令中获得的每个分支名称，签出该分支并尝试以快进方式合并。如果失败，则调用break，命令在此处停止。

当然，如果你想要的话，你可以用git rebase替换git merge --ff-only。

最后，你可以把它作为别名放在你的bashrc中：

alias git-pull-all='git fetch --all && for branch in $(git branch | sed '\''/*/{$q;h;d};$G'\'' | tr -d "*") ; do git checkout $branch && git merge --ff-only || break ; done'

或者，如果您害怕弄乱 ' 和 "，或者您只是希望在编辑器中保持语法可读性，您可以将其声明为函数：

git-pull-all()
{
    git fetch --all && for branch in $(git branch | sed '/*/{$q;h;d};$G' | tr -d '*') ; do git checkout $branch && git merge --ff-only || break ; done
}

奖金：

对于那些想要sed '/*/{$q;h;d};$G' 部分的解释的人：

• /*/ => 搜索带有* 的行。

• {$q => 如果在最后一行，退出（我们不需要做任何事情，因为当前分支已经是列表中的最后一个）。

• ;h;d} => 否则，将该行存储在保持缓冲区中并在当前列表位置删除它。

• ;$G => 当到达最后一行时，追加保持缓冲区的内容。

Answer 3

“git pull --all”可以更新我所有的本地分支吗？

不，它不能。对于快进，我只是写了一个小工具来做到这一点。 https://github.com/changyuheng/git-fast-forward-all

此工具的优点：

1. 在一个存储库中支持多个遥控器。 （hub sync 目前不支持多个遥控器。）
2. 支持在本地分支和对应的远程跟踪分支上使用不同的名称。
3. 比其他为每个分支获取远程的脚本要快得多。
4. 没有容易出错的正则表达式解析/编辑。

Answer 4

事实上，使用 git version 1.8.3.1，它可以工作：

[root@test test]# git br
* master
  release/0.1
  update
[root@test test]# git pull --rebase
remote: Enumerating objects: 9, done.
remote: Counting objects: 100% (9/9), done.
remote: Compressing objects: 100% (9/9), done.
remote: Total 9 (delta 2), reused 0 (delta 0)
Unpacking objects: 100% (9/9), done.
From http://xxx/scm/csdx/test-git
   d32ca6d..2caa393  release/0.1 -> origin/release/0.1
Current branch master is up to date.
[root@test test]# git --version
git version 1.8.3.1

在 master 分支中，您可以更新所有其他分支。 @Cascabel

我不知道哪个版本破坏/修复它，在 2.17（我使用的）中，它可以工作。

Answer 5

我遇到了同样的问题...

想知道自己，我在.bashrc 文件中做了一个小别名函数：

gitPullAll() {
    for branch in `git branch | sed -E 's/^\*/ /' | awk '{print $1}'`; do
        git checkout $branch
        git pull -p
        printf "\n"
    done
    echo "Done"
}

为我工作（：

Answer 6

如果可能，以下单行将所有具有上游分支的分支快进，否则打印错误：

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

它是如何工作的？

它使用git branch 命令的自定义格式。对于每个具有上游分支的分支，它会打印一行具有以下模式：

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

这可以直接通过管道传递到sh（假设分支名称格式正确）。省略 | sh 以查看它在做什么。

注意事项

one-liner 不会联系您的遥控器。在运行之前发出git fetch 或git fetch --all。

当前签出的分支不会更新类似消息

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

为此，您可以求助于普通的git pull --ff-only。

别名

将以下内容添加到您的.gitconfig，以便git fft 执行此命令：

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

另见我的.gitconfig。别名是“快进跟踪（分支）”的简写。

Answer 7

我使用hub 的sync subcommand 来自动执行此操作。我的.bash_profile 中有alias git=hub，所以我输入的命令是：

git sync

这会更新所有具有匹配上游分支的本地分支。从手册页：

• 如果本地分支过时，快进；
• 如果本地分支包含未推送的工作，请发出警告；
• 如果分支似乎已合并并且其上游分支已被删除，请将其删除。

它还处理当前分支上未提交的更改的存储/取消存储。

我曾经使用过类似的工具 git-up，但它不再维护，而 git sync 几乎完全相同。

Answer 8

我知道这个问题已经快 3 年了，但我问自己同样的问题，但没有找到任何现成的解决方案。所以，我自己创建了一个自定义的 git 命令 shell 脚本。

在这里，git-ffwd-update 脚本执行以下操作...

1. 它发出git remote update 来获取最新的转速
2. 然后使用git remote show 获取跟踪远程分支的本地分支列表（例如，可以与git pull 一起使用的分支）
3. 然后它使用git rev-list --count <REMOTE_BRANCH>..<LOCAL_BRANCH> 检查本地分支在远程之后有多少提交（反之亦然）
4. 如果本地分支提前 1 次或多次提交，它可以不能快进，需要手动合并或重新定位
5. 如果本地分支是 0 次前提交和 1 次或更多次提交，可以通过git branch -f <LOCAL_BRANCH> -t <REMOTE_BRANCH> 快进

脚本可以这样调用：

$ 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

完整的脚本，应该保存为git-ffwd-update，并且需要在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 $@

Answer 9

可以使用下面的脚本来完成...它会首先获取所有分支并逐个结帐并自行更新。

#!/bin/bash
git branch -r | grep -v '\->' | while read remote; do git branch --track 
"${remote#origin/}" "$remote"; done

set -x
CURRENT=`git rev-parse --abbrev-ref HEAD`
git fetch --all
branch_name=$(git branch | awk '{print $1" "}' | grep -v '*' | xargs)
for branch in $branch_name; do
   git checkout "$branch" || exit 1
   git rebase "origin/$branch" || exit 1
   git pull origin $branch|| exit 1
done
git checkout "$CURRENT" || exit 1
git pull || exit 1

Answer 10

只是发布一个更新的答案。 git-up 不再维护，如果您阅读文档，他们会看到mention the functionality is now available in git。

从 Git 2.9 开始， git pull --rebase --autostash 的作用基本相同。

因此，如果你更新到 Git 2.9 或更高版本，你可以使用这个别名来代替安装 git-up：

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

您也可以从 Git 2.9 开始为每个 git pull 设置此设置（感谢@VonC，请查看他的回答 here）

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

Answer 11

这个问题还没有解决（还），至少不容易/没有脚本：请参阅 Junio C Hamano 在 git 邮件列表上的 this post 解释情况并提供简单解决方案的呼吁。

主要原因是你不应该需要这个：

对于不古老的 git（即 v1.5.0 或更新版本），没有理由 让本地“开发”不再纯粹跟踪远程。如果你只想 去看看，你可以直接查看远程跟踪分支 在带有“git checkout origin/dev”的分离 HEAD 上。

这意味着我们需要为用户提供方便的唯一情况 是处理这些本地分支，当你这样做时“跟踪”远程分支 进行本地更改，或者当您计划进行一些更改时。

如果您确实对标记为跟踪删除的“dev”进行了本地更改 “dev”，如果您在与“dev”不同的分支上，那么我们不应该 在“git fetch”更新远程跟踪“dev”之后执行任何操作。它 反正不会快进

解决方案的调用是使用一个选项或外部脚本来修剪现在远程跟踪分支之后的本地分支，而不是通过快速转发使它们保持最新，例如要求原始海报。

那么迭代的“git branch --prune --remote=<upstream>”怎么样 本地分支机构，如果

(1) 不是当前分支；和
(2) 它被标记为跟踪从 获取的一些分支；和
(3) 它自己没有任何提交；

然后删除那个分支？ “git remote --prune-local-forks <upstream>”是 也很好；我不关心哪个命令实现的功能 很多。

注意： 从 git 2.10 开始，不存在这样的解决方案。请注意，git remote prune 子命令和 git fetch --prune 是关于删除远程不再存在的分支的远程跟踪分支，而不是删除跟踪远程跟踪分支的本地分支（远程跟踪分支是上游分支） .

Answer 12

从 git 2.9 开始：

git pull --rebase --autostash

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

在操作开始之前自动创建一个临时存储， 并在操作结束后应用。这意味着您可以运行 在脏工作树上变基。但是，请小心使用：最后的藏匿处 成功变基后的应用程序可能会导致不平凡 冲突。

Answer 13

如果您使用的是 Windows，则可以使用 PyGitUp，它是 Python 的 git-up 的克隆。您可以使用pip 和pip install --user git-up 或通过Scoop 使用scoop install git-up 安装它

[

Answer 14

看起来很多其他人都贡献了类似的解决方案，但我想我会分享我的想法并邀请其他人做出贡献。该解决方案具有漂亮的彩色输出，优雅地处理您当前的工作目录，并且速度很快，因为它不进行任何检查，并且使您的工作目录保持完整。此外，它只是一个 shell 脚本，除了 git 之外没有其他依赖项。 （目前只在 OSX 上测试过）

#!/usr/bin/env bash

gitup(){    
RED='\033[33;31m'
YELLO='\033[33;33m'
GREEN='\033[33;32m'
NC='\033[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

对不起，我似乎也想出了与上面其他工具相同的名称。

Answer 15

这是一个很好的答案：How to fetch all git branches

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

Answer 16

我为GitBash 编写的脚本。完成以下任务：

• 默认情况下，所有设置为跟踪原点的分支都从原点提取，允许您根据需要指定不同的远程。
• 如果您当前的分支处于脏状态，那么它会隐藏您的更改并在最后尝试恢复这些更改。
• 对于设置为跟踪远程分支的每个本地分支将：
  • git checkout branch
  • git pull origin
• 最后，会让您回到原来的分支并恢复状态。

** 我使用这个，但没有彻底测试，使用风险自负。在 .bash_alias 文件 here 中查看此脚本的示例。

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

Answer 17

一个稍微不同的脚本，它只快进名称与上游分支匹配的分支。如果可以进行快进，它还会更新当前分支。

通过运行git branch -vv 确保所有分支的上游分支都设置正确。使用git branch -u origin/yourbanchname设置上游分支

复制粘贴到文件中并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;

Answer 18

这里有很多答案，但没有一个使用git-fetch直接更新本地ref，这比签出分支简单得多，也比git-update-ref安全。

这里我们使用git-fetch 更新非当前分支，git pull --ff-only 更新当前分支。它：

• 不需要签出分支
• 仅在可以快进时更新分支
• 无法快进时会报告

这里是：

#!/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>（不带任何+），我们得到一个仅在可以快进时更新本地引用的获取。

注意：这假设本地和远程分支的名称相同（并且您想要跟踪所有分支），它应该真正使用有关您拥有哪些本地分支以及它们设置了什么的信息跟踪。

Answer 19

来自@larsmans 的脚本，稍有改进：

#!/bin/sh

set -x
CURRENT=`git rev-parse --abbrev-ref HEAD`
git fetch --all
for branch in "$@"; do
  if ["$branch" -ne "$CURRENT"]; then
    git checkout "$branch" || exit 1
    git rebase "origin/$branch" || exit 1
  fi
done
git checkout "$CURRENT" || exit 1
git rebase "origin/$CURRENT" || exit 1

这在完成后，会从 同一分支 签出工作副本，就像调用脚本之前一样。

git pull 版本：

#!/bin/sh

set -x
CURRENT=`git rev-parse --abbrev-ref HEAD`
git fetch --all
for branch in "$@"; do
  if ["$branch" -ne "$CURRENT"]; then
    git checkout "$branch" || exit 1
    git pull || exit 1
  fi
done
git checkout "$CURRENT" || exit 1
git pull || exit 1

Answer 20

在 Mac OS X 上将 this script 添加到 .profile：

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

Answer 21

这里有很多可以接受的答案，但有些管道对于外行来说可能有点不透明。下面是一个可以轻松定制的更简单的示例：

$ 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

Answer 22

为了完成 Matt Connolly 的回答，这是一种更新本地分支引用的更安全方法，可以快速转发，而无需检查分支。它不会更新无法快速转发的分支（即已经发散的分支），也不会更新当前签出的分支（因为工作副本也应该更新）。

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

Answer 23

这仍然不是自动的，因为我希望有一个选项 - 并且应该进行一些检查以确保这只会发生在快进更新中（这就是为什么手动执行拉取更安全！ ！），但除了注意事项之外，您可以：

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

无需检查即可更新本地分支的位置。

注意：您将丢失当前分支位置并将其移动到源分支所在的位置，这意味着如果您需要合并，您将丢失数据！

Answer 24

自动化并不难：

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

Answer 25

您为pull --all 描述的行为完全符合预期，但不一定有用。该选项被传递给 git fetch，然后它从所有远程获取所有 refs，而不仅仅是需要的； pull 然后合并（或者在你的情况下，重新设置）适当的单个分支。

如果您想查看其他分支，则必须查看它们。是的，合并（和变基）绝对需要一个工作树，所以如果不检查其他分支就无法完成。如果你愿意，你可以将你描述的步骤包装成一个脚本/别名，不过我建议使用&& 加入命令，这样如果其中一个失败，它就不会尝试继续下去。

Answer 26

如果refs/heads/master可以快进到refs/remotes/foo/master，输出

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

应该返回 refs/heads/master 指向的 SHA1 id。有了这个，您可以编写一个脚本，自动更新所有没有应用转移提交的本地分支。

这个小 shell 脚本（我称之为 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