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# https://public-inbox.org/git/m1odwkyuf5.fsf_-_@ebiederm.dsl.xmission.com/ 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 format=$(git config --get rebase.instructionFormat) 789 # extract fixup!/squash! lines and resolve any referenced sha1's 790 while read -r pick sha1 message 791 do 792 test -z "${format}" || message=$(git log -n 1 --format="%s" ${sha1}) 793 case "$message" in 794 "squash! "*|"fixup! "*) 795 action="${message%%!*}" 796 rest=$message 797 prefix= 798 # skip all squash! or fixup! (but save for later) 799 while : 800 do 801 case "$rest" in 802 "squash! "*|"fixup! "*) 803 prefix="$prefix${rest%%!*}," 804 rest="${rest#*! }" 805 ;; 806 *) 807 break 808 ;; 809 esac 810 done 811 printf '%s %s %s %s\n' "$sha1" "$action" "$prefix" "$rest" 812 # if it's a single word, try to resolve to a full sha1 and 813 # emit a second copy. This allows us to match on both message 814 # and on sha1 prefix 815 if test "${rest#* }" = "$rest"; then 816 fullsha="$(git rev-parse -q --verify "$rest" 2>/dev/null)" 817 if test -n "$fullsha"; then 818 # prefix the action to uniquely identify this line as 819 # intended for full sha1 match 820 echo "$sha1 +$action $prefix $fullsha" 821 fi 822 fi 823 esac 824 done >"$1.sq" <"$1" 825 test -s "$1.sq" || return 826 827 used= 828 while read -r pick sha1 message 829 do 830 case " $used" in 831 *" $sha1 "*) continue ;; 832 esac 833 printf '%s\n' "$pick $sha1 $message" 834 test -z "${format}" || message=$(git log -n 1 --format="%s" ${sha1}) 835 used="$used$sha1 " 836 while read -r squash action msg_prefix msg_content 837 do 838 case " $used" in 839 *" $squash "*) continue ;; 840 esac 841 emit=0 842 case "$action" in 843 +*) 844 action="${action#+}" 845 # full sha1 prefix test 846 case "$msg_content" in "$sha1"*) emit=1;; esac ;; 847 *) 848 # message prefix test 849 case "$message" in "$msg_content"*) emit=1;; esac ;; 850 esac 851 if test $emit = 1; then 852 if test -n "${format}" 853 then 854 msg_content=$(git log -n 1 --format="${format}" ${squash}) 855 else 856 msg_content="$(echo "$msg_prefix" | sed "s/,/! /g")$msg_content" 857 fi 858 printf '%s\n' "$action $squash $msg_content" 859 used="$used$squash " 860 fi 861 done <"$1.sq" 862 done >"$1.rearranged" <"$1" 863 cat "$1.rearranged" >"$1" 864 rm -f "$1.sq" "$1.rearranged" 865} 866 867# Add commands after a pick or after a squash/fixup serie 868# in the todo list. 869add_exec_commands () { 870 { 871 first=t 872 while read -r insn rest 873 do 874 case $insn in 875 pick) 876 test -n "$first" || 877 printf "%s" "$cmd" 878 ;; 879 esac 880 printf "%s %s\n" "$insn" "$rest" 881 first= 882 done 883 printf "%s" "$cmd" 884 } <"$1" >"$1.new" && 885 mv "$1.new" "$1" 886} 887 888# Check if the SHA-1 passed as an argument is a 889# correct one, if not then print $2 in "$todo".badsha 890# $1: the SHA-1 to test 891# $2: the line number of the input 892# $3: the input filename 893check_commit_sha () { 894 badsha=0 895 if test -z "$1" 896 then 897 badsha=1 898 else 899 sha1_verif="$(git rev-parse --verify --quiet $1^{commit})" 900 if test -z "$sha1_verif" 901 then 902 badsha=1 903 fi 904 fi 905 906 if test $badsha -ne 0 907 then 908 line="$(sed -n -e "${2}p" "$3")" 909 warn "$(eval_gettext "\ 910Warning: the SHA-1 is missing or isn't a commit in the following line: 911 - \$line")" 912 warn 913 fi 914 915 return $badsha 916} 917 918# prints the bad commits and bad commands 919# from the todolist in stdin 920check_bad_cmd_and_sha () { 921 retval=0 922 lineno=0 923 while read -r command rest 924 do 925 lineno=$(( $lineno + 1 )) 926 case $command in 927 "$comment_char"*|''|noop|x|exec) 928 # Doesn't expect a SHA-1 929 ;; 930 "$cr") 931 # Work around CR left by "read" (e.g. with Git for 932 # Windows' Bash). 933 ;; 934 pick|p|drop|d|reword|r|edit|e|squash|s|fixup|f) 935 if ! check_commit_sha "${rest%%[ ]*}" "$lineno" "$1" 936 then 937 retval=1 938 fi 939 ;; 940 *) 941 line="$(sed -n -e "${lineno}p" "$1")" 942 warn "$(eval_gettext "\ 943Warning: the command isn't recognized in the following line: 944 - \$line")" 945 warn 946 retval=1 947 ;; 948 esac 949 done <"$1" 950 return $retval 951} 952 953# Print the list of the SHA-1 of the commits 954# from stdin to stdout 955todo_list_to_sha_list () { 956 git stripspace --strip-comments | 957 while read -r command sha1 rest 958 do 959 case $command in 960 "$comment_char"*|''|noop|x|"exec") 961 ;; 962 *) 963 long_sha=$(git rev-list --no-walk "$sha1" 2>/dev/null) 964 printf "%s\n" "$long_sha" 965 ;; 966 esac 967 done 968} 969 970# Use warn for each line in stdin 971warn_lines () { 972 while read -r line 973 do 974 warn " - $line" 975 done 976} 977 978# Switch to the branch in $into and notify it in the reflog 979checkout_onto () { 980 GIT_REFLOG_ACTION="$GIT_REFLOG_ACTION: checkout $onto_name" 981 output git checkout $onto || die_abort "$(gettext "could not detach HEAD")" 982 git update-ref ORIG_HEAD $orig_head 983} 984 985get_missing_commit_check_level () { 986 check_level=$(git config --get rebase.missingCommitsCheck) 987 check_level=${check_level:-ignore} 988 # Don't be case sensitive 989 printf '%s' "$check_level" | tr 'A-Z' 'a-z' 990} 991 992# Check if the user dropped some commits by mistake 993# Behaviour determined by rebase.missingCommitsCheck. 994# Check if there is an unrecognized command or a 995# bad SHA-1 in a command. 996check_todo_list () { 997 raise_error=f 998 999 check_level=$(get_missing_commit_check_level)10001001 case "$check_level" in1002 warn|error)1003 # Get the SHA-1 of the commits1004 todo_list_to_sha_list <"$todo".backup >"$todo".oldsha11005 todo_list_to_sha_list <"$todo" >"$todo".newsha110061007 # Sort the SHA-1 and compare them1008 sort -u "$todo".oldsha1 >"$todo".oldsha1+1009 mv "$todo".oldsha1+ "$todo".oldsha11010 sort -u "$todo".newsha1 >"$todo".newsha1+1011 mv "$todo".newsha1+ "$todo".newsha11012 comm -2 -3 "$todo".oldsha1 "$todo".newsha1 >"$todo".miss10131014 # Warn about missing commits1015 if test -s "$todo".miss1016 then1017 test "$check_level" = error && raise_error=t10181019 warn "$(gettext "\1020Warning: some commits may have been dropped accidentally.1021Dropped commits (newer to older):")"10221023 # Make the list user-friendly and display1024 opt="--no-walk=sorted --format=oneline --abbrev-commit --stdin"1025 git rev-list $opt <"$todo".miss | warn_lines10261027 warn "$(gettext "\1028To avoid this message, use \"drop\" to explicitly remove a commit.10291030Use 'git config rebase.missingCommitsCheck' to change the level of warnings.1031The possible behaviours are: ignore, warn, error.")"1032 warn1033 fi1034 ;;1035 ignore)1036 ;;1037 *)1038 warn "$(eval_gettext "Unrecognized setting \$check_level for option rebase.missingCommitsCheck. Ignoring.")"1039 ;;1040 esac10411042 if ! check_bad_cmd_and_sha "$todo"1043 then1044 raise_error=t1045 fi10461047 if test $raise_error = t1048 then1049 # Checkout before the first commit of the1050 # rebase: this way git rebase --continue1051 # will work correctly as it expects HEAD to be1052 # placed before the commit of the next action1053 checkout_onto10541055 warn "$(gettext "You can fix this with 'git rebase --edit-todo' and then run 'git rebase --continue'.")"1056 die "$(gettext "Or you can abort the rebase with 'git rebase --abort'.")"1057 fi1058}10591060# The whole contents of this file is run by dot-sourcing it from1061# inside a shell function. It used to be that "return"s we see1062# below were not inside any function, and expected to return1063# to the function that dot-sourced us.1064#1065# However, older (9.x) versions of FreeBSD /bin/sh misbehave on such a1066# construct and continue to run the statements that follow such a "return".1067# As a work-around, we introduce an extra layer of a function1068# here, and immediately call it after defining it.1069git_rebase__interactive () {10701071case "$action" in1072continue)1073 if test ! -d "$rewritten"1074 then1075 exec git rebase--helper ${force_rebase:+--no-ff} --continue1076 fi1077 # do we have anything to commit?1078 if git diff-index --cached --quiet HEAD --1079 then1080 # Nothing to commit -- skip this commit10811082 test ! -f "$GIT_DIR"/CHERRY_PICK_HEAD ||1083 rm "$GIT_DIR"/CHERRY_PICK_HEAD ||1084 die "$(gettext "Could not remove CHERRY_PICK_HEAD")"1085 else1086 if ! test -f "$author_script"1087 then1088 gpg_sign_opt_quoted=${gpg_sign_opt:+$(git rev-parse --sq-quote "$gpg_sign_opt")}1089 die "$(eval_gettext "\1090You have staged changes in your working tree.1091If these changes are meant to be1092squashed into the previous commit, run:10931094 git commit --amend \$gpg_sign_opt_quoted10951096If they are meant to go into a new commit, run:10971098 git commit \$gpg_sign_opt_quoted10991100In both cases, once you're done, continue with:11011102 git rebase --continue1103")"1104 fi1105 . "$author_script" ||1106 die "$(gettext "Error trying to find the author identity to amend commit")"1107 if test -f "$amend"1108 then1109 current_head=$(git rev-parse --verify HEAD)1110 test "$current_head" = $(cat "$amend") ||1111 die "$(gettext "\1112You have uncommitted changes in your working tree. Please commit them1113first and then run 'git rebase --continue' again.")"1114 do_with_author git commit --amend --no-verify -F "$msg" -e \1115 ${gpg_sign_opt:+"$gpg_sign_opt"} ||1116 die "$(gettext "Could not commit staged changes.")"1117 else1118 do_with_author git commit --no-verify -F "$msg" -e \1119 ${gpg_sign_opt:+"$gpg_sign_opt"} ||1120 die "$(gettext "Could not commit staged changes.")"1121 fi1122 fi11231124 if test -r "$state_dir"/stopped-sha1125 then1126 record_in_rewritten "$(cat "$state_dir"/stopped-sha)"1127 fi11281129 require_clean_work_tree "rebase"1130 do_rest1131 return 01132 ;;1133skip)1134 git rerere clear11351136 if test ! -d "$rewritten"1137 then1138 exec git rebase--helper ${force_rebase:+--no-ff} --continue1139 fi1140 do_rest1141 return 01142 ;;1143edit-todo)1144 git stripspace --strip-comments <"$todo" >"$todo".new1145 mv -f "$todo".new "$todo"1146 collapse_todo_ids1147 append_todo_help1148 gettext "1149You are editing the todo file of an ongoing interactive rebase.1150To continue rebase after editing, run:1151 git rebase --continue11521153" | git stripspace --comment-lines >>"$todo"11541155 git_sequence_editor "$todo" ||1156 die "$(gettext "Could not execute editor")"1157 expand_todo_ids11581159 exit1160 ;;1161esac11621163comment_for_reflog start11641165if test ! -z "$switch_to"1166then1167 GIT_REFLOG_ACTION="$GIT_REFLOG_ACTION: checkout $switch_to"1168 output git checkout "$switch_to" -- ||1169 die "$(eval_gettext "Could not checkout \$switch_to")"11701171 comment_for_reflog start1172fi11731174orig_head=$(git rev-parse --verify HEAD) || die "$(gettext "No HEAD?")"1175mkdir -p "$state_dir" || die "$(eval_gettext "Could not create temporary \$state_dir")"11761177: > "$state_dir"/interactive || die "$(gettext "Could not mark as interactive")"1178write_basic_state1179if test t = "$preserve_merges"1180then1181 if test -z "$rebase_root"1182 then1183 mkdir "$rewritten" &&1184 for c in $(git merge-base --all $orig_head $upstream)1185 do1186 echo $onto > "$rewritten"/$c ||1187 die "$(gettext "Could not init rewritten commits")"1188 done1189 else1190 mkdir "$rewritten" &&1191 echo $onto > "$rewritten"/root ||1192 die "$(gettext "Could not init rewritten commits")"1193 fi1194 # No cherry-pick because our first pass is to determine1195 # parents to rewrite and skipping dropped commits would1196 # prematurely end our probe1197 merges_option=1198else1199 merges_option="--no-merges --cherry-pick"1200fi12011202shorthead=$(git rev-parse --short $orig_head)1203shortonto=$(git rev-parse --short $onto)1204if test -z "$rebase_root"1205 # this is now equivalent to ! -z "$upstream"1206then1207 shortupstream=$(git rev-parse --short $upstream)1208 revisions=$upstream...$orig_head1209 shortrevisions=$shortupstream..$shorthead1210else1211 revisions=$onto...$orig_head1212 shortrevisions=$shorthead1213fi1214if test t != "$preserve_merges"1215then1216 git rebase--helper --make-script ${keep_empty:+--keep-empty} \1217 $revisions ${restrict_revision+^$restrict_revision} >"$todo"1218else1219 format=$(git config --get rebase.instructionFormat)1220 # the 'rev-list .. | sed' requires %m to parse; the instruction requires %H to parse1221 git rev-list $merges_option --format="%m%H ${format:-%s}" \1222 --reverse --left-right --topo-order \1223 $revisions ${restrict_revision+^$restrict_revision} | \1224 sed -n "s/^>//p" |1225 while read -r sha1 rest1226 do12271228 if test -z "$keep_empty" && is_empty_commit $sha1 && ! is_merge_commit $sha11229 then1230 comment_out="$comment_char "1231 else1232 comment_out=1233 fi12341235 if test -z "$rebase_root"1236 then1237 preserve=t1238 for p in $(git rev-list --parents -1 $sha1 | cut -d' ' -s -f2-)1239 do1240 if test -f "$rewritten"/$p1241 then1242 preserve=f1243 fi1244 done1245 else1246 preserve=f1247 fi1248 if test f = "$preserve"1249 then1250 touch "$rewritten"/$sha11251 printf '%s\n' "${comment_out}pick $sha1 $rest" >>"$todo"1252 fi1253 done1254fi12551256# Watch for commits that been dropped by --cherry-pick1257if test t = "$preserve_merges"1258then1259 mkdir "$dropped"1260 # Save all non-cherry-picked changes1261 git rev-list $revisions --left-right --cherry-pick | \1262 sed -n "s/^>//p" > "$state_dir"/not-cherry-picks1263 # Now all commits and note which ones are missing in1264 # not-cherry-picks and hence being dropped1265 git rev-list $revisions |1266 while read rev1267 do1268 if test -f "$rewritten"/$rev &&1269 ! sane_grep "$rev" "$state_dir"/not-cherry-picks >/dev/null1270 then1271 # Use -f2 because if rev-list is telling us this commit is1272 # not worthwhile, we don't want to track its multiple heads,1273 # just the history of its first-parent for others that will1274 # be rebasing on top of it1275 git rev-list --parents -1 $rev | cut -d' ' -s -f2 > "$dropped"/$rev1276 sha1=$(git rev-list -1 $rev)1277 sane_grep -v "^[a-z][a-z]* $sha1" <"$todo" > "${todo}2" ; mv "${todo}2" "$todo"1278 rm "$rewritten"/$rev1279 fi1280 done1281fi12821283test -s "$todo" || echo noop >> "$todo"1284test -n "$autosquash" && rearrange_squash "$todo"1285test -n "$cmd" && add_exec_commands "$todo"12861287todocount=$(git stripspace --strip-comments <"$todo" | wc -l)1288todocount=${todocount##* }12891290cat >>"$todo" <<EOF12911292$comment_char $(eval_ngettext \1293 "Rebase \$shortrevisions onto \$shortonto (\$todocount command)" \1294 "Rebase \$shortrevisions onto \$shortonto (\$todocount commands)" \1295 "$todocount")1296EOF1297append_todo_help1298gettext "1299However, if you remove everything, the rebase will be aborted.13001301" | git stripspace --comment-lines >>"$todo"13021303if test -z "$keep_empty"1304then1305 printf '%s\n' "$comment_char $(gettext "Note that empty commits are commented out")" >>"$todo"1306fi130713081309has_action "$todo" ||1310 return 213111312cp "$todo" "$todo".backup1313collapse_todo_ids1314git_sequence_editor "$todo" ||1315 die_abort "$(gettext "Could not execute editor")"13161317has_action "$todo" ||1318 return 213191320check_todo_list13211322expand_todo_ids13231324test -d "$rewritten" || test -n "$force_rebase" || skip_unnecessary_picks13251326checkout_onto1327if test -z "$rebase_root" && test ! -d "$rewritten"1328then1329 require_clean_work_tree "rebase"1330 exec git rebase--helper ${force_rebase:+--no-ff} --continue1331fi1332do_rest13331334}1335# ... and then we call the whole thing.1336git_rebase__interactive