git-rebase--interactive.shon commit add update 'none' flag to disable update of submodule by default (322bb6e)
   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
  13. git-sh-setup
  14
  15# The file containing rebase commands, comments, and empty lines.
  16# This file is created by "git rebase -i" then edited by the user.  As
  17# the lines are processed, they are removed from the front of this
  18# file and written to the tail of $done.
  19todo="$state_dir"/git-rebase-todo
  20
  21# The rebase command lines that have already been processed.  A line
  22# is moved here when it is first handled, before any associated user
  23# actions.
  24done="$state_dir"/done
  25
  26# The commit message that is planned to be used for any changes that
  27# need to be committed following a user interaction.
  28msg="$state_dir"/message
  29
  30# The file into which is accumulated the suggested commit message for
  31# squash/fixup commands.  When the first of a series of squash/fixups
  32# is seen, the file is created and the commit message from the
  33# previous commit and from the first squash/fixup commit are written
  34# to it.  The commit message for each subsequent squash/fixup commit
  35# is appended to the file as it is processed.
  36#
  37# The first line of the file is of the form
  38#     # This is a combination of $count commits.
  39# where $count is the number of commits whose messages have been
  40# written to the file so far (including the initial "pick" commit).
  41# Each time that a commit message is processed, this line is read and
  42# updated.  It is deleted just before the combined commit is made.
  43squash_msg="$state_dir"/message-squash
  44
  45# If the current series of squash/fixups has not yet included a squash
  46# command, then this file exists and holds the commit message of the
  47# original "pick" commit.  (If the series ends without a "squash"
  48# command, then this can be used as the commit message of the combined
  49# commit without opening the editor.)
  50fixup_msg="$state_dir"/message-fixup
  51
  52# $rewritten is the name of a directory containing files for each
  53# commit that is reachable by at least one merge base of $head and
  54# $upstream. They are not necessarily rewritten, but their children
  55# might be.  This ensures that commits on merged, but otherwise
  56# unrelated side branches are left alone. (Think "X" in the man page's
  57# example.)
  58rewritten="$state_dir"/rewritten
  59
  60dropped="$state_dir"/dropped
  61
  62# A script to set the GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL, and
  63# GIT_AUTHOR_DATE that will be used for the commit that is currently
  64# being rebased.
  65author_script="$state_dir"/author-script
  66
  67# When an "edit" rebase command is being processed, the SHA1 of the
  68# commit to be edited is recorded in this file.  When "git rebase
  69# --continue" is executed, if there are any staged changes then they
  70# will be amended to the HEAD commit, but only provided the HEAD
  71# commit is still the commit to be edited.  When any other rebase
  72# command is processed, this file is deleted.
  73amend="$state_dir"/amend
  74
  75# For the post-rewrite hook, we make a list of rewritten commits and
  76# their new sha1s.  The rewritten-pending list keeps the sha1s of
  77# commits that have been processed, but not committed yet,
  78# e.g. because they are waiting for a 'squash' command.
  79rewritten_list="$state_dir"/rewritten-list
  80rewritten_pending="$state_dir"/rewritten-pending
  81
  82GIT_CHERRY_PICK_HELP="$resolvemsg"
  83export GIT_CHERRY_PICK_HELP
  84
  85warn () {
  86        printf '%s\n' "$*" >&2
  87}
  88
  89# Output the commit message for the specified commit.
  90commit_message () {
  91        git cat-file commit "$1" | sed "1,/^$/d"
  92}
  93
  94orig_reflog_action="$GIT_REFLOG_ACTION"
  95
  96comment_for_reflog () {
  97        case "$orig_reflog_action" in
  98        ''|rebase*)
  99                GIT_REFLOG_ACTION="rebase -i ($1)"
 100                export GIT_REFLOG_ACTION
 101                ;;
 102        esac
 103}
 104
 105last_count=
 106mark_action_done () {
 107        sed -e 1q < "$todo" >> "$done"
 108        sed -e 1d < "$todo" >> "$todo".new
 109        mv -f "$todo".new "$todo"
 110        new_count=$(sane_grep -c '^[^#]' < "$done")
 111        total=$(($new_count+$(sane_grep -c '^[^#]' < "$todo")))
 112        if test "$last_count" != "$new_count"
 113        then
 114                last_count=$new_count
 115                printf "Rebasing (%d/%d)\r" $new_count $total
 116                test -z "$verbose" || echo
 117        fi
 118}
 119
 120make_patch () {
 121        sha1_and_parents="$(git rev-list --parents -1 "$1")"
 122        case "$sha1_and_parents" in
 123        ?*' '?*' '?*)
 124                git diff --cc $sha1_and_parents
 125                ;;
 126        ?*' '?*)
 127                git diff-tree -p "$1^!"
 128                ;;
 129        *)
 130                echo "Root commit"
 131                ;;
 132        esac > "$state_dir"/patch
 133        test -f "$msg" ||
 134                commit_message "$1" > "$msg"
 135        test -f "$author_script" ||
 136                get_author_ident_from_commit "$1" > "$author_script"
 137}
 138
 139die_with_patch () {
 140        echo "$1" > "$state_dir"/stopped-sha
 141        make_patch "$1"
 142        git rerere
 143        die "$2"
 144}
 145
 146die_abort () {
 147        rm -rf "$state_dir"
 148        die "$1"
 149}
 150
 151has_action () {
 152        sane_grep '^[^#]' "$1" >/dev/null
 153}
 154
 155# Run command with GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL, and
 156# GIT_AUTHOR_DATE exported from the current environment.
 157do_with_author () {
 158        (
 159                export GIT_AUTHOR_NAME GIT_AUTHOR_EMAIL GIT_AUTHOR_DATE
 160                "$@"
 161        )
 162}
 163
 164pick_one () {
 165        ff=--ff
 166        case "$1" in -n) sha1=$2; ff= ;; *) sha1=$1 ;; esac
 167        case "$force_rebase" in '') ;; ?*) ff= ;; esac
 168        output git rev-parse --verify $sha1 || die "Invalid commit name: $sha1"
 169        test -d "$rewritten" &&
 170                pick_one_preserving_merges "$@" && return
 171        output git cherry-pick $ff "$@"
 172}
 173
 174pick_one_preserving_merges () {
 175        fast_forward=t
 176        case "$1" in
 177        -n)
 178                fast_forward=f
 179                sha1=$2
 180                ;;
 181        *)
 182                sha1=$1
 183                ;;
 184        esac
 185        sha1=$(git rev-parse $sha1)
 186
 187        if test -f "$state_dir"/current-commit
 188        then
 189                if test "$fast_forward" = t
 190                then
 191                        while read current_commit
 192                        do
 193                                git rev-parse HEAD > "$rewritten"/$current_commit
 194                        done <"$state_dir"/current-commit
 195                        rm "$state_dir"/current-commit ||
 196                        die "Cannot write current commit's replacement sha1"
 197                fi
 198        fi
 199
 200        echo $sha1 >> "$state_dir"/current-commit
 201
 202        # rewrite parents; if none were rewritten, we can fast-forward.
 203        new_parents=
 204        pend=" $(git rev-list --parents -1 $sha1 | cut -d' ' -s -f2-)"
 205        if test "$pend" = " "
 206        then
 207                pend=" root"
 208        fi
 209        while [ "$pend" != "" ]
 210        do
 211                p=$(expr "$pend" : ' \([^ ]*\)')
 212                pend="${pend# $p}"
 213
 214                if test -f "$rewritten"/$p
 215                then
 216                        new_p=$(cat "$rewritten"/$p)
 217
 218                        # If the todo reordered commits, and our parent is marked for
 219                        # rewriting, but hasn't been gotten to yet, assume the user meant to
 220                        # drop it on top of the current HEAD
 221                        if test -z "$new_p"
 222                        then
 223                                new_p=$(git rev-parse HEAD)
 224                        fi
 225
 226                        test $p != $new_p && fast_forward=f
 227                        case "$new_parents" in
 228                        *$new_p*)
 229                                ;; # do nothing; that parent is already there
 230                        *)
 231                                new_parents="$new_parents $new_p"
 232                                ;;
 233                        esac
 234                else
 235                        if test -f "$dropped"/$p
 236                        then
 237                                fast_forward=f
 238                                replacement="$(cat "$dropped"/$p)"
 239                                test -z "$replacement" && replacement=root
 240                                pend=" $replacement$pend"
 241                        else
 242                                new_parents="$new_parents $p"
 243                        fi
 244                fi
 245        done
 246        case $fast_forward in
 247        t)
 248                output warn "Fast-forward to $sha1"
 249                output git reset --hard $sha1 ||
 250                        die "Cannot fast-forward to $sha1"
 251                ;;
 252        f)
 253                first_parent=$(expr "$new_parents" : ' \([^ ]*\)')
 254
 255                if [ "$1" != "-n" ]
 256                then
 257                        # detach HEAD to current parent
 258                        output git checkout $first_parent 2> /dev/null ||
 259                                die "Cannot move HEAD to $first_parent"
 260                fi
 261
 262                case "$new_parents" in
 263                ' '*' '*)
 264                        test "a$1" = a-n && die "Refusing to squash a merge: $sha1"
 265
 266                        # redo merge
 267                        author_script_content=$(get_author_ident_from_commit $sha1)
 268                        eval "$author_script_content"
 269                        msg_content="$(commit_message $sha1)"
 270                        # No point in merging the first parent, that's HEAD
 271                        new_parents=${new_parents# $first_parent}
 272                        if ! do_with_author output \
 273                                git merge --no-ff ${strategy:+-s $strategy} -m \
 274                                        "$msg_content" $new_parents
 275                        then
 276                                printf "%s\n" "$msg_content" > "$GIT_DIR"/MERGE_MSG
 277                                die_with_patch $sha1 "Error redoing merge $sha1"
 278                        fi
 279                        echo "$sha1 $(git rev-parse HEAD^0)" >> "$rewritten_list"
 280                        ;;
 281                *)
 282                        output git cherry-pick "$@" ||
 283                                die_with_patch $sha1 "Could not pick $sha1"
 284                        ;;
 285                esac
 286                ;;
 287        esac
 288}
 289
 290nth_string () {
 291        case "$1" in
 292        *1[0-9]|*[04-9]) echo "$1"th;;
 293        *1) echo "$1"st;;
 294        *2) echo "$1"nd;;
 295        *3) echo "$1"rd;;
 296        esac
 297}
 298
 299update_squash_messages () {
 300        if test -f "$squash_msg"; then
 301                mv "$squash_msg" "$squash_msg".bak || exit
 302                count=$(($(sed -n \
 303                        -e "1s/^# This is a combination of \(.*\) commits\./\1/p" \
 304                        -e "q" < "$squash_msg".bak)+1))
 305                {
 306                        echo "# This is a combination of $count commits."
 307                        sed -e 1d -e '2,/^./{
 308                                /^$/d
 309                        }' <"$squash_msg".bak
 310                } >"$squash_msg"
 311        else
 312                commit_message HEAD > "$fixup_msg" || die "Cannot write $fixup_msg"
 313                count=2
 314                {
 315                        echo "# This is a combination of 2 commits."
 316                        echo "# The first commit's message is:"
 317                        echo
 318                        cat "$fixup_msg"
 319                } >"$squash_msg"
 320        fi
 321        case $1 in
 322        squash)
 323                rm -f "$fixup_msg"
 324                echo
 325                echo "# This is the $(nth_string $count) commit message:"
 326                echo
 327                commit_message $2
 328                ;;
 329        fixup)
 330                echo
 331                echo "# The $(nth_string $count) commit message will be skipped:"
 332                echo
 333                commit_message $2 | sed -e 's/^/#       /'
 334                ;;
 335        esac >>"$squash_msg"
 336}
 337
 338peek_next_command () {
 339        sed -n -e "/^#/d" -e '/^$/d' -e "s/ .*//p" -e "q" < "$todo"
 340}
 341
 342# A squash/fixup has failed.  Prepare the long version of the squash
 343# commit message, then die_with_patch.  This code path requires the
 344# user to edit the combined commit message for all commits that have
 345# been squashed/fixedup so far.  So also erase the old squash
 346# messages, effectively causing the combined commit to be used as the
 347# new basis for any further squash/fixups.  Args: sha1 rest
 348die_failed_squash() {
 349        mv "$squash_msg" "$msg" || exit
 350        rm -f "$fixup_msg"
 351        cp "$msg" "$GIT_DIR"/MERGE_MSG || exit
 352        warn
 353        warn "Could not apply $1... $2"
 354        die_with_patch $1 ""
 355}
 356
 357flush_rewritten_pending() {
 358        test -s "$rewritten_pending" || return
 359        newsha1="$(git rev-parse HEAD^0)"
 360        sed "s/$/ $newsha1/" < "$rewritten_pending" >> "$rewritten_list"
 361        rm -f "$rewritten_pending"
 362}
 363
 364record_in_rewritten() {
 365        oldsha1="$(git rev-parse $1)"
 366        echo "$oldsha1" >> "$rewritten_pending"
 367
 368        case "$(peek_next_command)" in
 369        squash|s|fixup|f)
 370                ;;
 371        *)
 372                flush_rewritten_pending
 373                ;;
 374        esac
 375}
 376
 377do_next () {
 378        rm -f "$msg" "$author_script" "$amend" || exit
 379        read -r command sha1 rest < "$todo"
 380        case "$command" in
 381        '#'*|''|noop)
 382                mark_action_done
 383                ;;
 384        pick|p)
 385                comment_for_reflog pick
 386
 387                mark_action_done
 388                pick_one $sha1 ||
 389                        die_with_patch $sha1 "Could not apply $sha1... $rest"
 390                record_in_rewritten $sha1
 391                ;;
 392        reword|r)
 393                comment_for_reflog reword
 394
 395                mark_action_done
 396                pick_one $sha1 ||
 397                        die_with_patch $sha1 "Could not apply $sha1... $rest"
 398                git commit --amend --no-post-rewrite
 399                record_in_rewritten $sha1
 400                ;;
 401        edit|e)
 402                comment_for_reflog edit
 403
 404                mark_action_done
 405                pick_one $sha1 ||
 406                        die_with_patch $sha1 "Could not apply $sha1... $rest"
 407                echo "$sha1" > "$state_dir"/stopped-sha
 408                make_patch $sha1
 409                git rev-parse --verify HEAD > "$amend"
 410                warn "Stopped at $sha1... $rest"
 411                warn "You can amend the commit now, with"
 412                warn
 413                warn "  git commit --amend"
 414                warn
 415                warn "Once you are satisfied with your changes, run"
 416                warn
 417                warn "  git rebase --continue"
 418                warn
 419                exit 0
 420                ;;
 421        squash|s|fixup|f)
 422                case "$command" in
 423                squash|s)
 424                        squash_style=squash
 425                        ;;
 426                fixup|f)
 427                        squash_style=fixup
 428                        ;;
 429                esac
 430                comment_for_reflog $squash_style
 431
 432                test -f "$done" && has_action "$done" ||
 433                        die "Cannot '$squash_style' without a previous commit"
 434
 435                mark_action_done
 436                update_squash_messages $squash_style $sha1
 437                author_script_content=$(get_author_ident_from_commit HEAD)
 438                echo "$author_script_content" > "$author_script"
 439                eval "$author_script_content"
 440                output git reset --soft HEAD^
 441                pick_one -n $sha1 || die_failed_squash $sha1 "$rest"
 442                case "$(peek_next_command)" in
 443                squash|s|fixup|f)
 444                        # This is an intermediate commit; its message will only be
 445                        # used in case of trouble.  So use the long version:
 446                        do_with_author output git commit --no-verify -F "$squash_msg" ||
 447                                die_failed_squash $sha1 "$rest"
 448                        ;;
 449                *)
 450                        # This is the final command of this squash/fixup group
 451                        if test -f "$fixup_msg"
 452                        then
 453                                do_with_author git commit --no-verify -F "$fixup_msg" ||
 454                                        die_failed_squash $sha1 "$rest"
 455                        else
 456                                cp "$squash_msg" "$GIT_DIR"/SQUASH_MSG || exit
 457                                rm -f "$GIT_DIR"/MERGE_MSG
 458                                do_with_author git commit --no-verify -e ||
 459                                        die_failed_squash $sha1 "$rest"
 460                        fi
 461                        rm -f "$squash_msg" "$fixup_msg"
 462                        ;;
 463                esac
 464                record_in_rewritten $sha1
 465                ;;
 466        x|"exec")
 467                read -r command rest < "$todo"
 468                mark_action_done
 469                printf 'Executing: %s\n' "$rest"
 470                # "exec" command doesn't take a sha1 in the todo-list.
 471                # => can't just use $sha1 here.
 472                git rev-parse --verify HEAD > "$state_dir"/stopped-sha
 473                ${SHELL:-@SHELL_PATH@} -c "$rest" # Actual execution
 474                status=$?
 475                if test "$status" -ne 0
 476                then
 477                        warn "Execution failed: $rest"
 478                        warn "You can fix the problem, and then run"
 479                        warn
 480                        warn "  git rebase --continue"
 481                        warn
 482                        exit "$status"
 483                fi
 484                # Run in subshell because require_clean_work_tree can die.
 485                if ! (require_clean_work_tree "rebase")
 486                then
 487                        warn "Commit or stash your changes, and then run"
 488                        warn
 489                        warn "  git rebase --continue"
 490                        warn
 491                        exit 1
 492                fi
 493                ;;
 494        *)
 495                warn "Unknown command: $command $sha1 $rest"
 496                if git rev-parse --verify -q "$sha1" >/dev/null
 497                then
 498                        die_with_patch $sha1 "Please fix this in the file $todo."
 499                else
 500                        die "Please fix this in the file $todo."
 501                fi
 502                ;;
 503        esac
 504        test -s "$todo" && return
 505
 506        comment_for_reflog finish &&
 507        shortonto=$(git rev-parse --short $onto) &&
 508        newhead=$(git rev-parse HEAD) &&
 509        case $head_name in
 510        refs/*)
 511                message="$GIT_REFLOG_ACTION: $head_name onto $shortonto" &&
 512                git update-ref -m "$message" $head_name $newhead $orig_head &&
 513                git symbolic-ref \
 514                  -m "$GIT_REFLOG_ACTION: returning to $head_name" \
 515                  HEAD $head_name
 516                ;;
 517        esac && {
 518                test ! -f "$state_dir"/verbose ||
 519                        git diff-tree --stat $orig_head..HEAD
 520        } &&
 521        {
 522                test -s "$rewritten_list" &&
 523                git notes copy --for-rewrite=rebase < "$rewritten_list" ||
 524                true # we don't care if this copying failed
 525        } &&
 526        if test -x "$GIT_DIR"/hooks/post-rewrite &&
 527                test -s "$rewritten_list"; then
 528                "$GIT_DIR"/hooks/post-rewrite rebase < "$rewritten_list"
 529                true # we don't care if this hook failed
 530        fi &&
 531        rm -rf "$state_dir" &&
 532        git gc --auto &&
 533        warn "Successfully rebased and updated $head_name."
 534
 535        exit
 536}
 537
 538do_rest () {
 539        while :
 540        do
 541                do_next
 542        done
 543}
 544
 545# skip picking commits whose parents are unchanged
 546skip_unnecessary_picks () {
 547        fd=3
 548        while read -r command rest
 549        do
 550                # fd=3 means we skip the command
 551                case "$fd,$command" in
 552                3,pick|3,p)
 553                        # pick a commit whose parent is current $onto -> skip
 554                        sha1=${rest%% *}
 555                        case "$(git rev-parse --verify --quiet "$sha1"^)" in
 556                        "$onto"*)
 557                                onto=$sha1
 558                                ;;
 559                        *)
 560                                fd=1
 561                                ;;
 562                        esac
 563                        ;;
 564                3,#*|3,)
 565                        # copy comments
 566                        ;;
 567                *)
 568                        fd=1
 569                        ;;
 570                esac
 571                printf '%s\n' "$command${rest:+ }$rest" >&$fd
 572        done <"$todo" >"$todo.new" 3>>"$done" &&
 573        mv -f "$todo".new "$todo" &&
 574        case "$(peek_next_command)" in
 575        squash|s|fixup|f)
 576                record_in_rewritten "$onto"
 577                ;;
 578        esac ||
 579        die "Could not skip unnecessary pick commands"
 580}
 581
 582# Rearrange the todo list that has both "pick sha1 msg" and
 583# "pick sha1 fixup!/squash! msg" appears in it so that the latter
 584# comes immediately after the former, and change "pick" to
 585# "fixup"/"squash".
 586rearrange_squash () {
 587        # extract fixup!/squash! lines and resolve any referenced sha1's
 588        while read -r pick sha1 message
 589        do
 590                case "$message" in
 591                "squash! "*|"fixup! "*)
 592                        action="${message%%!*}"
 593                        rest="${message#*! }"
 594                        echo "$sha1 $action $rest"
 595                        # if it's a single word, try to resolve to a full sha1 and
 596                        # emit a second copy. This allows us to match on both message
 597                        # and on sha1 prefix
 598                        if test "${rest#* }" = "$rest"; then
 599                                fullsha="$(git rev-parse -q --verify "$rest" 2>/dev/null)"
 600                                if test -n "$fullsha"; then
 601                                        # prefix the action to uniquely identify this line as
 602                                        # intended for full sha1 match
 603                                        echo "$sha1 +$action $fullsha"
 604                                fi
 605                        fi
 606                esac
 607        done >"$1.sq" <"$1"
 608        test -s "$1.sq" || return
 609
 610        used=
 611        while read -r pick sha1 message
 612        do
 613                case " $used" in
 614                *" $sha1 "*) continue ;;
 615                esac
 616                printf '%s\n' "$pick $sha1 $message"
 617                used="$used$sha1 "
 618                while read -r squash action msg_content
 619                do
 620                        case " $used" in
 621                        *" $squash "*) continue ;;
 622                        esac
 623                        emit=0
 624                        case "$action" in
 625                        +*)
 626                                action="${action#+}"
 627                                # full sha1 prefix test
 628                                case "$msg_content" in "$sha1"*) emit=1;; esac ;;
 629                        *)
 630                                # message prefix test
 631                                case "$message" in "$msg_content"*) emit=1;; esac ;;
 632                        esac
 633                        if test $emit = 1; then
 634                                printf '%s\n' "$action $squash $action! $msg_content"
 635                                used="$used$squash "
 636                        fi
 637                done <"$1.sq"
 638        done >"$1.rearranged" <"$1"
 639        cat "$1.rearranged" >"$1"
 640        rm -f "$1.sq" "$1.rearranged"
 641}
 642
 643case "$action" in
 644continue)
 645        # do we have anything to commit?
 646        if git diff-index --cached --quiet --ignore-submodules HEAD --
 647        then
 648                : Nothing to commit -- skip this
 649        else
 650                . "$author_script" ||
 651                        die "Cannot find the author identity"
 652                current_head=
 653                if test -f "$amend"
 654                then
 655                        current_head=$(git rev-parse --verify HEAD)
 656                        test "$current_head" = $(cat "$amend") ||
 657                        die "\
 658You have uncommitted changes in your working tree. Please, commit them
 659first and then run 'git rebase --continue' again."
 660                        git reset --soft HEAD^ ||
 661                        die "Cannot rewind the HEAD"
 662                fi
 663                do_with_author git commit --no-verify -F "$msg" -e || {
 664                        test -n "$current_head" && git reset --soft $current_head
 665                        die "Could not commit staged changes."
 666                }
 667        fi
 668
 669        record_in_rewritten "$(cat "$state_dir"/stopped-sha)"
 670
 671        require_clean_work_tree "rebase"
 672        do_rest
 673        ;;
 674skip)
 675        git rerere clear
 676
 677        do_rest
 678        ;;
 679esac
 680
 681git var GIT_COMMITTER_IDENT >/dev/null ||
 682        die "You need to set your committer info first"
 683
 684comment_for_reflog start
 685
 686if test ! -z "$switch_to"
 687then
 688        output git checkout "$switch_to" -- ||
 689                die "Could not checkout $switch_to"
 690fi
 691
 692orig_head=$(git rev-parse --verify HEAD) || die "No HEAD?"
 693mkdir "$state_dir" || die "Could not create temporary $state_dir"
 694
 695: > "$state_dir"/interactive || die "Could not mark as interactive"
 696write_basic_state
 697if test t = "$preserve_merges"
 698then
 699        if test -z "$rebase_root"
 700        then
 701                mkdir "$rewritten" &&
 702                for c in $(git merge-base --all $orig_head $upstream)
 703                do
 704                        echo $onto > "$rewritten"/$c ||
 705                                die "Could not init rewritten commits"
 706                done
 707        else
 708                mkdir "$rewritten" &&
 709                echo $onto > "$rewritten"/root ||
 710                        die "Could not init rewritten commits"
 711        fi
 712        # No cherry-pick because our first pass is to determine
 713        # parents to rewrite and skipping dropped commits would
 714        # prematurely end our probe
 715        merges_option=
 716else
 717        merges_option="--no-merges --cherry-pick"
 718fi
 719
 720shorthead=$(git rev-parse --short $orig_head)
 721shortonto=$(git rev-parse --short $onto)
 722if test -z "$rebase_root"
 723        # this is now equivalent to ! -z "$upstream"
 724then
 725        shortupstream=$(git rev-parse --short $upstream)
 726        revisions=$upstream...$orig_head
 727        shortrevisions=$shortupstream..$shorthead
 728else
 729        revisions=$onto...$orig_head
 730        shortrevisions=$shorthead
 731fi
 732git rev-list $merges_option --pretty=oneline --abbrev-commit \
 733        --abbrev=7 --reverse --left-right --topo-order \
 734        $revisions | \
 735        sed -n "s/^>//p" |
 736while read -r shortsha1 rest
 737do
 738        if test t != "$preserve_merges"
 739        then
 740                printf '%s\n' "pick $shortsha1 $rest" >> "$todo"
 741        else
 742                sha1=$(git rev-parse $shortsha1)
 743                if test -z "$rebase_root"
 744                then
 745                        preserve=t
 746                        for p in $(git rev-list --parents -1 $sha1 | cut -d' ' -s -f2-)
 747                        do
 748                                if test -f "$rewritten"/$p
 749                                then
 750                                        preserve=f
 751                                fi
 752                        done
 753                else
 754                        preserve=f
 755                fi
 756                if test f = "$preserve"
 757                then
 758                        touch "$rewritten"/$sha1
 759                        printf '%s\n' "pick $shortsha1 $rest" >> "$todo"
 760                fi
 761        fi
 762done
 763
 764# Watch for commits that been dropped by --cherry-pick
 765if test t = "$preserve_merges"
 766then
 767        mkdir "$dropped"
 768        # Save all non-cherry-picked changes
 769        git rev-list $revisions --left-right --cherry-pick | \
 770                sed -n "s/^>//p" > "$state_dir"/not-cherry-picks
 771        # Now all commits and note which ones are missing in
 772        # not-cherry-picks and hence being dropped
 773        git rev-list $revisions |
 774        while read rev
 775        do
 776                if test -f "$rewritten"/$rev -a "$(sane_grep "$rev" "$state_dir"/not-cherry-picks)" = ""
 777                then
 778                        # Use -f2 because if rev-list is telling us this commit is
 779                        # not worthwhile, we don't want to track its multiple heads,
 780                        # just the history of its first-parent for others that will
 781                        # be rebasing on top of it
 782                        git rev-list --parents -1 $rev | cut -d' ' -s -f2 > "$dropped"/$rev
 783                        short=$(git rev-list -1 --abbrev-commit --abbrev=7 $rev)
 784                        sane_grep -v "^[a-z][a-z]* $short" <"$todo" > "${todo}2" ; mv "${todo}2" "$todo"
 785                        rm "$rewritten"/$rev
 786                fi
 787        done
 788fi
 789
 790test -s "$todo" || echo noop >> "$todo"
 791test -n "$autosquash" && rearrange_squash "$todo"
 792cat >> "$todo" << EOF
 793
 794# Rebase $shortrevisions onto $shortonto
 795#
 796# Commands:
 797#  p, pick = use commit
 798#  r, reword = use commit, but edit the commit message
 799#  e, edit = use commit, but stop for amending
 800#  s, squash = use commit, but meld into previous commit
 801#  f, fixup = like "squash", but discard this commit's log message
 802#  x, exec = run command (the rest of the line) using shell
 803#
 804# If you remove a line here THAT COMMIT WILL BE LOST.
 805# However, if you remove everything, the rebase will be aborted.
 806#
 807EOF
 808
 809has_action "$todo" ||
 810        die_abort "Nothing to do"
 811
 812cp "$todo" "$todo".backup
 813git_editor "$todo" ||
 814        die_abort "Could not execute editor"
 815
 816has_action "$todo" ||
 817        die_abort "Nothing to do"
 818
 819test -d "$rewritten" || test -n "$force_rebase" || skip_unnecessary_picks
 820
 821output git checkout $onto || die_abort "could not detach HEAD"
 822git update-ref ORIG_HEAD $orig_head
 823do_rest