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