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