9cf005677c2936a7c2f14a00cc4e91670e2259f3
   1#!/bin/sh
   2#
   3# Copyright (c) 2005 Junio C Hamano.
   4#
   5
   6USAGE='[--interactive | -i] [-v] [--onto <newbase>] <upstream> [<branch>]'
   7LONG_USAGE='git-rebase replaces <branch> with a new branch of the
   8same name.  When the --onto option is provided the new branch starts
   9out with a HEAD equal to <newbase>, otherwise it is equal to <upstream>
  10It then attempts to create a new commit for each commit from the original
  11<branch> that does not exist in the <upstream> branch.
  12
  13It is possible that a merge failure will prevent this process from being
  14completely automatic.  You will have to resolve any such merge failure
  15and run git rebase --continue.  Another option is to bypass the commit
  16that caused the merge failure with git rebase --skip.  To restore the
  17original <branch> and remove the .dotest working files, use the command
  18git rebase --abort instead.
  19
  20Note that if <branch> is not specified on the command line, the
  21currently checked out branch is used.  You must be in the top
  22directory of your project to start (or continue) a rebase.
  23
  24Example:       git-rebase master~1 topic
  25
  26        A---B---C topic                   A'\''--B'\''--C'\'' topic
  27       /                   -->           /
  28  D---E---F---G master          D---E---F---G master
  29'
  30
  31SUBDIRECTORY_OK=Yes
  32. git-sh-setup
  33set_reflog_action rebase
  34require_work_tree
  35cd_to_toplevel
  36
  37RESOLVEMSG="
  38When you have resolved this problem run \"git rebase --continue\".
  39If you would prefer to skip this patch, instead run \"git rebase --skip\".
  40To restore the original branch and stop rebasing run \"git rebase --abort\".
  41"
  42unset newbase
  43strategy=recursive
  44do_merge=
  45dotest=$GIT_DIR/.dotest-merge
  46prec=4
  47verbose=
  48git_am_opt=
  49
  50continue_merge () {
  51        test -n "$prev_head" || die "prev_head must be defined"
  52        test -d "$dotest" || die "$dotest directory does not exist"
  53
  54        unmerged=$(git ls-files -u)
  55        if test -n "$unmerged"
  56        then
  57                echo "You still have unmerged paths in your index"
  58                echo "did you forget to use git add?"
  59                die "$RESOLVEMSG"
  60        fi
  61
  62        cmt=`cat $dotest/current`
  63        if ! git diff-index --quiet HEAD
  64        then
  65                if ! git-commit -C "$cmt"
  66                then
  67                        echo "Commit failed, please do not call \"git commit\""
  68                        echo "directly, but instead do one of the following: "
  69                        die "$RESOLVEMSG"
  70                fi
  71                printf "Committed: %0${prec}d " $msgnum
  72                git rev-list --pretty=oneline -1 HEAD | \
  73                        sed 's/^[a-f0-9]\+ //'
  74        else
  75                printf "Already applied: %0${prec}d " $msgnum
  76                git rev-list --pretty=oneline -1 "$cmt" | \
  77                        sed 's/^[a-f0-9]\+ //'
  78        fi
  79
  80        prev_head=`git rev-parse HEAD^0`
  81        # save the resulting commit so we can read-tree on it later
  82        echo "$prev_head" > "$dotest/prev_head"
  83
  84        # onto the next patch:
  85        msgnum=$(($msgnum + 1))
  86        echo "$msgnum" >"$dotest/msgnum"
  87}
  88
  89call_merge () {
  90        cmt="$(cat $dotest/cmt.$1)"
  91        echo "$cmt" > "$dotest/current"
  92        hd=$(git rev-parse --verify HEAD)
  93        cmt_name=$(git symbolic-ref HEAD)
  94        msgnum=$(cat $dotest/msgnum)
  95        end=$(cat $dotest/end)
  96        eval GITHEAD_$cmt='"${cmt_name##refs/heads/}~$(($end - $msgnum))"'
  97        eval GITHEAD_$hd='"$(cat $dotest/onto_name)"'
  98        export GITHEAD_$cmt GITHEAD_$hd
  99        git-merge-$strategy "$cmt^" -- "$hd" "$cmt"
 100        rv=$?
 101        case "$rv" in
 102        0)
 103                unset GITHEAD_$cmt GITHEAD_$hd
 104                return
 105                ;;
 106        1)
 107                git rerere
 108                die "$RESOLVEMSG"
 109                ;;
 110        2)
 111                echo "Strategy: $rv $strategy failed, try another" 1>&2
 112                die "$RESOLVEMSG"
 113                ;;
 114        *)
 115                die "Unknown exit code ($rv) from command:" \
 116                        "git-merge-$strategy $cmt^ -- HEAD $cmt"
 117                ;;
 118        esac
 119}
 120
 121finish_rb_merge () {
 122        rm -r "$dotest"
 123        echo "All done."
 124}
 125
 126is_interactive () {
 127        test -f "$dotest"/interactive ||
 128        while case $#,"$1" in 0,|*,-i|*,--interactive) break ;; esac
 129        do
 130                shift
 131        done && test -n "$1"
 132}
 133
 134is_interactive "$@" && exec git-rebase--interactive "$@"
 135
 136while case "$#" in 0) break ;; esac
 137do
 138        case "$1" in
 139        --continue)
 140                git diff-files --quiet || {
 141                        echo "You must edit all merge conflicts and then"
 142                        echo "mark them as resolved using git add"
 143                        exit 1
 144                }
 145                if test -d "$dotest"
 146                then
 147                        prev_head="`cat $dotest/prev_head`"
 148                        end="`cat $dotest/end`"
 149                        msgnum="`cat $dotest/msgnum`"
 150                        onto="`cat $dotest/onto`"
 151                        continue_merge
 152                        while test "$msgnum" -le "$end"
 153                        do
 154                                call_merge "$msgnum"
 155                                continue_merge
 156                        done
 157                        finish_rb_merge
 158                        exit
 159                fi
 160                git am --resolved --3way --resolvemsg="$RESOLVEMSG"
 161                exit
 162                ;;
 163        --skip)
 164                if test -d "$dotest"
 165                then
 166                        git rerere clear
 167                        prev_head="`cat $dotest/prev_head`"
 168                        end="`cat $dotest/end`"
 169                        msgnum="`cat $dotest/msgnum`"
 170                        msgnum=$(($msgnum + 1))
 171                        onto="`cat $dotest/onto`"
 172                        while test "$msgnum" -le "$end"
 173                        do
 174                                call_merge "$msgnum"
 175                                continue_merge
 176                        done
 177                        finish_rb_merge
 178                        exit
 179                fi
 180                git am -3 --skip --resolvemsg="$RESOLVEMSG"
 181                exit
 182                ;;
 183        --abort)
 184                git rerere clear
 185                if test -d "$dotest"
 186                then
 187                        rm -r "$dotest"
 188                elif test -d .dotest
 189                then
 190                        rm -r .dotest
 191                else
 192                        die "No rebase in progress?"
 193                fi
 194                git reset --hard ORIG_HEAD
 195                exit
 196                ;;
 197        --onto)
 198                test 2 -le "$#" || usage
 199                newbase="$2"
 200                shift
 201                ;;
 202        -M|-m|--m|--me|--mer|--merg|--merge)
 203                do_merge=t
 204                ;;
 205        -s=*|--s=*|--st=*|--str=*|--stra=*|--strat=*|--strate=*|\
 206                --strateg=*|--strategy=*|\
 207        -s|--s|--st|--str|--stra|--strat|--strate|--strateg|--strategy)
 208                case "$#,$1" in
 209                *,*=*)
 210                        strategy=`expr "z$1" : 'z-[^=]*=\(.*\)'` ;;
 211                1,*)
 212                        usage ;;
 213                *)
 214                        strategy="$2"
 215                        shift ;;
 216                esac
 217                do_merge=t
 218                ;;
 219        -v|--verbose)
 220                verbose=t
 221                ;;
 222        -C*)
 223                git_am_opt=$1
 224                shift
 225                ;;
 226        -*)
 227                usage
 228                ;;
 229        *)
 230                break
 231                ;;
 232        esac
 233        shift
 234done
 235
 236# Make sure we do not have .dotest
 237if test -z "$do_merge"
 238then
 239        if mkdir .dotest
 240        then
 241                rmdir .dotest
 242        else
 243                echo >&2 '
 244It seems that I cannot create a .dotest directory, and I wonder if you
 245are in the middle of patch application or another rebase.  If that is not
 246the case, please rm -fr .dotest and run me again.  I am stopping in case
 247you still have something valuable there.'
 248                exit 1
 249        fi
 250else
 251        if test -d "$dotest"
 252        then
 253                die "previous dotest directory $dotest still exists." \
 254                        'try git-rebase < --continue | --abort >'
 255        fi
 256fi
 257
 258# The tree must be really really clean.
 259git update-index --refresh || exit
 260diff=$(git diff-index --cached --name-status -r HEAD)
 261case "$diff" in
 262?*)     echo "cannot rebase: your index is not up-to-date"
 263        echo "$diff"
 264        exit 1
 265        ;;
 266esac
 267
 268# The upstream head must be given.  Make sure it is valid.
 269upstream_name="$1"
 270upstream=`git rev-parse --verify "${upstream_name}^0"` ||
 271    die "invalid upstream $upstream_name"
 272
 273# Make sure the branch to rebase onto is valid.
 274onto_name=${newbase-"$upstream_name"}
 275onto=$(git rev-parse --verify "${onto_name}^0") || exit
 276
 277# If a hook exists, give it a chance to interrupt
 278if test -x "$GIT_DIR/hooks/pre-rebase"
 279then
 280        "$GIT_DIR/hooks/pre-rebase" ${1+"$@"} || {
 281                echo >&2 "The pre-rebase hook refused to rebase."
 282                exit 1
 283        }
 284fi
 285
 286# If the branch to rebase is given, first switch to it.
 287case "$#" in
 2882)
 289        branch_name="$2"
 290        git-checkout "$2" || usage
 291        ;;
 292*)
 293        if branch_name=`git symbolic-ref -q HEAD`
 294        then
 295                branch_name=`expr "z$branch_name" : 'zrefs/heads/\(.*\)'`
 296        else
 297                branch_name=HEAD ;# detached
 298        fi
 299        ;;
 300esac
 301branch=$(git rev-parse --verify "${branch_name}^0") || exit
 302
 303# Now we are rebasing commits $upstream..$branch on top of $onto
 304
 305# Check if we are already based on $onto with linear history,
 306# but this should be done only when upstream and onto are the same.
 307mb=$(git merge-base "$onto" "$branch")
 308if test "$upstream" = "$onto" && test "$mb" = "$onto" &&
 309        # linear history?
 310        ! git rev-list --parents "$onto".."$branch" | grep " .* " > /dev/null
 311then
 312        echo >&2 "Current branch $branch_name is up to date."
 313        exit 0
 314fi
 315
 316if test -n "$verbose"
 317then
 318        echo "Changes from $mb to $onto:"
 319        # We want color (if set), but no pager
 320        GIT_PAGER='' git diff --stat --summary "$mb" "$onto"
 321fi
 322
 323# Rewind the head to "$onto"; this saves our current head in ORIG_HEAD.
 324echo "First, rewinding head to replay your work on top of it..."
 325git-reset --hard "$onto"
 326
 327# If the $onto is a proper descendant of the tip of the branch, then
 328# we just fast forwarded.
 329if test "$mb" = "$branch"
 330then
 331        echo >&2 "Fast-forwarded $branch_name to $onto_name."
 332        exit 0
 333fi
 334
 335if test -z "$do_merge"
 336then
 337        git format-patch -k --stdout --full-index --ignore-if-in-upstream "$upstream"..ORIG_HEAD |
 338        git am $git_am_opt --binary -3 -k --resolvemsg="$RESOLVEMSG"
 339        exit $?
 340fi
 341
 342# start doing a rebase with git-merge
 343# this is rename-aware if the recursive (default) strategy is used
 344
 345mkdir -p "$dotest"
 346echo "$onto" > "$dotest/onto"
 347echo "$onto_name" > "$dotest/onto_name"
 348prev_head=`git rev-parse HEAD^0`
 349echo "$prev_head" > "$dotest/prev_head"
 350
 351msgnum=0
 352for cmt in `git rev-list --reverse --no-merges "$upstream"..ORIG_HEAD`
 353do
 354        msgnum=$(($msgnum + 1))
 355        echo "$cmt" > "$dotest/cmt.$msgnum"
 356done
 357
 358echo 1 >"$dotest/msgnum"
 359echo $msgnum >"$dotest/end"
 360
 361end=$msgnum
 362msgnum=1
 363
 364while test "$msgnum" -le "$end"
 365do
 366        call_merge "$msgnum"
 367        continue_merge
 368done
 369
 370finish_rb_merge