1# This shell script fragment is sourced by git-rebase to implement 2# its interactive mode. "git rebase --interactive" makes it easy 3# to fix up commits in the middle of a series and rearrange commits. 4# 5# Copyright (c) 2006 Johannes E. Schindelin 6# 7# The original idea comes from Eric W. Biederman, in 8# http://article.gmane.org/gmane.comp.version-control.git/22407 9# 10# The file containing rebase commands, comments, and empty lines. 11# This file is created by "git rebase -i" then edited by the user. As 12# the lines are processed, they are removed from the front of this 13# file and written to the tail of $done. 14todo="$state_dir"/git-rebase-todo 15 16# The rebase command lines that have already been processed. A line 17# is moved here when it is first handled, before any associated user 18# actions. 19done="$state_dir"/done 20 21# The commit message that is planned to be used for any changes that 22# need to be committed following a user interaction. 23msg="$state_dir"/message 24 25# The file into which is accumulated the suggested commit message for 26# squash/fixup commands. When the first of a series of squash/fixups 27# is seen, the file is created and the commit message from the 28# previous commit and from the first squash/fixup commit are written 29# to it. The commit message for each subsequent squash/fixup commit 30# is appended to the file as it is processed. 31# 32# The first line of the file is of the form 33# # This is a combination of $count commits. 34# where $count is the number of commits whose messages have been 35# written to the file so far (including the initial "pick" commit). 36# Each time that a commit message is processed, this line is read and 37# updated. It is deleted just before the combined commit is made. 38squash_msg="$state_dir"/message-squash 39 40# If the current series of squash/fixups has not yet included a squash 41# command, then this file exists and holds the commit message of the 42# original "pick" commit. (If the series ends without a "squash" 43# command, then this can be used as the commit message of the combined 44# commit without opening the editor.) 45fixup_msg="$state_dir"/message-fixup 46 47# $rewritten is the name of a directory containing files for each 48# commit that is reachable by at least one merge base of $head and 49# $upstream. They are not necessarily rewritten, but their children 50# might be. This ensures that commits on merged, but otherwise 51# unrelated side branches are left alone. (Think "X" in the man page's 52# example.) 53rewritten="$state_dir"/rewritten 54 55dropped="$state_dir"/dropped 56 57end="$state_dir"/end 58msgnum="$state_dir"/msgnum 59 60# A script to set the GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL, and 61# GIT_AUTHOR_DATE that will be used for the commit that is currently 62# being rebased. 63author_script="$state_dir"/author-script 64 65# When an "edit" rebase command is being processed, the SHA1 of the 66# commit to be edited is recorded in this file. When "git rebase 67# --continue" is executed, if there are any staged changes then they 68# will be amended to the HEAD commit, but only provided the HEAD 69# commit is still the commit to be edited. When any other rebase 70# command is processed, this file is deleted. 71amend="$state_dir"/amend 72 73# For the post-rewrite hook, we make a list of rewritten commits and 74# their new sha1s. The rewritten-pending list keeps the sha1s of 75# commits that have been processed, but not committed yet, 76# e.g. because they are waiting for a 'squash' command. 77rewritten_list="$state_dir"/rewritten-list 78rewritten_pending="$state_dir"/rewritten-pending 79 80# Work around Git for Windows' Bash whose "read" does not strip CRLF 81# and leaves CR at the end instead. 82cr=$(printf "\015") 83 84strategy_args=${strategy:+--strategy=$strategy} 85test -n "$strategy_opts" && 86eval ' 87 for strategy_opt in '"$strategy_opts"' 88 do 89 strategy_args="$strategy_args -X$(git rev-parse --sq-quote "${strategy_opt#--}")" 90 done 91' 92 93GIT_CHERRY_PICK_HELP="$resolvemsg" 94export GIT_CHERRY_PICK_HELP 95 96comment_char=$(git config --get core.commentchar 2>/dev/null) 97case "$comment_char" in 98'' | auto) 99 comment_char="#" 100 ;; 101?) 102 ;; 103*) 104 comment_char=$(echo "$comment_char" | cut -c1) 105 ;; 106esac 107 108warn () { 109 printf '%s\n' "$*" >&2 110} 111 112# Output the commit message for the specified commit. 113commit_message () { 114 git cat-file commit "$1" | sed "1,/^$/d" 115} 116 117orig_reflog_action="$GIT_REFLOG_ACTION" 118 119comment_for_reflog () { 120 case "$orig_reflog_action" in 121 ''|rebase*) 122 GIT_REFLOG_ACTION="rebase -i ($1)" 123 export GIT_REFLOG_ACTION 124 ;; 125 esac 126} 127 128last_count= 129mark_action_done () { 130 sed -e 1q < "$todo" >> "$done" 131 sed -e 1d < "$todo" >> "$todo".new 132 mv -f "$todo".new "$todo" 133 new_count=$(( $(git stripspace --strip-comments <"$done" | wc -l) )) 134 echo $new_count >"$msgnum" 135 total=$(($new_count + $(git stripspace --strip-comments <"$todo" | wc -l))) 136 echo $total >"$end" 137 if test "$last_count" != "$new_count" 138 then 139 last_count=$new_count 140 eval_gettext "Rebasing (\$new_count/\$total)"; printf "\r" 141 test -z "$verbose" || echo 142 fi 143} 144 145# Put the last action marked done at the beginning of the todo list 146# again. If there has not been an action marked done yet, leave the list of 147# items on the todo list unchanged. 148reschedule_last_action () { 149 tail -n 1 "$done" | cat - "$todo" >"$todo".new 150 sed -e \$d <"$done" >"$done".new 151 mv -f "$todo".new "$todo" 152 mv -f "$done".new "$done" 153} 154 155append_todo_help () { 156 gettext " 157Commands: 158 p, pick = use commit 159 r, reword = use commit, but edit the commit message 160 e, edit = use commit, but stop for amending 161 s, squash = use commit, but meld into previous commit 162 f, fixup = like \"squash\", but discard this commit's log message 163 x, exec = run command (the rest of the line) using shell 164 d, drop = remove commit 165 166These lines can be re-ordered; they are executed from top to bottom. 167" | git stripspace --comment-lines >>"$todo" 168 169 if test $(get_missing_commit_check_level) = error 170 then 171 gettext " 172Do not remove any line. Use 'drop' explicitly to remove a commit. 173" | git stripspace --comment-lines >>"$todo" 174 else 175 gettext " 176If you remove a line here THAT COMMIT WILL BE LOST. 177" | git stripspace --comment-lines >>"$todo" 178 fi 179} 180 181make_patch () { 182 sha1_and_parents="$(git rev-list --parents -1 "$1")" 183 case "$sha1_and_parents" in 184 ?*' '?*' '?*) 185 git diff --cc $sha1_and_parents 186 ;; 187 ?*' '?*) 188 git diff-tree -p "$1^!" 189 ;; 190 *) 191 echo "Root commit" 192 ;; 193 esac > "$state_dir"/patch 194 test -f "$msg" || 195 commit_message "$1" > "$msg" 196 test -f "$author_script" || 197 get_author_ident_from_commit "$1" > "$author_script" 198} 199 200die_with_patch () { 201 echo "$1" > "$state_dir"/stopped-sha 202 make_patch "$1" 203 die "$2" 204} 205 206exit_with_patch () { 207 echo "$1" > "$state_dir"/stopped-sha 208 make_patch $1 209 git rev-parse --verify HEAD > "$amend" 210 gpg_sign_opt_quoted=${gpg_sign_opt:+$(git rev-parse --sq-quote "$gpg_sign_opt")} 211 warn "$(eval_gettext "\ 212You can amend the commit now, with 213 214 git commit --amend \$gpg_sign_opt_quoted 215 216Once you are satisfied with your changes, run 217 218 git rebase --continue")" 219 warn 220 exit $2 221} 222 223die_abort () { 224 apply_autostash 225 rm -rf "$state_dir" 226 die "$1" 227} 228 229has_action () { 230 test -n "$(git stripspace --strip-comments <"$1")" 231} 232 233is_empty_commit() { 234 tree=$(git rev-parse -q --verify "$1"^{tree} 2>/dev/null) || { 235 sha1=$1 236 die "$(eval_gettext "\$sha1: not a commit that can be picked")" 237 } 238 ptree=$(git rev-parse -q --verify "$1"^^{tree} 2>/dev/null) || 239 ptree=4b825dc642cb6eb9a060e54bf8d69288fbee4904 240 test "$tree" = "$ptree" 241} 242 243is_merge_commit() 244{ 245 git rev-parse --verify --quiet "$1"^2 >/dev/null 2>&1 246} 247 248# Run command with GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL, and 249# GIT_AUTHOR_DATE exported from the current environment. 250do_with_author () { 251 ( 252 export GIT_AUTHOR_NAME GIT_AUTHOR_EMAIL GIT_AUTHOR_DATE 253 "$@" 254 ) 255} 256 257git_sequence_editor () { 258 if test -z "$GIT_SEQUENCE_EDITOR" 259 then 260 GIT_SEQUENCE_EDITOR="$(git config sequence.editor)" 261 if [ -z "$GIT_SEQUENCE_EDITOR" ] 262 then 263 GIT_SEQUENCE_EDITOR="$(git var GIT_EDITOR)" || return $? 264 fi 265 fi 266 267 eval "$GIT_SEQUENCE_EDITOR" '"$@"' 268} 269 270pick_one () { 271 ff=--ff 272 273 case "$1" in -n) sha1=$2; ff= ;; *) sha1=$1 ;; esac 274 case "$force_rebase" in '') ;; ?*) ff= ;; esac 275 output git rev-parse --verify $sha1 || die "$(eval_gettext "Invalid commit name: \$sha1")" 276 277 if is_empty_commit "$sha1" 278 then 279 empty_args="--allow-empty" 280 fi 281 282 test -d "$rewritten" && 283 pick_one_preserving_merges "$@" && return 284 output eval git cherry-pick \ 285 ${gpg_sign_opt:+$(git rev-parse --sq-quote "$gpg_sign_opt")} \ 286 "$strategy_args" $empty_args $ff "$@" 287 288 # If cherry-pick dies it leaves the to-be-picked commit unrecorded. Reschedule 289 # previous task so this commit is not lost. 290 ret=$? 291 case "$ret" in [01]) ;; *) reschedule_last_action ;; esac 292 return $ret 293} 294 295pick_one_preserving_merges () { 296 fast_forward=t 297 case "$1" in 298 -n) 299 fast_forward=f 300 sha1=$2 301 ;; 302 *) 303 sha1=$1 304 ;; 305 esac 306 sha1=$(git rev-parse $sha1) 307 308 if test -f "$state_dir"/current-commit 309 then 310 if test "$fast_forward" = t 311 then 312 while read current_commit 313 do 314 git rev-parse HEAD > "$rewritten"/$current_commit 315 done <"$state_dir"/current-commit 316 rm "$state_dir"/current-commit || 317 die "$(gettext "Cannot write current commit's replacement sha1")" 318 fi 319 fi 320 321 echo $sha1 >> "$state_dir"/current-commit 322 323 # rewrite parents; if none were rewritten, we can fast-forward. 324 new_parents= 325 pend=" $(git rev-list --parents -1 $sha1 | cut -d' ' -s -f2-)" 326 if test "$pend" = " " 327 then 328 pend=" root" 329 fi 330 while [ "$pend" != "" ] 331 do 332 p=$(expr "$pend" : ' \([^ ]*\)') 333 pend="${pend# $p}" 334 335 if test -f "$rewritten"/$p 336 then 337 new_p=$(cat "$rewritten"/$p) 338 339 # If the todo reordered commits, and our parent is marked for 340 # rewriting, but hasn't been gotten to yet, assume the user meant to 341 # drop it on top of the current HEAD 342 if test -z "$new_p" 343 then 344 new_p=$(git rev-parse HEAD) 345 fi 346 347 test $p != $new_p && fast_forward=f 348 case "$new_parents" in 349 *$new_p*) 350 ;; # do nothing; that parent is already there 351 *) 352 new_parents="$new_parents $new_p" 353 ;; 354 esac 355 else 356 if test -f "$dropped"/$p 357 then 358 fast_forward=f 359 replacement="$(cat "$dropped"/$p)" 360 test -z "$replacement" && replacement=root 361 pend=" $replacement$pend" 362 else 363 new_parents="$new_parents $p" 364 fi 365 fi 366 done 367 case $fast_forward in 368 t) 369 output warn "$(eval_gettext "Fast-forward to \$sha1")" 370 output git reset --hard $sha1 || 371 die "$(eval_gettext "Cannot fast-forward to \$sha1")" 372 ;; 373 f) 374 first_parent=$(expr "$new_parents" : ' \([^ ]*\)') 375 376 if [ "$1" != "-n" ] 377 then 378 # detach HEAD to current parent 379 output git checkout $first_parent 2> /dev/null || 380 die "$(eval_gettext "Cannot move HEAD to \$first_parent")" 381 fi 382 383 case "$new_parents" in 384 ' '*' '*) 385 test "a$1" = a-n && die "$(eval_gettext "Refusing to squash a merge: \$sha1")" 386 387 # redo merge 388 author_script_content=$(get_author_ident_from_commit $sha1) 389 eval "$author_script_content" 390 msg_content="$(commit_message $sha1)" 391 # No point in merging the first parent, that's HEAD 392 new_parents=${new_parents# $first_parent} 393 merge_args="--no-log --no-ff" 394 if ! do_with_author output eval \ 395 'git merge ${gpg_sign_opt:+"$gpg_sign_opt"} \ 396 $merge_args $strategy_args -m "$msg_content" $new_parents' 397 then 398 printf "%s\n" "$msg_content" > "$GIT_DIR"/MERGE_MSG 399 die_with_patch $sha1 "$(eval_gettext "Error redoing merge \$sha1")" 400 fi 401 echo "$sha1 $(git rev-parse HEAD^0)" >> "$rewritten_list" 402 ;; 403 *) 404 output eval git cherry-pick \ 405 ${gpg_sign_opt:+$(git rev-parse --sq-quote "$gpg_sign_opt")} \ 406 "$strategy_args" "$@" || 407 die_with_patch $sha1 "$(eval_gettext "Could not pick \$sha1")" 408 ;; 409 esac 410 ;; 411 esac 412} 413 414this_nth_commit_message () { 415 n=$1 416 eval_gettext "This is the commit message #\${n}:" 417} 418 419skip_nth_commit_message () { 420 n=$1 421 eval_gettext "The commit message #\${n} will be skipped:" 422} 423 424update_squash_messages () { 425 if test -f "$squash_msg"; then 426 mv "$squash_msg" "$squash_msg".bak || exit 427 count=$(($(sed -n \ 428 -e "1s/^$comment_char[^0-9]*\([0-9][0-9]*\).*/\1/p" \ 429 -e "q" < "$squash_msg".bak)+1)) 430 { 431 printf '%s\n' "$comment_char $(eval_ngettext \ 432 "This is a combination of \$count commit." \ 433 "This is a combination of \$count commits." \ 434 $count)" 435 sed -e 1d -e '2,/^./{ 436 /^$/d 437 }' <"$squash_msg".bak 438 } >"$squash_msg" 439 else 440 commit_message HEAD >"$fixup_msg" || 441 die "$(eval_gettext "Cannot write \$fixup_msg")" 442 count=2 443 { 444 printf '%s\n' "$comment_char $(gettext "This is a combination of 2 commits.")" 445 printf '%s\n' "$comment_char $(gettext "This is the 1st commit message:")" 446 echo 447 cat "$fixup_msg" 448 } >"$squash_msg" 449 fi 450 case $1 in 451 squash) 452 rm -f "$fixup_msg" 453 echo 454 printf '%s\n' "$comment_char $(this_nth_commit_message $count)" 455 echo 456 commit_message $2 457 ;; 458 fixup) 459 echo 460 printf '%s\n' "$comment_char $(skip_nth_commit_message $count)" 461 echo 462 # Change the space after the comment character to TAB: 463 commit_message $2 | git stripspace --comment-lines | sed -e 's/ / /' 464 ;; 465 esac >>"$squash_msg" 466} 467 468peek_next_command () { 469 git stripspace --strip-comments <"$todo" | sed -n -e 's/ .*//p' -e q 470} 471 472# A squash/fixup has failed. Prepare the long version of the squash 473# commit message, then die_with_patch. This code path requires the 474# user to edit the combined commit message for all commits that have 475# been squashed/fixedup so far. So also erase the old squash 476# messages, effectively causing the combined commit to be used as the 477# new basis for any further squash/fixups. Args: sha1 rest 478die_failed_squash() { 479 sha1=$1 480 rest=$2 481 mv "$squash_msg" "$msg" || exit 482 rm -f "$fixup_msg" 483 cp "$msg" "$GIT_DIR"/MERGE_MSG || exit 484 warn 485 warn "$(eval_gettext "Could not apply \$sha1... \$rest")" 486 die_with_patch $sha1 "" 487} 488 489flush_rewritten_pending() { 490 test -s "$rewritten_pending" || return 491 newsha1="$(git rev-parse HEAD^0)" 492 sed "s/$/ $newsha1/" < "$rewritten_pending" >> "$rewritten_list" 493 rm -f "$rewritten_pending" 494} 495 496record_in_rewritten() { 497 oldsha1="$(git rev-parse $1)" 498 echo "$oldsha1" >> "$rewritten_pending" 499 500 case "$(peek_next_command)" in 501 squash|s|fixup|f) 502 ;; 503 *) 504 flush_rewritten_pending 505 ;; 506 esac 507} 508 509do_pick () { 510 sha1=$1 511 rest=$2 512 if test "$(git rev-parse HEAD)" = "$squash_onto" 513 then 514 # Set the correct commit message and author info on the 515 # sentinel root before cherry-picking the original changes 516 # without committing (-n). Finally, update the sentinel again 517 # to include these changes. If the cherry-pick results in a 518 # conflict, this means our behaviour is similar to a standard 519 # failed cherry-pick during rebase, with a dirty index to 520 # resolve before manually running git commit --amend then git 521 # rebase --continue. 522 git commit --allow-empty --allow-empty-message --amend \ 523 --no-post-rewrite -n -q -C $sha1 && 524 pick_one -n $sha1 && 525 git commit --allow-empty --allow-empty-message \ 526 --amend --no-post-rewrite -n -q -C $sha1 \ 527 ${gpg_sign_opt:+"$gpg_sign_opt"} || 528 die_with_patch $sha1 "$(eval_gettext "Could not apply \$sha1... \$rest")" 529 else 530 pick_one $sha1 || 531 die_with_patch $sha1 "$(eval_gettext "Could not apply \$sha1... \$rest")" 532 fi 533} 534 535do_next () { 536 rm -f "$msg" "$author_script" "$amend" "$state_dir"/stopped-sha || exit 537 read -r command sha1 rest < "$todo" 538 case "$command" in 539 "$comment_char"*|''|noop|drop|d) 540 mark_action_done 541 ;; 542 "$cr") 543 # Work around CR left by "read" (e.g. with Git for Windows' Bash). 544 mark_action_done 545 ;; 546 pick|p) 547 comment_for_reflog pick 548 549 mark_action_done 550 do_pick $sha1 "$rest" 551 record_in_rewritten $sha1 552 ;; 553 reword|r) 554 comment_for_reflog reword 555 556 mark_action_done 557 do_pick $sha1 "$rest" 558 git commit --amend --no-post-rewrite ${gpg_sign_opt:+"$gpg_sign_opt"} || { 559 warn "$(eval_gettext "\ 560Could not amend commit after successfully picking \$sha1... \$rest 561This is most likely due to an empty commit message, or the pre-commit hook 562failed. If the pre-commit hook failed, you may need to resolve the issue before 563you are able to reword the commit.")" 564 exit_with_patch $sha1 1 565 } 566 record_in_rewritten $sha1 567 ;; 568 edit|e) 569 comment_for_reflog edit 570 571 mark_action_done 572 do_pick $sha1 "$rest" 573 sha1_abbrev=$(git rev-parse --short $sha1) 574 warn "$(eval_gettext "Stopped at \$sha1_abbrev... \$rest")" 575 exit_with_patch $sha1 0 576 ;; 577 squash|s|fixup|f) 578 case "$command" in 579 squash|s) 580 squash_style=squash 581 ;; 582 fixup|f) 583 squash_style=fixup 584 ;; 585 esac 586 comment_for_reflog $squash_style 587 588 test -f "$done" && has_action "$done" || 589 die "$(eval_gettext "Cannot '\$squash_style' without a previous commit")" 590 591 mark_action_done 592 update_squash_messages $squash_style $sha1 593 author_script_content=$(get_author_ident_from_commit HEAD) 594 echo "$author_script_content" > "$author_script" 595 eval "$author_script_content" 596 if ! pick_one -n $sha1 597 then 598 git rev-parse --verify HEAD >"$amend" 599 die_failed_squash $sha1 "$rest" 600 fi 601 case "$(peek_next_command)" in 602 squash|s|fixup|f) 603 # This is an intermediate commit; its message will only be 604 # used in case of trouble. So use the long version: 605 do_with_author output git commit --amend --no-verify -F "$squash_msg" \ 606 ${gpg_sign_opt:+"$gpg_sign_opt"} || 607 die_failed_squash $sha1 "$rest" 608 ;; 609 *) 610 # This is the final command of this squash/fixup group 611 if test -f "$fixup_msg" 612 then 613 do_with_author git commit --amend --no-verify -F "$fixup_msg" \ 614 ${gpg_sign_opt:+"$gpg_sign_opt"} || 615 die_failed_squash $sha1 "$rest" 616 else 617 cp "$squash_msg" "$GIT_DIR"/SQUASH_MSG || exit 618 rm -f "$GIT_DIR"/MERGE_MSG 619 do_with_author git commit --amend --no-verify -F "$GIT_DIR"/SQUASH_MSG -e \ 620 ${gpg_sign_opt:+"$gpg_sign_opt"} || 621 die_failed_squash $sha1 "$rest" 622 fi 623 rm -f "$squash_msg" "$fixup_msg" 624 ;; 625 esac 626 record_in_rewritten $sha1 627 ;; 628 x|"exec") 629 read -r command rest < "$todo" 630 mark_action_done 631 eval_gettextln "Executing: \$rest" 632 "${SHELL:-@SHELL_PATH@}" -c "$rest" # Actual execution 633 status=$? 634 # Run in subshell because require_clean_work_tree can die. 635 dirty=f 636 (require_clean_work_tree "rebase" 2>/dev/null) || dirty=t 637 if test "$status" -ne 0 638 then 639 warn "$(eval_gettext "Execution failed: \$rest")" 640 test "$dirty" = f || 641 warn "$(gettext "and made changes to the index and/or the working tree")" 642 643 warn "$(gettext "\ 644You can fix the problem, and then run 645 646 git rebase --continue")" 647 warn 648 if test $status -eq 127 # command not found 649 then 650 status=1 651 fi 652 exit "$status" 653 elif test "$dirty" = t 654 then 655 # TRANSLATORS: after these lines is a command to be issued by the user 656 warn "$(eval_gettext "\ 657Execution succeeded: \$rest 658but left changes to the index and/or the working tree 659Commit or stash your changes, and then run 660 661 git rebase --continue")" 662 warn 663 exit 1 664 fi 665 ;; 666 *) 667 warn "$(eval_gettext "Unknown command: \$command \$sha1 \$rest")" 668 fixtodo="$(gettext "Please fix this using 'git rebase --edit-todo'.")" 669 if git rev-parse --verify -q "$sha1" >/dev/null 670 then 671 die_with_patch $sha1 "$fixtodo" 672 else 673 die "$fixtodo" 674 fi 675 ;; 676 esac 677 test -s "$todo" && return 678 679 comment_for_reflog finish && 680 newhead=$(git rev-parse HEAD) && 681 case $head_name in 682 refs/*) 683 message="$GIT_REFLOG_ACTION: $head_name onto $onto" && 684 git update-ref -m "$message" $head_name $newhead $orig_head && 685 git symbolic-ref \ 686 -m "$GIT_REFLOG_ACTION: returning to $head_name" \ 687 HEAD $head_name 688 ;; 689 esac && { 690 test ! -f "$state_dir"/verbose || 691 git diff-tree --stat $orig_head..HEAD 692 } && 693 { 694 test -s "$rewritten_list" && 695 git notes copy --for-rewrite=rebase < "$rewritten_list" || 696 true # we don't care if this copying failed 697 } && 698 hook="$(git rev-parse --git-path hooks/post-rewrite)" 699 if test -x "$hook" && test -s "$rewritten_list"; then 700 "$hook" rebase < "$rewritten_list" 701 true # we don't care if this hook failed 702 fi && 703 warn "$(eval_gettext "Successfully rebased and updated \$head_name.")" 704 705 return 1 # not failure; just to break the do_rest loop 706} 707 708# can only return 0, when the infinite loop breaks 709do_rest () { 710 while : 711 do 712 do_next || break 713 done 714} 715 716# skip picking commits whose parents are unchanged 717skip_unnecessary_picks () { 718 fd=3 719 while read -r command rest 720 do 721 # fd=3 means we skip the command 722 case "$fd,$command" in 723 3,pick|3,p) 724 # pick a commit whose parent is current $onto -> skip 725 sha1=${rest%% *} 726 case "$(git rev-parse --verify --quiet "$sha1"^)" in 727 "$onto"*) 728 onto=$sha1 729 ;; 730 *) 731 fd=1 732 ;; 733 esac 734 ;; 735 3,"$comment_char"*|3,) 736 # copy comments 737 ;; 738 *) 739 fd=1 740 ;; 741 esac 742 printf '%s\n' "$command${rest:+ }$rest" >&$fd 743 done <"$todo" >"$todo.new" 3>>"$done" && 744 mv -f "$todo".new "$todo" && 745 case "$(peek_next_command)" in 746 squash|s|fixup|f) 747 record_in_rewritten "$onto" 748 ;; 749 esac || 750 die "$(gettext "Could not skip unnecessary pick commands")" 751} 752 753transform_todo_ids () { 754 while read -r command rest 755 do 756 case "$command" in 757 "$comment_char"* | exec) 758 # Be careful for oddball commands like 'exec' 759 # that do not have a SHA-1 at the beginning of $rest. 760 ;; 761 *) 762 sha1=$(git rev-parse --verify --quiet "$@" ${rest%%[ ]*}) && 763 rest="$sha1 ${rest#*[ ]}" 764 ;; 765 esac 766 printf '%s\n' "$command${rest:+ }$rest" 767 done <"$todo" >"$todo.new" && 768 mv -f "$todo.new" "$todo" 769} 770 771expand_todo_ids() { 772 transform_todo_ids 773} 774 775collapse_todo_ids() { 776 transform_todo_ids --short 777} 778 779# Rearrange the todo list that has both "pick sha1 msg" and 780# "pick sha1 fixup!/squash! msg" appears in it so that the latter 781# comes immediately after the former, and change "pick" to 782# "fixup"/"squash". 783# 784# Note that if the config has specified a custom instruction format 785# each log message will be re-retrieved in order to normalize the 786# autosquash arrangement 787rearrange_squash () { 788 # extract fixup!/squash! lines and resolve any referenced sha1's 789 while read -r pick sha1 message 790 do 791 test -z "${format}" || message=$(git log -n 1 --format="%s" ${sha1}) 792 case "$message" in 793 "squash! "*|"fixup! "*) 794 action="${message%%!*}" 795 rest=$message 796 prefix= 797 # skip all squash! or fixup! (but save for later) 798 while : 799 do 800 case "$rest" in 801 "squash! "*|"fixup! "*) 802 prefix="$prefix${rest%%!*}," 803 rest="${rest#*! }" 804 ;; 805 *) 806 break 807 ;; 808 esac 809 done 810 printf '%s %s %s %s\n' "$sha1" "$action" "$prefix" "$rest" 811 # if it's a single word, try to resolve to a full sha1 and 812 # emit a second copy. This allows us to match on both message 813 # and on sha1 prefix 814 if test "${rest#* }" = "$rest"; then 815 fullsha="$(git rev-parse -q --verify "$rest" 2>/dev/null)" 816 if test -n "$fullsha"; then 817 # prefix the action to uniquely identify this line as 818 # intended for full sha1 match 819 echo "$sha1 +$action $prefix $fullsha" 820 fi 821 fi 822 esac 823 done >"$1.sq" <"$1" 824 test -s "$1.sq" || return 825 826 used= 827 while read -r pick sha1 message 828 do 829 case " $used" in 830 *" $sha1 "*) continue ;; 831 esac 832 printf '%s\n' "$pick $sha1 $message" 833 test -z "${format}" || message=$(git log -n 1 --format="%s" ${sha1}) 834 used="$used$sha1 " 835 while read -r squash action msg_prefix msg_content 836 do 837 case " $used" in 838 *" $squash "*) continue ;; 839 esac 840 emit=0 841 case "$action" in 842 +*) 843 action="${action#+}" 844 # full sha1 prefix test 845 case "$msg_content" in "$sha1"*) emit=1;; esac ;; 846 *) 847 # message prefix test 848 case "$message" in "$msg_content"*) emit=1;; esac ;; 849 esac 850 if test $emit = 1; then 851 if test -n "${format}" 852 then 853 msg_content=$(git log -n 1 --format="${format}" ${squash}) 854 else 855 msg_content="$(echo "$msg_prefix" | sed "s/,/! /g")$msg_content" 856 fi 857 printf '%s\n' "$action $squash $msg_content" 858 used="$used$squash " 859 fi 860 done <"$1.sq" 861 done >"$1.rearranged" <"$1" 862 cat "$1.rearranged" >"$1" 863 rm -f "$1.sq" "$1.rearranged" 864} 865 866# Add commands after a pick or after a squash/fixup serie 867# in the todo list. 868add_exec_commands () { 869 { 870 first=t 871 while read -r insn rest 872 do 873 case $insn in 874 pick) 875 test -n "$first" || 876 printf "%s" "$cmd" 877 ;; 878 esac 879 printf "%s %s\n" "$insn" "$rest" 880 first= 881 done 882 printf "%s" "$cmd" 883 } <"$1" >"$1.new" && 884 mv "$1.new" "$1" 885} 886 887# Check if the SHA-1 passed as an argument is a 888# correct one, if not then print $2 in "$todo".badsha 889# $1: the SHA-1 to test 890# $2: the line number of the input 891# $3: the input filename 892check_commit_sha () { 893 badsha=0 894 if test -z "$1" 895 then 896 badsha=1 897 else 898 sha1_verif="$(git rev-parse --verify --quiet $1^{commit})" 899 if test -z "$sha1_verif" 900 then 901 badsha=1 902 fi 903 fi 904 905 if test $badsha -ne 0 906 then 907 line="$(sed -n -e "${2}p" "$3")" 908 warn "$(eval_gettext "\ 909Warning: the SHA-1 is missing or isn't a commit in the following line: 910 - \$line")" 911 warn 912 fi 913 914 return $badsha 915} 916 917# prints the bad commits and bad commands 918# from the todolist in stdin 919check_bad_cmd_and_sha () { 920 retval=0 921 lineno=0 922 while read -r command rest 923 do 924 lineno=$(( $lineno + 1 )) 925 case $command in 926 "$comment_char"*|''|noop|x|exec) 927 # Doesn't expect a SHA-1 928 ;; 929 "$cr") 930 # Work around CR left by "read" (e.g. with Git for 931 # Windows' Bash). 932 ;; 933 pick|p|drop|d|reword|r|edit|e|squash|s|fixup|f) 934 if ! check_commit_sha "${rest%%[ ]*}" "$lineno" "$1" 935 then 936 retval=1 937 fi 938 ;; 939 *) 940 line="$(sed -n -e "${lineno}p" "$1")" 941 warn "$(eval_gettext "\ 942Warning: the command isn't recognized in the following line: 943 - \$line")" 944 warn 945 retval=1 946 ;; 947 esac 948 done <"$1" 949 return $retval 950} 951 952# Print the list of the SHA-1 of the commits 953# from stdin to stdout 954todo_list_to_sha_list () { 955 git stripspace --strip-comments | 956 while read -r command sha1 rest 957 do 958 case $command in 959 "$comment_char"*|''|noop|x|"exec") 960 ;; 961 *) 962 long_sha=$(git rev-list --no-walk "$sha1" 2>/dev/null) 963 printf "%s\n" "$long_sha" 964 ;; 965 esac 966 done 967} 968 969# Use warn for each line in stdin 970warn_lines () { 971 while read -r line 972 do 973 warn " - $line" 974 done 975} 976 977# Switch to the branch in $into and notify it in the reflog 978checkout_onto () { 979 GIT_REFLOG_ACTION="$GIT_REFLOG_ACTION: checkout $onto_name" 980 output git checkout $onto || die_abort "$(gettext "could not detach HEAD")" 981 git update-ref ORIG_HEAD $orig_head 982} 983 984get_missing_commit_check_level () { 985 check_level=$(git config --get rebase.missingCommitsCheck) 986 check_level=${check_level:-ignore} 987 # Don't be case sensitive 988 printf '%s' "$check_level" | tr 'A-Z' 'a-z' 989} 990 991# Check if the user dropped some commits by mistake 992# Behaviour determined by rebase.missingCommitsCheck. 993# Check if there is an unrecognized command or a 994# bad SHA-1 in a command. 995check_todo_list () { 996 raise_error=f 997 998 check_level=$(get_missing_commit_check_level) 9991000 case "$check_level" in1001 warn|error)1002 # Get the SHA-1 of the commits1003 todo_list_to_sha_list <"$todo".backup >"$todo".oldsha11004 todo_list_to_sha_list <"$todo" >"$todo".newsha110051006 # Sort the SHA-1 and compare them1007 sort -u "$todo".oldsha1 >"$todo".oldsha1+1008 mv "$todo".oldsha1+ "$todo".oldsha11009 sort -u "$todo".newsha1 >"$todo".newsha1+1010 mv "$todo".newsha1+ "$todo".newsha11011 comm -2 -3 "$todo".oldsha1 "$todo".newsha1 >"$todo".miss10121013 # Warn about missing commits1014 if test -s "$todo".miss1015 then1016 test "$check_level" = error && raise_error=t10171018 warn "$(gettext "\1019Warning: some commits may have been dropped accidentally.1020Dropped commits (newer to older):")"10211022 # Make the list user-friendly and display1023 opt="--no-walk=sorted --format=oneline --abbrev-commit --stdin"1024 git rev-list $opt <"$todo".miss | warn_lines10251026 warn "$(gettext "\1027To avoid this message, use \"drop\" to explicitly remove a commit.10281029Use 'git config rebase.missingCommitsCheck' to change the level of warnings.1030The possible behaviours are: ignore, warn, error.")"1031 warn1032 fi1033 ;;1034 ignore)1035 ;;1036 *)1037 warn "$(eval_gettext "Unrecognized setting \$check_level for option rebase.missingCommitsCheck. Ignoring.")"1038 ;;1039 esac10401041 if ! check_bad_cmd_and_sha "$todo"1042 then1043 raise_error=t1044 fi10451046 if test $raise_error = t1047 then1048 # Checkout before the first commit of the1049 # rebase: this way git rebase --continue1050 # will work correctly as it expects HEAD to be1051 # placed before the commit of the next action1052 checkout_onto10531054 warn "$(gettext "You can fix this with 'git rebase --edit-todo' and then run 'git rebase --continue'.")"1055 die "$(gettext "Or you can abort the rebase with 'git rebase --abort'.")"1056 fi1057}10581059# The whole contents of this file is run by dot-sourcing it from1060# inside a shell function. It used to be that "return"s we see1061# below were not inside any function, and expected to return1062# to the function that dot-sourced us.1063#1064# However, older (9.x) versions of FreeBSD /bin/sh misbehave on such a1065# construct and continue to run the statements that follow such a "return".1066# As a work-around, we introduce an extra layer of a function1067# here, and immediately call it after defining it.1068git_rebase__interactive () {10691070case "$action" in1071continue)1072 # do we have anything to commit?1073 if git diff-index --cached --quiet HEAD --1074 then1075 # Nothing to commit -- skip this commit10761077 test ! -f "$GIT_DIR"/CHERRY_PICK_HEAD ||1078 rm "$GIT_DIR"/CHERRY_PICK_HEAD ||1079 die "$(gettext "Could not remove CHERRY_PICK_HEAD")"1080 else1081 if ! test -f "$author_script"1082 then1083 gpg_sign_opt_quoted=${gpg_sign_opt:+$(git rev-parse --sq-quote "$gpg_sign_opt")}1084 die "$(eval_gettext "\1085You have staged changes in your working tree.1086If these changes are meant to be1087squashed into the previous commit, run:10881089 git commit --amend \$gpg_sign_opt_quoted10901091If they are meant to go into a new commit, run:10921093 git commit \$gpg_sign_opt_quoted10941095In both cases, once you're done, continue with:10961097 git rebase --continue1098")"1099 fi1100 . "$author_script" ||1101 die "$(gettext "Error trying to find the author identity to amend commit")"1102 if test -f "$amend"1103 then1104 current_head=$(git rev-parse --verify HEAD)1105 test "$current_head" = $(cat "$amend") ||1106 die "$(gettext "\1107You have uncommitted changes in your working tree. Please commit them1108first and then run 'git rebase --continue' again.")"1109 do_with_author git commit --amend --no-verify -F "$msg" -e \1110 ${gpg_sign_opt:+"$gpg_sign_opt"} ||1111 die "$(gettext "Could not commit staged changes.")"1112 else1113 do_with_author git commit --no-verify -F "$msg" -e \1114 ${gpg_sign_opt:+"$gpg_sign_opt"} ||1115 die "$(gettext "Could not commit staged changes.")"1116 fi1117 fi11181119 if test -r "$state_dir"/stopped-sha1120 then1121 record_in_rewritten "$(cat "$state_dir"/stopped-sha)"1122 fi11231124 require_clean_work_tree "rebase"1125 do_rest1126 return 01127 ;;1128skip)1129 git rerere clear11301131 do_rest1132 return 01133 ;;1134edit-todo)1135 git stripspace --strip-comments <"$todo" >"$todo".new1136 mv -f "$todo".new "$todo"1137 collapse_todo_ids1138 append_todo_help1139 gettext "1140You are editing the todo file of an ongoing interactive rebase.1141To continue rebase after editing, run:1142 git rebase --continue11431144" | git stripspace --comment-lines >>"$todo"11451146 git_sequence_editor "$todo" ||1147 die "$(gettext "Could not execute editor")"1148 expand_todo_ids11491150 exit1151 ;;1152esac11531154comment_for_reflog start11551156if test ! -z "$switch_to"1157then1158 GIT_REFLOG_ACTION="$GIT_REFLOG_ACTION: checkout $switch_to"1159 output git checkout "$switch_to" -- ||1160 die "$(eval_gettext "Could not checkout \$switch_to")"11611162 comment_for_reflog start1163fi11641165orig_head=$(git rev-parse --verify HEAD) || die "$(gettext "No HEAD?")"1166mkdir -p "$state_dir" || die "$(eval_gettext "Could not create temporary \$state_dir")"11671168: > "$state_dir"/interactive || die "$(gettext "Could not mark as interactive")"1169write_basic_state1170if test t = "$preserve_merges"1171then1172 if test -z "$rebase_root"1173 then1174 mkdir "$rewritten" &&1175 for c in $(git merge-base --all $orig_head $upstream)1176 do1177 echo $onto > "$rewritten"/$c ||1178 die "$(gettext "Could not init rewritten commits")"1179 done1180 else1181 mkdir "$rewritten" &&1182 echo $onto > "$rewritten"/root ||1183 die "$(gettext "Could not init rewritten commits")"1184 fi1185 # No cherry-pick because our first pass is to determine1186 # parents to rewrite and skipping dropped commits would1187 # prematurely end our probe1188 merges_option=1189else1190 merges_option="--no-merges --cherry-pick"1191fi11921193shorthead=$(git rev-parse --short $orig_head)1194shortonto=$(git rev-parse --short $onto)1195if test -z "$rebase_root"1196 # this is now equivalent to ! -z "$upstream"1197then1198 shortupstream=$(git rev-parse --short $upstream)1199 revisions=$upstream...$orig_head1200 shortrevisions=$shortupstream..$shorthead1201else1202 revisions=$onto...$orig_head1203 shortrevisions=$shorthead1204fi1205format=$(git config --get rebase.instructionFormat)1206# the 'rev-list .. | sed' requires %m to parse; the instruction requires %H to parse1207git rev-list $merges_option --format="%m%H ${format:-%s}" \1208 --reverse --left-right --topo-order \1209 $revisions ${restrict_revision+^$restrict_revision} | \1210 sed -n "s/^>//p" |1211while read -r sha1 rest1212do12131214 if test -z "$keep_empty" && is_empty_commit $sha1 && ! is_merge_commit $sha11215 then1216 comment_out="$comment_char "1217 else1218 comment_out=1219 fi12201221 if test t != "$preserve_merges"1222 then1223 printf '%s\n' "${comment_out}pick $sha1 $rest" >>"$todo"1224 else1225 if test -z "$rebase_root"1226 then1227 preserve=t1228 for p in $(git rev-list --parents -1 $sha1 | cut -d' ' -s -f2-)1229 do1230 if test -f "$rewritten"/$p1231 then1232 preserve=f1233 fi1234 done1235 else1236 preserve=f1237 fi1238 if test f = "$preserve"1239 then1240 touch "$rewritten"/$sha11241 printf '%s\n' "${comment_out}pick $sha1 $rest" >>"$todo"1242 fi1243 fi1244done12451246# Watch for commits that been dropped by --cherry-pick1247if test t = "$preserve_merges"1248then1249 mkdir "$dropped"1250 # Save all non-cherry-picked changes1251 git rev-list $revisions --left-right --cherry-pick | \1252 sed -n "s/^>//p" > "$state_dir"/not-cherry-picks1253 # Now all commits and note which ones are missing in1254 # not-cherry-picks and hence being dropped1255 git rev-list $revisions |1256 while read rev1257 do1258 if test -f "$rewritten"/$rev &&1259 ! sane_grep "$rev" "$state_dir"/not-cherry-picks >/dev/null1260 then1261 # Use -f2 because if rev-list is telling us this commit is1262 # not worthwhile, we don't want to track its multiple heads,1263 # just the history of its first-parent for others that will1264 # be rebasing on top of it1265 git rev-list --parents -1 $rev | cut -d' ' -s -f2 > "$dropped"/$rev1266 sha1=$(git rev-list -1 $rev)1267 sane_grep -v "^[a-z][a-z]* $sha1" <"$todo" > "${todo}2" ; mv "${todo}2" "$todo"1268 rm "$rewritten"/$rev1269 fi1270 done1271fi12721273test -s "$todo" || echo noop >> "$todo"1274test -n "$autosquash" && rearrange_squash "$todo"1275test -n "$cmd" && add_exec_commands "$todo"12761277todocount=$(git stripspace --strip-comments <"$todo" | wc -l)1278todocount=${todocount##* }12791280cat >>"$todo" <<EOF12811282$comment_char $(eval_ngettext \1283 "Rebase \$shortrevisions onto \$shortonto (\$todocount command)" \1284 "Rebase \$shortrevisions onto \$shortonto (\$todocount commands)" \1285 "$todocount")1286EOF1287append_todo_help1288gettext "1289However, if you remove everything, the rebase will be aborted.12901291" | git stripspace --comment-lines >>"$todo"12921293if test -z "$keep_empty"1294then1295 printf '%s\n' "$comment_char $(gettext "Note that empty commits are commented out")" >>"$todo"1296fi129712981299has_action "$todo" ||1300 return 213011302cp "$todo" "$todo".backup1303collapse_todo_ids1304git_sequence_editor "$todo" ||1305 die_abort "$(gettext "Could not execute editor")"13061307has_action "$todo" ||1308 return 213091310check_todo_list13111312expand_todo_ids13131314test -d "$rewritten" || test -n "$force_rebase" || skip_unnecessary_picks13151316checkout_onto1317do_rest13181319}1320# ... and then we call the whole thing.1321git_rebase__interactive