Andrew's git - gitweb.git/blob - git-rebase--interactive.sh

   1#!/bin/sh
   2#
   3# Copyright (c) 2006 Johannes E. Schindelin
   4
   5# SHORT DESCRIPTION
   6#
   7# This script makes it easy to fix up commits in the middle of a series,
   8# and rearrange commits.
   9#
  10# The original idea comes from Eric W. Biederman, in
  11# http://article.gmane.org/gmane.comp.version-control.git/22407
  12
  13USAGE='(--continue | --abort | --skip | [--preserve-merges] [--verbose]
  14        [--onto <branch>] <upstream> [<branch>])'
  15
  16OPTIONS_SPEC=
  17. git-sh-setup
  18require_work_tree
  19
  20DOTEST="$GIT_DIR/.dotest-merge"
  21TODO="$DOTEST"/git-rebase-todo
  22DONE="$DOTEST"/done
  23MSG="$DOTEST"/message
  24SQUASH_MSG="$DOTEST"/message-squash
  25REWRITTEN="$DOTEST"/rewritten
  26PRESERVE_MERGES=
  27STRATEGY=
  28VERBOSE=
  29test -d "$REWRITTEN" && PRESERVE_MERGES=t
  30test -f "$DOTEST"/strategy && STRATEGY="$(cat "$DOTEST"/strategy)"
  31test -f "$DOTEST"/verbose && VERBOSE=t
  32
  33GIT_CHERRY_PICK_HELP="  After resolving the conflicts,
  34mark the corrected paths with 'git add <paths>', and
  35run 'git rebase --continue'"
  36export GIT_CHERRY_PICK_HELP
  37
  38warn () {
  39        echo "$*" >&2
  40}
  41
  42output () {
  43        case "$VERBOSE" in
  44        '')
  45                output=$("$@" 2>&1 )
  46                status=$?
  47                test $status != 0 && printf "%s\n" "$output"
  48                return $status
  49                ;;
  50        *)
  51                "$@"
  52                ;;
  53        esac
  54}
  55
  56require_clean_work_tree () {
  57        # test if working tree is dirty
  58        git rev-parse --verify HEAD > /dev/null &&
  59        git update-index --refresh &&
  60        git diff-files --quiet &&
  61        git diff-index --cached --quiet HEAD -- ||
  62        die "Working tree is dirty"
  63}
  64
  65ORIG_REFLOG_ACTION="$GIT_REFLOG_ACTION"
  66
  67comment_for_reflog () {
  68        case "$ORIG_REFLOG_ACTION" in
  69        ''|rebase*)
  70                GIT_REFLOG_ACTION="rebase -i ($1)"
  71                export GIT_REFLOG_ACTION
  72                ;;
  73        esac
  74}
  75
  76mark_action_done () {
  77        sed -e 1q < "$TODO" >> "$DONE"
  78        sed -e 1d < "$TODO" >> "$TODO".new
  79        mv -f "$TODO".new "$TODO"
  80        count=$(($(grep -ve '^$' -e '^#' < "$DONE" | wc -l)))
  81        total=$(($count+$(grep -ve '^$' -e '^#' < "$TODO" | wc -l)))
  82        printf "Rebasing (%d/%d)\r" $count $total
  83        test -z "$VERBOSE" || echo
  84}
  85
  86make_patch () {
  87        parent_sha1=$(git rev-parse --verify "$1"^) ||
  88                die "Cannot get patch for $1^"
  89        git diff-tree -p "$parent_sha1".."$1" > "$DOTEST"/patch
  90        test -f "$DOTEST"/message ||
  91                git cat-file commit "$1" | sed "1,/^$/d" > "$DOTEST"/message
  92        test -f "$DOTEST"/author-script ||
  93                get_author_ident_from_commit "$1" > "$DOTEST"/author-script
  94}
  95
  96die_with_patch () {
  97        make_patch "$1"
  98        git rerere
  99        die "$2"
 100}
 101
 102die_abort () {
 103        rm -rf "$DOTEST"
 104        die "$1"
 105}
 106
 107has_action () {
 108        grep -vqe '^$' -e '^#' "$1"
 109}
 110
 111pick_one () {
 112        no_ff=
 113        case "$1" in -n) sha1=$2; no_ff=t ;; *) sha1=$1 ;; esac
 114        output git rev-parse --verify $sha1 || die "Invalid commit name: $sha1"
 115        test -d "$REWRITTEN" &&
 116                pick_one_preserving_merges "$@" && return
 117        parent_sha1=$(git rev-parse --verify $sha1^) ||
 118                die "Could not get the parent of $sha1"
 119        current_sha1=$(git rev-parse --verify HEAD)
 120        if test "$no_ff$current_sha1" = "$parent_sha1"; then
 121                output git reset --hard $sha1
 122                test "a$1" = a-n && output git reset --soft $current_sha1
 123                sha1=$(git rev-parse --short $sha1)
 124                output warn Fast forward to $sha1
 125        else
 126                output git cherry-pick "$@"
 127        fi
 128}
 129
 130pick_one_preserving_merges () {
 131        case "$1" in -n) sha1=$2 ;; *) sha1=$1 ;; esac
 132        sha1=$(git rev-parse $sha1)
 133
 134        if test -f "$DOTEST"/current-commit
 135        then
 136                current_commit=$(cat "$DOTEST"/current-commit) &&
 137                git rev-parse HEAD > "$REWRITTEN"/$current_commit &&
 138                rm "$DOTEST"/current-commit ||
 139                die "Cannot write current commit's replacement sha1"
 140        fi
 141
 142        # rewrite parents; if none were rewritten, we can fast-forward.
 143        fast_forward=t
 144        preserve=t
 145        new_parents=
 146        for p in $(git rev-list --parents -1 $sha1 | cut -d' ' -f2-)
 147        do
 148                if test -f "$REWRITTEN"/$p
 149                then
 150                        preserve=f
 151                        new_p=$(cat "$REWRITTEN"/$p)
 152                        test $p != $new_p && fast_forward=f
 153                        case "$new_parents" in
 154                        *$new_p*)
 155                                ;; # do nothing; that parent is already there
 156                        *)
 157                                new_parents="$new_parents $new_p"
 158                                ;;
 159                        esac
 160                fi
 161        done
 162        case $fast_forward in
 163        t)
 164                output warn "Fast forward to $sha1"
 165                test $preserve = f || echo $sha1 > "$REWRITTEN"/$sha1
 166                ;;
 167        f)
 168                test "a$1" = a-n && die "Refusing to squash a merge: $sha1"
 169
 170                first_parent=$(expr "$new_parents" : ' \([^ ]*\)')
 171                # detach HEAD to current parent
 172                output git checkout $first_parent 2> /dev/null ||
 173                        die "Cannot move HEAD to $first_parent"
 174
 175                echo $sha1 > "$DOTEST"/current-commit
 176                case "$new_parents" in
 177                ' '*' '*)
 178                        # redo merge
 179                        author_script=$(get_author_ident_from_commit $sha1)
 180                        eval "$author_script"
 181                        msg="$(git cat-file commit $sha1 | sed -e '1,/^$/d')"
 182                        # No point in merging the first parent, that's HEAD
 183                        new_parents=${new_parents# $first_parent}
 184                        if ! GIT_AUTHOR_NAME="$GIT_AUTHOR_NAME" \
 185                                GIT_AUTHOR_EMAIL="$GIT_AUTHOR_EMAIL" \
 186                                GIT_AUTHOR_DATE="$GIT_AUTHOR_DATE" \
 187                                output git merge $STRATEGY -m "$msg" \
 188                                        $new_parents
 189                        then
 190                                git rerere
 191                                printf "%s\n" "$msg" > "$GIT_DIR"/MERGE_MSG
 192                                die Error redoing merge $sha1
 193                        fi
 194                        ;;
 195                *)
 196                        output git cherry-pick "$@" ||
 197                                die_with_patch $sha1 "Could not pick $sha1"
 198                        ;;
 199                esac
 200                ;;
 201        esac
 202}
 203
 204nth_string () {
 205        case "$1" in
 206        *1[0-9]|*[04-9]) echo "$1"th;;
 207        *1) echo "$1"st;;
 208        *2) echo "$1"nd;;
 209        *3) echo "$1"rd;;
 210        esac
 211}
 212
 213make_squash_message () {
 214        if test -f "$SQUASH_MSG"; then
 215                COUNT=$(($(sed -n "s/^# This is [^0-9]*\([1-9][0-9]*\).*/\1/p" \
 216                        < "$SQUASH_MSG" | tail -n 1)+1))
 217                echo "# This is a combination of $COUNT commits."
 218                sed -n "2,\$p" < "$SQUASH_MSG"
 219        else
 220                COUNT=2
 221                echo "# This is a combination of two commits."
 222                echo "# The first commit's message is:"
 223                echo
 224                git cat-file commit HEAD | sed -e '1,/^$/d'
 225                echo
 226        fi
 227        echo "# This is the $(nth_string $COUNT) commit message:"
 228        echo
 229        git cat-file commit $1 | sed -e '1,/^$/d'
 230}
 231
 232peek_next_command () {
 233        sed -n "1s/ .*$//p" < "$TODO"
 234}
 235
 236do_next () {
 237        rm -f "$DOTEST"/message "$DOTEST"/author-script \
 238                "$DOTEST"/amend || exit
 239        read command sha1 rest < "$TODO"
 240        case "$command" in
 241        '#'*|'')
 242                mark_action_done
 243                ;;
 244        pick|p)
 245                comment_for_reflog pick
 246
 247                mark_action_done
 248                pick_one $sha1 ||
 249                        die_with_patch $sha1 "Could not apply $sha1... $rest"
 250                ;;
 251        edit|e)
 252                comment_for_reflog edit
 253
 254                mark_action_done
 255                pick_one $sha1 ||
 256                        die_with_patch $sha1 "Could not apply $sha1... $rest"
 257                make_patch $sha1
 258                : > "$DOTEST"/amend
 259                warn
 260                warn "You can amend the commit now, with"
 261                warn
 262                warn "  git commit --amend"
 263                warn
 264                exit 0
 265                ;;
 266        squash|s)
 267                comment_for_reflog squash
 268
 269                has_action "$DONE" ||
 270                        die "Cannot 'squash' without a previous commit"
 271
 272                mark_action_done
 273                make_squash_message $sha1 > "$MSG"
 274                case "$(peek_next_command)" in
 275                squash|s)
 276                        EDIT_COMMIT=
 277                        USE_OUTPUT=output
 278                        cp "$MSG" "$SQUASH_MSG"
 279                        ;;
 280                *)
 281                        EDIT_COMMIT=-e
 282                        USE_OUTPUT=
 283                        rm -f "$SQUASH_MSG" || exit
 284                        ;;
 285                esac
 286
 287                failed=f
 288                author_script=$(get_author_ident_from_commit HEAD)
 289                output git reset --soft HEAD^
 290                pick_one -n $sha1 || failed=t
 291                echo "$author_script" > "$DOTEST"/author-script
 292                case $failed in
 293                f)
 294                        # This is like --amend, but with a different message
 295                        eval "$author_script"
 296                        GIT_AUTHOR_NAME="$GIT_AUTHOR_NAME" \
 297                        GIT_AUTHOR_EMAIL="$GIT_AUTHOR_EMAIL" \
 298                        GIT_AUTHOR_DATE="$GIT_AUTHOR_DATE" \
 299                        $USE_OUTPUT git commit -F "$MSG" $EDIT_COMMIT
 300                        ;;
 301                t)
 302                        cp "$MSG" "$GIT_DIR"/MERGE_MSG
 303                        warn
 304                        warn "Could not apply $sha1... $rest"
 305                        die_with_patch $sha1 ""
 306                        ;;
 307                esac
 308                ;;
 309        *)
 310                warn "Unknown command: $command $sha1 $rest"
 311                die_with_patch $sha1 "Please fix this in the file $TODO."
 312                ;;
 313        esac
 314        test -s "$TODO" && return
 315
 316        comment_for_reflog finish &&
 317        HEADNAME=$(cat "$DOTEST"/head-name) &&
 318        OLDHEAD=$(cat "$DOTEST"/head) &&
 319        SHORTONTO=$(git rev-parse --short $(cat "$DOTEST"/onto)) &&
 320        if test -d "$REWRITTEN"
 321        then
 322                test -f "$DOTEST"/current-commit &&
 323                        current_commit=$(cat "$DOTEST"/current-commit) &&
 324                        git rev-parse HEAD > "$REWRITTEN"/$current_commit
 325                if test -f "$REWRITTEN"/$OLDHEAD
 326                then
 327                        NEWHEAD=$(cat "$REWRITTEN"/$OLDHEAD)
 328                else
 329                        NEWHEAD=$OLDHEAD
 330                fi
 331        else
 332                NEWHEAD=$(git rev-parse HEAD)
 333        fi &&
 334        case $HEADNAME in
 335        refs/*)
 336                message="$GIT_REFLOG_ACTION: $HEADNAME onto $SHORTONTO)" &&
 337                git update-ref -m "$message" $HEADNAME $NEWHEAD $OLDHEAD &&
 338                git symbolic-ref HEAD $HEADNAME
 339                ;;
 340        esac && {
 341                test ! -f "$DOTEST"/verbose ||
 342                        git diff-tree --stat $(cat "$DOTEST"/head)..HEAD
 343        } &&
 344        rm -rf "$DOTEST" &&
 345        git gc --auto &&
 346        warn "Successfully rebased and updated $HEADNAME."
 347
 348        exit
 349}
 350
 351do_rest () {
 352        while :
 353        do
 354                do_next
 355        done
 356}
 357
 358while test $# != 0
 359do
 360        case "$1" in
 361        --continue)
 362                comment_for_reflog continue
 363
 364                test -d "$DOTEST" || die "No interactive rebase running"
 365
 366                # commit if necessary
 367                git rev-parse --verify HEAD > /dev/null &&
 368                git update-index --refresh &&
 369                git diff-files --quiet &&
 370                ! git diff-index --cached --quiet HEAD -- &&
 371                . "$DOTEST"/author-script && {
 372                        test ! -f "$DOTEST"/amend || git reset --soft HEAD^
 373                } &&
 374                export GIT_AUTHOR_NAME GIT_AUTHOR_NAME GIT_AUTHOR_DATE &&
 375                git commit -F "$DOTEST"/message -e
 376
 377                require_clean_work_tree
 378                do_rest
 379                ;;
 380        --abort)
 381                comment_for_reflog abort
 382
 383                git rerere clear
 384                test -d "$DOTEST" || die "No interactive rebase running"
 385
 386                HEADNAME=$(cat "$DOTEST"/head-name)
 387                HEAD=$(cat "$DOTEST"/head)
 388                case $HEADNAME in
 389                refs/*)
 390                        git symbolic-ref HEAD $HEADNAME
 391                        ;;
 392                esac &&
 393                output git reset --hard $HEAD &&
 394                rm -rf "$DOTEST"
 395                exit
 396                ;;
 397        --skip)
 398                comment_for_reflog skip
 399
 400                git rerere clear
 401                test -d "$DOTEST" || die "No interactive rebase running"
 402
 403                output git reset --hard && do_rest
 404                ;;
 405        -s|--strategy)
 406                case "$#,$1" in
 407                *,*=*)
 408                        STRATEGY="-s "$(expr "z$1" : 'z-[^=]*=\(.*\)') ;;
 409                1,*)
 410                        usage ;;
 411                *)
 412                        STRATEGY="-s $2"
 413                        shift ;;
 414                esac
 415                ;;
 416        --merge)
 417                # we use merge anyway
 418                ;;
 419        -C*)
 420                die "Interactive rebase uses merge, so $1 does not make sense"
 421                ;;
 422        -v|--verbose)
 423                VERBOSE=t
 424                ;;
 425        -p|--preserve-merges)
 426                PRESERVE_MERGES=t
 427                ;;
 428        -i|--interactive)
 429                # yeah, we know
 430                ;;
 431        ''|-h)
 432                usage
 433                ;;
 434        *)
 435                test -d "$DOTEST" &&
 436                        die "Interactive rebase already started"
 437
 438                git var GIT_COMMITTER_IDENT >/dev/null ||
 439                        die "You need to set your committer info first"
 440
 441                comment_for_reflog start
 442
 443                ONTO=
 444                case "$1" in
 445                --onto)
 446                        ONTO=$(git rev-parse --verify "$2") ||
 447                                die "Does not point to a valid commit: $2"
 448                        shift; shift
 449                        ;;
 450                esac
 451
 452                require_clean_work_tree
 453
 454                if test ! -z "$2"
 455                then
 456                        output git show-ref --verify --quiet "refs/heads/$2" ||
 457                                die "Invalid branchname: $2"
 458                        output git checkout "$2" ||
 459                                die "Could not checkout $2"
 460                fi
 461
 462                HEAD=$(git rev-parse --verify HEAD) || die "No HEAD?"
 463                UPSTREAM=$(git rev-parse --verify "$1") || die "Invalid base"
 464
 465                mkdir "$DOTEST" || die "Could not create temporary $DOTEST"
 466
 467                test -z "$ONTO" && ONTO=$UPSTREAM
 468
 469                : > "$DOTEST"/interactive || die "Could not mark as interactive"
 470                git symbolic-ref HEAD > "$DOTEST"/head-name 2> /dev/null ||
 471                        echo "detached HEAD" > "$DOTEST"/head-name
 472
 473                echo $HEAD > "$DOTEST"/head
 474                echo $UPSTREAM > "$DOTEST"/upstream
 475                echo $ONTO > "$DOTEST"/onto
 476                test -z "$STRATEGY" || echo "$STRATEGY" > "$DOTEST"/strategy
 477                test t = "$VERBOSE" && : > "$DOTEST"/verbose
 478                if test t = "$PRESERVE_MERGES"
 479                then
 480                        # $REWRITTEN contains files for each commit that is
 481                        # reachable by at least one merge base of $HEAD and
 482                        # $UPSTREAM. They are not necessarily rewritten, but
 483                        # their children might be.
 484                        # This ensures that commits on merged, but otherwise
 485                        # unrelated side branches are left alone. (Think "X"
 486                        # in the man page's example.)
 487                        mkdir "$REWRITTEN" &&
 488                        for c in $(git merge-base --all $HEAD $UPSTREAM)
 489                        do
 490                                echo $ONTO > "$REWRITTEN"/$c ||
 491                                        die "Could not init rewritten commits"
 492                        done
 493                        MERGES_OPTION=
 494                else
 495                        MERGES_OPTION=--no-merges
 496                fi
 497
 498                SHORTUPSTREAM=$(git rev-parse --short $UPSTREAM)
 499                SHORTHEAD=$(git rev-parse --short $HEAD)
 500                SHORTONTO=$(git rev-parse --short $ONTO)
 501                git rev-list $MERGES_OPTION --pretty=oneline --abbrev-commit \
 502                        --abbrev=7 --reverse --left-right --cherry-pick \
 503                        $UPSTREAM...$HEAD | \
 504                        sed -n "s/^>/pick /p" > "$TODO"
 505                cat >> "$TODO" << EOF
 506
 507# Rebase $SHORTUPSTREAM..$SHORTHEAD onto $SHORTONTO
 508#
 509# Commands:
 510#  pick = use commit
 511#  edit = use commit, but stop for amending
 512#  squash = use commit, but meld into previous commit
 513#
 514# If you remove a line here THAT COMMIT WILL BE LOST.
 515# However, if you remove everything, the rebase will be aborted.
 516#
 517EOF
 518
 519                has_action "$TODO" ||
 520                        die_abort "Nothing to do"
 521
 522                cp "$TODO" "$TODO".backup
 523                git_editor "$TODO" ||
 524                        die "Could not execute editor"
 525
 526                has_action "$TODO" ||
 527                        die_abort "Nothing to do"
 528
 529                output git checkout $ONTO && do_rest
 530                ;;
 531        esac
 532        shift
 533done