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= 85if test -n "$do_merge" 86then 87 strategy_args=${strategy:+--strategy=$strategy} 88 eval ' 89 for strategy_opt in '"$strategy_opts"' 90 do 91 strategy_args="$strategy_args -X$(git rev-parse --sq-quote "${strategy_opt#--}")" 92 done 93 ' 94fi 95 96GIT_CHERRY_PICK_HELP="$resolvemsg" 97export GIT_CHERRY_PICK_HELP 98 99comment_char=$(git config --get core.commentchar 2>/dev/null | cut -c1) 100: ${comment_char:=#} 101 102warn () { 103 printf '%s\n' "$*" >&2 104} 105 106# Output the commit message for the specified commit. 107commit_message () { 108 git cat-file commit "$1" | sed "1,/^$/d" 109} 110 111orig_reflog_action="$GIT_REFLOG_ACTION" 112 113comment_for_reflog () { 114 case "$orig_reflog_action" in 115 ''|rebase*) 116 GIT_REFLOG_ACTION="rebase -i ($1)" 117 export GIT_REFLOG_ACTION 118 ;; 119 esac 120} 121 122last_count= 123mark_action_done () { 124 sed -e 1q < "$todo" >> "$done" 125 sed -e 1d < "$todo" >> "$todo".new 126 mv -f "$todo".new "$todo" 127 new_count=$(git stripspace --strip-comments <"$done" | wc -l) 128 echo $new_count >"$msgnum" 129 total=$(($new_count + $(git stripspace --strip-comments <"$todo" | wc -l))) 130 echo $total >"$end" 131 if test "$last_count" != "$new_count" 132 then 133 last_count=$new_count 134 printf "Rebasing (%d/%d)\r" $new_count $total 135 test -z "$verbose" || echo 136 fi 137} 138 139# Put the last action marked done at the beginning of the todo list 140# again. If there has not been an action marked done yet, leave the list of 141# items on the todo list unchanged. 142reschedule_last_action () { 143 tail -n 1 "$done" | cat - "$todo" >"$todo".new 144 sed -e \$d <"$done" >"$done".new 145 mv -f "$todo".new "$todo" 146 mv -f "$done".new "$done" 147} 148 149append_todo_help () { 150 git stripspace --comment-lines >>"$todo" <<\EOF 151 152Commands: 153 p, pick = use commit 154 r, reword = use commit, but edit the commit message 155 e, edit = use commit, but stop for amending 156 s, squash = use commit, but meld into previous commit 157 f, fixup = like "squash", but discard this commit's log message 158 x, exec = run command (the rest of the line) using shell 159 d, drop = remove commit 160 161These lines can be re-ordered; they are executed from top to bottom. 162 163EOF 164 if test $(get_missing_commit_check_level) = error 165 then 166 git stripspace --comment-lines >>"$todo" <<\EOF 167Do not remove any line. Use 'drop' explicitly to remove a commit. 168EOF 169 else 170 git stripspace --comment-lines >>"$todo" <<\EOF 171If you remove a line here THAT COMMIT WILL BE LOST. 172EOF 173 fi 174} 175 176make_patch () { 177 sha1_and_parents="$(git rev-list --parents -1 "$1")" 178 case "$sha1_and_parents" in 179 ?*' '?*' '?*) 180 git diff --cc $sha1_and_parents 181 ;; 182 ?*' '?*) 183 git diff-tree -p "$1^!" 184 ;; 185 *) 186 echo "Root commit" 187 ;; 188 esac > "$state_dir"/patch 189 test -f "$msg" || 190 commit_message "$1" > "$msg" 191 test -f "$author_script" || 192 get_author_ident_from_commit "$1" > "$author_script" 193} 194 195die_with_patch () { 196 echo "$1" > "$state_dir"/stopped-sha 197 make_patch "$1" 198 git rerere 199 die "$2" 200} 201 202exit_with_patch () { 203 echo "$1" > "$state_dir"/stopped-sha 204 make_patch $1 205 git rev-parse --verify HEAD > "$amend" 206 gpg_sign_opt_quoted=${gpg_sign_opt:+$(git rev-parse --sq-quote "$gpg_sign_opt")} 207 warn "You can amend the commit now, with" 208 warn 209 warn " git commit --amend $gpg_sign_opt_quoted" 210 warn 211 warn "Once you are satisfied with your changes, run" 212 warn 213 warn " git rebase --continue" 214 warn 215 exit $2 216} 217 218die_abort () { 219 rm -rf "$state_dir" 220 die "$1" 221} 222 223has_action () { 224 test -n "$(git stripspace --strip-comments <"$1")" 225} 226 227is_empty_commit() { 228 tree=$(git rev-parse -q --verify "$1"^{tree} 2>/dev/null || 229 die "$1: not a commit that can be picked") 230 ptree=$(git rev-parse -q --verify "$1"^^{tree} 2>/dev/null || 231 ptree=4b825dc642cb6eb9a060e54bf8d69288fbee4904) 232 test "$tree" = "$ptree" 233} 234 235is_merge_commit() 236{ 237 git rev-parse --verify --quiet "$1"^2 >/dev/null 2>&1 238} 239 240# Run command with GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL, and 241# GIT_AUTHOR_DATE exported from the current environment. 242do_with_author () { 243 ( 244 export GIT_AUTHOR_NAME GIT_AUTHOR_EMAIL GIT_AUTHOR_DATE 245 "$@" 246 ) 247} 248 249git_sequence_editor () { 250 if test -z "$GIT_SEQUENCE_EDITOR" 251 then 252 GIT_SEQUENCE_EDITOR="$(git config sequence.editor)" 253 if [ -z "$GIT_SEQUENCE_EDITOR" ] 254 then 255 GIT_SEQUENCE_EDITOR="$(git var GIT_EDITOR)" || return $? 256 fi 257 fi 258 259 eval "$GIT_SEQUENCE_EDITOR" '"$@"' 260} 261 262pick_one () { 263 ff=--ff 264 265 case "$1" in -n) sha1=$2; ff= ;; *) sha1=$1 ;; esac 266 case "$force_rebase" in '') ;; ?*) ff= ;; esac 267 output git rev-parse --verify $sha1 || die "Invalid commit name: $sha1" 268 269 if is_empty_commit "$sha1" 270 then 271 empty_args="--allow-empty" 272 fi 273 274 test -d "$rewritten" && 275 pick_one_preserving_merges "$@" && return 276 output eval git cherry-pick \ 277 ${gpg_sign_opt:+$(git rev-parse --sq-quote "$gpg_sign_opt")} \ 278 "$strategy_args" $empty_args $ff "$@" 279 280 # If cherry-pick dies it leaves the to-be-picked commit unrecorded. Reschedule 281 # previous task so this commit is not lost. 282 ret=$? 283 case "$ret" in [01]) ;; *) reschedule_last_action ;; esac 284 return $ret 285} 286 287pick_one_preserving_merges () { 288 fast_forward=t 289 case "$1" in 290 -n) 291 fast_forward=f 292 sha1=$2 293 ;; 294 *) 295 sha1=$1 296 ;; 297 esac 298 sha1=$(git rev-parse $sha1) 299 300 if test -f "$state_dir"/current-commit 301 then 302 if test "$fast_forward" = t 303 then 304 while read current_commit 305 do 306 git rev-parse HEAD > "$rewritten"/$current_commit 307 done <"$state_dir"/current-commit 308 rm "$state_dir"/current-commit || 309 die "Cannot write current commit's replacement sha1" 310 fi 311 fi 312 313 echo $sha1 >> "$state_dir"/current-commit 314 315 # rewrite parents; if none were rewritten, we can fast-forward. 316 new_parents= 317 pend=" $(git rev-list --parents -1 $sha1 | cut -d' ' -s -f2-)" 318 if test "$pend" = " " 319 then 320 pend=" root" 321 fi 322 while [ "$pend" != "" ] 323 do 324 p=$(expr "$pend" : ' \([^ ]*\)') 325 pend="${pend# $p}" 326 327 if test -f "$rewritten"/$p 328 then 329 new_p=$(cat "$rewritten"/$p) 330 331 # If the todo reordered commits, and our parent is marked for 332 # rewriting, but hasn't been gotten to yet, assume the user meant to 333 # drop it on top of the current HEAD 334 if test -z "$new_p" 335 then 336 new_p=$(git rev-parse HEAD) 337 fi 338 339 test $p != $new_p && fast_forward=f 340 case "$new_parents" in 341 *$new_p*) 342 ;; # do nothing; that parent is already there 343 *) 344 new_parents="$new_parents $new_p" 345 ;; 346 esac 347 else 348 if test -f "$dropped"/$p 349 then 350 fast_forward=f 351 replacement="$(cat "$dropped"/$p)" 352 test -z "$replacement" && replacement=root 353 pend=" $replacement$pend" 354 else 355 new_parents="$new_parents $p" 356 fi 357 fi 358 done 359 case $fast_forward in 360 t) 361 output warn "Fast-forward to $sha1" 362 output git reset --hard $sha1 || 363 die "Cannot fast-forward to $sha1" 364 ;; 365 f) 366 first_parent=$(expr "$new_parents" : ' \([^ ]*\)') 367 368 if [ "$1" != "-n" ] 369 then 370 # detach HEAD to current parent 371 output git checkout $first_parent 2> /dev/null || 372 die "Cannot move HEAD to $first_parent" 373 fi 374 375 case "$new_parents" in 376 ' '*' '*) 377 test "a$1" = a-n && die "Refusing to squash a merge: $sha1" 378 379 # redo merge 380 author_script_content=$(get_author_ident_from_commit $sha1) 381 eval "$author_script_content" 382 msg_content="$(commit_message $sha1)" 383 # No point in merging the first parent, that's HEAD 384 new_parents=${new_parents# $first_parent} 385 merge_args="--no-log --no-ff" 386 if ! do_with_author output eval \ 387 'git merge ${gpg_sign_opt:+"$gpg_sign_opt"} \ 388 $merge_args $strategy_args -m "$msg_content" $new_parents' 389 then 390 printf "%s\n" "$msg_content" > "$GIT_DIR"/MERGE_MSG 391 die_with_patch $sha1 "Error redoing merge $sha1" 392 fi 393 echo "$sha1 $(git rev-parse HEAD^0)" >> "$rewritten_list" 394 ;; 395 *) 396 output eval git cherry-pick \ 397 ${gpg_sign_opt:+$(git rev-parse --sq-quote "$gpg_sign_opt")} \ 398 "$strategy_args" "$@" || 399 die_with_patch $sha1 "Could not pick $sha1" 400 ;; 401 esac 402 ;; 403 esac 404} 405 406nth_string () { 407 case "$1" in 408 *1[0-9]|*[04-9]) echo "$1"th;; 409 *1) echo "$1"st;; 410 *2) echo "$1"nd;; 411 *3) echo "$1"rd;; 412 esac 413} 414 415update_squash_messages () { 416 if test -f "$squash_msg"; then 417 mv "$squash_msg" "$squash_msg".bak || exit 418 count=$(($(sed -n \ 419 -e "1s/^. This is a combination of \(.*\) commits\./\1/p" \ 420 -e "q" < "$squash_msg".bak)+1)) 421 { 422 printf '%s\n' "$comment_char This is a combination of $count commits." 423 sed -e 1d -e '2,/^./{ 424 /^$/d 425 }' <"$squash_msg".bak 426 } >"$squash_msg" 427 else 428 commit_message HEAD > "$fixup_msg" || die "Cannot write $fixup_msg" 429 count=2 430 { 431 printf '%s\n' "$comment_char This is a combination of 2 commits." 432 printf '%s\n' "$comment_char The first commit's message is:" 433 echo 434 cat "$fixup_msg" 435 } >"$squash_msg" 436 fi 437 case $1 in 438 squash) 439 rm -f "$fixup_msg" 440 echo 441 printf '%s\n' "$comment_char This is the $(nth_string $count) commit message:" 442 echo 443 commit_message $2 444 ;; 445 fixup) 446 echo 447 printf '%s\n' "$comment_char The $(nth_string $count) commit message will be skipped:" 448 echo 449 # Change the space after the comment character to TAB: 450 commit_message $2 | git stripspace --comment-lines | sed -e 's/ / /' 451 ;; 452 esac >>"$squash_msg" 453} 454 455peek_next_command () { 456 git stripspace --strip-comments <"$todo" | sed -n -e 's/ .*//p' -e q 457} 458 459# A squash/fixup has failed. Prepare the long version of the squash 460# commit message, then die_with_patch. This code path requires the 461# user to edit the combined commit message for all commits that have 462# been squashed/fixedup so far. So also erase the old squash 463# messages, effectively causing the combined commit to be used as the 464# new basis for any further squash/fixups. Args: sha1 rest 465die_failed_squash() { 466 mv "$squash_msg" "$msg" || exit 467 rm -f "$fixup_msg" 468 cp "$msg" "$GIT_DIR"/MERGE_MSG || exit 469 warn 470 warn "Could not apply $1... $2" 471 die_with_patch $1 "" 472} 473 474flush_rewritten_pending() { 475 test -s "$rewritten_pending" || return 476 newsha1="$(git rev-parse HEAD^0)" 477 sed "s/$/ $newsha1/" < "$rewritten_pending" >> "$rewritten_list" 478 rm -f "$rewritten_pending" 479} 480 481record_in_rewritten() { 482 oldsha1="$(git rev-parse $1)" 483 echo "$oldsha1" >> "$rewritten_pending" 484 485 case "$(peek_next_command)" in 486 squash|s|fixup|f) 487 ;; 488 *) 489 flush_rewritten_pending 490 ;; 491 esac 492} 493 494do_pick () { 495 if test "$(git rev-parse HEAD)" = "$squash_onto" 496 then 497 # Set the correct commit message and author info on the 498 # sentinel root before cherry-picking the original changes 499 # without committing (-n). Finally, update the sentinel again 500 # to include these changes. If the cherry-pick results in a 501 # conflict, this means our behaviour is similar to a standard 502 # failed cherry-pick during rebase, with a dirty index to 503 # resolve before manually running git commit --amend then git 504 # rebase --continue. 505 git commit --allow-empty --allow-empty-message --amend \ 506 --no-post-rewrite -n -q -C $1 && 507 pick_one -n $1 && 508 git commit --allow-empty --allow-empty-message \ 509 --amend --no-post-rewrite -n -q -C $1 \ 510 ${gpg_sign_opt:+"$gpg_sign_opt"} || 511 die_with_patch $1 "Could not apply $1... $2" 512 else 513 pick_one $1 || 514 die_with_patch $1 "Could not apply $1... $2" 515 fi 516} 517 518do_next () { 519 rm -f "$msg" "$author_script" "$amend" "$state_dir"/stopped-sha || exit 520 read -r command sha1 rest < "$todo" 521 case "$command" in 522 "$comment_char"*|''|noop|drop|d) 523 mark_action_done 524 ;; 525 "$cr") 526 # Work around CR left by "read" (e.g. with Git for Windows' Bash). 527 mark_action_done 528 ;; 529 pick|p) 530 comment_for_reflog pick 531 532 mark_action_done 533 do_pick $sha1 "$rest" 534 record_in_rewritten $sha1 535 ;; 536 reword|r) 537 comment_for_reflog reword 538 539 mark_action_done 540 do_pick $sha1 "$rest" 541 git commit --amend --no-post-rewrite ${gpg_sign_opt:+"$gpg_sign_opt"} || { 542 warn "Could not amend commit after successfully picking $sha1... $rest" 543 warn "This is most likely due to an empty commit message, or the pre-commit hook" 544 warn "failed. If the pre-commit hook failed, you may need to resolve the issue before" 545 warn "you are able to reword the commit." 546 exit_with_patch $sha1 1 547 } 548 record_in_rewritten $sha1 549 ;; 550 edit|e) 551 comment_for_reflog edit 552 553 mark_action_done 554 do_pick $sha1 "$rest" 555 warn "Stopped at $sha1... $rest" 556 exit_with_patch $sha1 0 557 ;; 558 squash|s|fixup|f) 559 case "$command" in 560 squash|s) 561 squash_style=squash 562 ;; 563 fixup|f) 564 squash_style=fixup 565 ;; 566 esac 567 comment_for_reflog $squash_style 568 569 test -f "$done" && has_action "$done" || 570 die "Cannot '$squash_style' without a previous commit" 571 572 mark_action_done 573 update_squash_messages $squash_style $sha1 574 author_script_content=$(get_author_ident_from_commit HEAD) 575 echo "$author_script_content" > "$author_script" 576 eval "$author_script_content" 577 if ! pick_one -n $sha1 578 then 579 git rev-parse --verify HEAD >"$amend" 580 die_failed_squash $sha1 "$rest" 581 fi 582 case "$(peek_next_command)" in 583 squash|s|fixup|f) 584 # This is an intermediate commit; its message will only be 585 # used in case of trouble. So use the long version: 586 do_with_author output git commit --amend --no-verify -F "$squash_msg" \ 587 ${gpg_sign_opt:+"$gpg_sign_opt"} || 588 die_failed_squash $sha1 "$rest" 589 ;; 590 *) 591 # This is the final command of this squash/fixup group 592 if test -f "$fixup_msg" 593 then 594 do_with_author git commit --amend --no-verify -F "$fixup_msg" \ 595 ${gpg_sign_opt:+"$gpg_sign_opt"} || 596 die_failed_squash $sha1 "$rest" 597 else 598 cp "$squash_msg" "$GIT_DIR"/SQUASH_MSG || exit 599 rm -f "$GIT_DIR"/MERGE_MSG 600 do_with_author git commit --amend --no-verify -F "$GIT_DIR"/SQUASH_MSG -e \ 601 ${gpg_sign_opt:+"$gpg_sign_opt"} || 602 die_failed_squash $sha1 "$rest" 603 fi 604 rm -f "$squash_msg" "$fixup_msg" 605 ;; 606 esac 607 record_in_rewritten $sha1 608 ;; 609 x|"exec") 610 read -r command rest < "$todo" 611 mark_action_done 612 printf 'Executing: %s\n' "$rest" 613 "${SHELL:-@SHELL_PATH@}" -c "$rest" # Actual execution 614 status=$? 615 # Run in subshell because require_clean_work_tree can die. 616 dirty=f 617 (require_clean_work_tree "rebase" 2>/dev/null) || dirty=t 618 if test "$status" -ne 0 619 then 620 warn "Execution failed: $rest" 621 test "$dirty" = f || 622 warn "and made changes to the index and/or the working tree" 623 624 warn "You can fix the problem, and then run" 625 warn 626 warn " git rebase --continue" 627 warn 628 if test $status -eq 127 # command not found 629 then 630 status=1 631 fi 632 exit "$status" 633 elif test "$dirty" = t 634 then 635 warn "Execution succeeded: $rest" 636 warn "but left changes to the index and/or the working tree" 637 warn "Commit or stash your changes, and then run" 638 warn 639 warn " git rebase --continue" 640 warn 641 exit 1 642 fi 643 ;; 644 *) 645 warn "Unknown command: $command $sha1 $rest" 646 fixtodo="Please fix this using 'git rebase --edit-todo'." 647 if git rev-parse --verify -q "$sha1" >/dev/null 648 then 649 die_with_patch $sha1 "$fixtodo" 650 else 651 die "$fixtodo" 652 fi 653 ;; 654 esac 655 test -s "$todo" && return 656 657 comment_for_reflog finish && 658 newhead=$(git rev-parse HEAD) && 659 case $head_name in 660 refs/*) 661 message="$GIT_REFLOG_ACTION: $head_name onto $onto" && 662 git update-ref -m "$message" $head_name $newhead $orig_head && 663 git symbolic-ref \ 664 -m "$GIT_REFLOG_ACTION: returning to $head_name" \ 665 HEAD $head_name 666 ;; 667 esac && { 668 test ! -f "$state_dir"/verbose || 669 git diff-tree --stat $orig_head..HEAD 670 } && 671 { 672 test -s "$rewritten_list" && 673 git notes copy --for-rewrite=rebase < "$rewritten_list" || 674 true # we don't care if this copying failed 675 } && 676 hook="$(git rev-parse --git-path hooks/post-rewrite)" 677 if test -x "$hook" && test -s "$rewritten_list"; then 678 "$hook" rebase < "$rewritten_list" 679 true # we don't care if this hook failed 680 fi && 681 warn "Successfully rebased and updated $head_name." 682 683 return 1 # not failure; just to break the do_rest loop 684} 685 686# can only return 0, when the infinite loop breaks 687do_rest () { 688 while : 689 do 690 do_next || break 691 done 692} 693 694# skip picking commits whose parents are unchanged 695skip_unnecessary_picks () { 696 fd=3 697 while read -r command rest 698 do 699 # fd=3 means we skip the command 700 case "$fd,$command" in 701 3,pick|3,p) 702 # pick a commit whose parent is current $onto -> skip 703 sha1=${rest%% *} 704 case "$(git rev-parse --verify --quiet "$sha1"^)" in 705 "$onto"*) 706 onto=$sha1 707 ;; 708 *) 709 fd=1 710 ;; 711 esac 712 ;; 713 3,"$comment_char"*|3,) 714 # copy comments 715 ;; 716 *) 717 fd=1 718 ;; 719 esac 720 printf '%s\n' "$command${rest:+ }$rest" >&$fd 721 done <"$todo" >"$todo.new" 3>>"$done" && 722 mv -f "$todo".new "$todo" && 723 case "$(peek_next_command)" in 724 squash|s|fixup|f) 725 record_in_rewritten "$onto" 726 ;; 727 esac || 728 die "Could not skip unnecessary pick commands" 729} 730 731transform_todo_ids () { 732 while read -r command rest 733 do 734 case "$command" in 735 "$comment_char"* | exec) 736 # Be careful for oddball commands like 'exec' 737 # that do not have a SHA-1 at the beginning of $rest. 738 ;; 739 *) 740 sha1=$(git rev-parse --verify --quiet "$@" ${rest%%[ ]*}) && 741 rest="$sha1 ${rest#*[ ]}" 742 ;; 743 esac 744 printf '%s\n' "$command${rest:+ }$rest" 745 done <"$todo" >"$todo.new" && 746 mv -f "$todo.new" "$todo" 747} 748 749expand_todo_ids() { 750 transform_todo_ids 751} 752 753collapse_todo_ids() { 754 transform_todo_ids --short 755} 756 757# Rearrange the todo list that has both "pick sha1 msg" and 758# "pick sha1 fixup!/squash! msg" appears in it so that the latter 759# comes immediately after the former, and change "pick" to 760# "fixup"/"squash". 761# 762# Note that if the config has specified a custom instruction format 763# each log message will be re-retrieved in order to normalize the 764# autosquash arrangement 765rearrange_squash () { 766 # extract fixup!/squash! lines and resolve any referenced sha1's 767 while read -r pick sha1 message 768 do 769 test -z "${format}" || message=$(git log -n 1 --format="%s" ${sha1}) 770 case "$message" in 771 "squash! "*|"fixup! "*) 772 action="${message%%!*}" 773 rest=$message 774 prefix= 775 # skip all squash! or fixup! (but save for later) 776 while : 777 do 778 case "$rest" in 779 "squash! "*|"fixup! "*) 780 prefix="$prefix${rest%%!*}," 781 rest="${rest#*! }" 782 ;; 783 *) 784 break 785 ;; 786 esac 787 done 788 printf '%s %s %s %s\n' "$sha1" "$action" "$prefix" "$rest" 789 # if it's a single word, try to resolve to a full sha1 and 790 # emit a second copy. This allows us to match on both message 791 # and on sha1 prefix 792 if test "${rest#* }" = "$rest"; then 793 fullsha="$(git rev-parse -q --verify "$rest" 2>/dev/null)" 794 if test -n "$fullsha"; then 795 # prefix the action to uniquely identify this line as 796 # intended for full sha1 match 797 echo "$sha1 +$action $prefix $fullsha" 798 fi 799 fi 800 esac 801 done >"$1.sq" <"$1" 802 test -s "$1.sq" || return 803 804 used= 805 while read -r pick sha1 message 806 do 807 case " $used" in 808 *" $sha1 "*) continue ;; 809 esac 810 printf '%s\n' "$pick $sha1 $message" 811 test -z "${format}" || message=$(git log -n 1 --format="%s" ${sha1}) 812 used="$used$sha1 " 813 while read -r squash action msg_prefix msg_content 814 do 815 case " $used" in 816 *" $squash "*) continue ;; 817 esac 818 emit=0 819 case "$action" in 820 +*) 821 action="${action#+}" 822 # full sha1 prefix test 823 case "$msg_content" in "$sha1"*) emit=1;; esac ;; 824 *) 825 # message prefix test 826 case "$message" in "$msg_content"*) emit=1;; esac ;; 827 esac 828 if test $emit = 1; then 829 if test -n "${format}" 830 then 831 msg_content=$(git log -n 1 --format="${format}" ${squash}) 832 else 833 msg_content="$(echo "$msg_prefix" | sed "s/,/! /g")$msg_content" 834 fi 835 printf '%s\n' "$action $squash $msg_content" 836 used="$used$squash " 837 fi 838 done <"$1.sq" 839 done >"$1.rearranged" <"$1" 840 cat "$1.rearranged" >"$1" 841 rm -f "$1.sq" "$1.rearranged" 842} 843 844# Add commands after a pick or after a squash/fixup serie 845# in the todo list. 846add_exec_commands () { 847 { 848 first=t 849 while read -r insn rest 850 do 851 case $insn in 852 pick) 853 test -n "$first" || 854 printf "%s" "$cmd" 855 ;; 856 esac 857 printf "%s %s\n" "$insn" "$rest" 858 first= 859 done 860 printf "%s" "$cmd" 861 } <"$1" >"$1.new" && 862 mv "$1.new" "$1" 863} 864 865# Check if the SHA-1 passed as an argument is a 866# correct one, if not then print $2 in "$todo".badsha 867# $1: the SHA-1 to test 868# $2: the line number of the input 869# $3: the input filename 870check_commit_sha () { 871 badsha=0 872 if test -z $1 873 then 874 badsha=1 875 else 876 sha1_verif="$(git rev-parse --verify --quiet $1^{commit})" 877 if test -z $sha1_verif 878 then 879 badsha=1 880 fi 881 fi 882 883 if test $badsha -ne 0 884 then 885 line="$(sed -n -e "${2}p" "$3")" 886 warn "Warning: the SHA-1 is missing or isn't" \ 887 "a commit in the following line:" 888 warn " - $line" 889 warn 890 fi 891 892 return $badsha 893} 894 895# prints the bad commits and bad commands 896# from the todolist in stdin 897check_bad_cmd_and_sha () { 898 retval=0 899 lineno=0 900 while read -r command rest 901 do 902 lineno=$(( $lineno + 1 )) 903 case $command in 904 "$comment_char"*|''|noop|x|exec) 905 # Doesn't expect a SHA-1 906 ;; 907 "$cr") 908 # Work around CR left by "read" (e.g. with Git for 909 # Windows' Bash). 910 ;; 911 pick|p|drop|d|reword|r|edit|e|squash|s|fixup|f) 912 if ! check_commit_sha "${rest%%[ ]*}" "$lineno" "$1" 913 then 914 retval=1 915 fi 916 ;; 917 *) 918 line="$(sed -n -e "${lineno}p" "$1")" 919 warn "Warning: the command isn't recognized" \ 920 "in the following line:" 921 warn " - $line" 922 warn 923 retval=1 924 ;; 925 esac 926 done <"$1" 927 return $retval 928} 929 930# Print the list of the SHA-1 of the commits 931# from stdin to stdout 932todo_list_to_sha_list () { 933 git stripspace --strip-comments | 934 while read -r command sha1 rest 935 do 936 case $command in 937 "$comment_char"*|''|noop|x|"exec") 938 ;; 939 *) 940 long_sha=$(git rev-list --no-walk "$sha1" 2>/dev/null) 941 printf "%s\n" "$long_sha" 942 ;; 943 esac 944 done 945} 946 947# Use warn for each line in stdin 948warn_lines () { 949 while read -r line 950 do 951 warn " - $line" 952 done 953} 954 955# Switch to the branch in $into and notify it in the reflog 956checkout_onto () { 957 GIT_REFLOG_ACTION="$GIT_REFLOG_ACTION: checkout $onto_name" 958 output git checkout $onto || die_abort "could not detach HEAD" 959 git update-ref ORIG_HEAD $orig_head 960} 961 962get_missing_commit_check_level () { 963 check_level=$(git config --get rebase.missingCommitsCheck) 964 check_level=${check_level:-ignore} 965 # Don't be case sensitive 966 printf '%s' "$check_level" | tr 'A-Z' 'a-z' 967} 968 969# Check if the user dropped some commits by mistake 970# Behaviour determined by rebase.missingCommitsCheck. 971# Check if there is an unrecognized command or a 972# bad SHA-1 in a command. 973check_todo_list () { 974 raise_error=f 975 976 check_level=$(get_missing_commit_check_level) 977 978 case "$check_level" in 979 warn|error) 980 # Get the SHA-1 of the commits 981 todo_list_to_sha_list <"$todo".backup >"$todo".oldsha1 982 todo_list_to_sha_list <"$todo" >"$todo".newsha1 983 984 # Sort the SHA-1 and compare them 985 sort -u "$todo".oldsha1 >"$todo".oldsha1+ 986 mv "$todo".oldsha1+ "$todo".oldsha1 987 sort -u "$todo".newsha1 >"$todo".newsha1+ 988 mv "$todo".newsha1+ "$todo".newsha1 989 comm -2 -3 "$todo".oldsha1 "$todo".newsha1 >"$todo".miss 990 991 # Warn about missing commits 992 if test -s "$todo".miss 993 then 994 test "$check_level" = error && raise_error=t 995 996 warn "Warning: some commits may have been dropped" \ 997 "accidentally." 998 warn "Dropped commits (newer to older):" 9991000 # Make the list user-friendly and display1001 opt="--no-walk=sorted --format=oneline --abbrev-commit --stdin"1002 git rev-list $opt <"$todo".miss | warn_lines10031004 warn "To avoid this message, use \"drop\" to" \1005 "explicitly remove a commit."1006 warn1007 warn "Use 'git config rebase.missingCommitsCheck' to change" \1008 "the level of warnings."1009 warn "The possible behaviours are: ignore, warn, error."1010 warn1011 fi1012 ;;1013 ignore)1014 ;;1015 *)1016 warn "Unrecognized setting $check_level for option" \1017 "rebase.missingCommitsCheck. Ignoring."1018 ;;1019 esac10201021 if ! check_bad_cmd_and_sha "$todo"1022 then1023 raise_error=t1024 fi10251026 if test $raise_error = t1027 then1028 # Checkout before the first commit of the1029 # rebase: this way git rebase --continue1030 # will work correctly as it expects HEAD to be1031 # placed before the commit of the next action1032 checkout_onto10331034 warn "You can fix this with 'git rebase --edit-todo'."1035 die "Or you can abort the rebase with 'git rebase --abort'."1036 fi1037}10381039# The whole contents of this file is run by dot-sourcing it from1040# inside a shell function. It used to be that "return"s we see1041# below were not inside any function, and expected to return1042# to the function that dot-sourced us.1043#1044# However, FreeBSD /bin/sh misbehaves on such a construct and1045# continues to run the statements that follow such a "return".1046# As a work-around, we introduce an extra layer of a function1047# here, and immediately call it after defining it.1048git_rebase__interactive () {10491050case "$action" in1051continue)1052 # do we have anything to commit?1053 if git diff-index --cached --quiet HEAD --1054 then1055 # Nothing to commit -- skip this commit10561057 test ! -f "$GIT_DIR"/CHERRY_PICK_HEAD ||1058 rm "$GIT_DIR"/CHERRY_PICK_HEAD ||1059 die "Could not remove CHERRY_PICK_HEAD"1060 else1061 if ! test -f "$author_script"1062 then1063 gpg_sign_opt_quoted=${gpg_sign_opt:+$(git rev-parse --sq-quote "$gpg_sign_opt")}1064 die "You have staged changes in your working tree. If these changes are meant to be1065squashed into the previous commit, run:10661067 git commit --amend $gpg_sign_opt_quoted10681069If they are meant to go into a new commit, run:10701071 git commit $gpg_sign_opt_quoted10721073In both case, once you're done, continue with:10741075 git rebase --continue1076"1077 fi1078 . "$author_script" ||1079 die "Error trying to find the author identity to amend commit"1080 if test -f "$amend"1081 then1082 current_head=$(git rev-parse --verify HEAD)1083 test "$current_head" = $(cat "$amend") ||1084 die "\1085You have uncommitted changes in your working tree. Please, commit them1086first and then run 'git rebase --continue' again."1087 do_with_author git commit --amend --no-verify -F "$msg" -e \1088 ${gpg_sign_opt:+"$gpg_sign_opt"} ||1089 die "Could not commit staged changes."1090 else1091 do_with_author git commit --no-verify -F "$msg" -e \1092 ${gpg_sign_opt:+"$gpg_sign_opt"} ||1093 die "Could not commit staged changes."1094 fi1095 fi10961097 if test -r "$state_dir"/stopped-sha1098 then1099 record_in_rewritten "$(cat "$state_dir"/stopped-sha)"1100 fi11011102 require_clean_work_tree "rebase"1103 do_rest1104 return 01105 ;;1106skip)1107 git rerere clear11081109 do_rest1110 return 01111 ;;1112edit-todo)1113 git stripspace --strip-comments <"$todo" >"$todo".new1114 mv -f "$todo".new "$todo"1115 collapse_todo_ids1116 append_todo_help1117 git stripspace --comment-lines >>"$todo" <<\EOF11181119You are editing the todo file of an ongoing interactive rebase.1120To continue rebase after editing, run:1121 git rebase --continue11221123EOF11241125 git_sequence_editor "$todo" ||1126 die "Could not execute editor"1127 expand_todo_ids11281129 exit1130 ;;1131esac11321133git var GIT_COMMITTER_IDENT >/dev/null ||1134 die "You need to set your committer info first"11351136comment_for_reflog start11371138if test ! -z "$switch_to"1139then1140 GIT_REFLOG_ACTION="$GIT_REFLOG_ACTION: checkout $switch_to"1141 output git checkout "$switch_to" -- ||1142 die "Could not checkout $switch_to"11431144 comment_for_reflog start1145fi11461147orig_head=$(git rev-parse --verify HEAD) || die "No HEAD?"1148mkdir -p "$state_dir" || die "Could not create temporary $state_dir"11491150: > "$state_dir"/interactive || die "Could not mark as interactive"1151write_basic_state1152if test t = "$preserve_merges"1153then1154 if test -z "$rebase_root"1155 then1156 mkdir "$rewritten" &&1157 for c in $(git merge-base --all $orig_head $upstream)1158 do1159 echo $onto > "$rewritten"/$c ||1160 die "Could not init rewritten commits"1161 done1162 else1163 mkdir "$rewritten" &&1164 echo $onto > "$rewritten"/root ||1165 die "Could not init rewritten commits"1166 fi1167 # No cherry-pick because our first pass is to determine1168 # parents to rewrite and skipping dropped commits would1169 # prematurely end our probe1170 merges_option=1171else1172 merges_option="--no-merges --cherry-pick"1173fi11741175shorthead=$(git rev-parse --short $orig_head)1176shortonto=$(git rev-parse --short $onto)1177if test -z "$rebase_root"1178 # this is now equivalent to ! -z "$upstream"1179then1180 shortupstream=$(git rev-parse --short $upstream)1181 revisions=$upstream...$orig_head1182 shortrevisions=$shortupstream..$shorthead1183else1184 revisions=$onto...$orig_head1185 shortrevisions=$shorthead1186fi1187format=$(git config --get rebase.instructionFormat)1188# the 'rev-list .. | sed' requires %m to parse; the instruction requires %H to parse1189git rev-list $merges_option --format="%m%H ${format:-%s}" \1190 --reverse --left-right --topo-order \1191 $revisions ${restrict_revision+^$restrict_revision} | \1192 sed -n "s/^>//p" |1193while read -r sha1 rest1194do11951196 if test -z "$keep_empty" && is_empty_commit $sha1 && ! is_merge_commit $sha11197 then1198 comment_out="$comment_char "1199 else1200 comment_out=1201 fi12021203 if test t != "$preserve_merges"1204 then1205 printf '%s\n' "${comment_out}pick $sha1 $rest" >>"$todo"1206 else1207 if test -z "$rebase_root"1208 then1209 preserve=t1210 for p in $(git rev-list --parents -1 $sha1 | cut -d' ' -s -f2-)1211 do1212 if test -f "$rewritten"/$p1213 then1214 preserve=f1215 fi1216 done1217 else1218 preserve=f1219 fi1220 if test f = "$preserve"1221 then1222 touch "$rewritten"/$sha11223 printf '%s\n' "${comment_out}pick $sha1 $rest" >>"$todo"1224 fi1225 fi1226done12271228# Watch for commits that been dropped by --cherry-pick1229if test t = "$preserve_merges"1230then1231 mkdir "$dropped"1232 # Save all non-cherry-picked changes1233 git rev-list $revisions --left-right --cherry-pick | \1234 sed -n "s/^>//p" > "$state_dir"/not-cherry-picks1235 # Now all commits and note which ones are missing in1236 # not-cherry-picks and hence being dropped1237 git rev-list $revisions |1238 while read rev1239 do1240 if test -f "$rewritten"/$rev && test "$(sane_grep "$rev" "$state_dir"/not-cherry-picks)" = ""1241 then1242 # Use -f2 because if rev-list is telling us this commit is1243 # not worthwhile, we don't want to track its multiple heads,1244 # just the history of its first-parent for others that will1245 # be rebasing on top of it1246 git rev-list --parents -1 $rev | cut -d' ' -s -f2 > "$dropped"/$rev1247 sha1=$(git rev-list -1 $rev)1248 sane_grep -v "^[a-z][a-z]* $sha1" <"$todo" > "${todo}2" ; mv "${todo}2" "$todo"1249 rm "$rewritten"/$rev1250 fi1251 done1252fi12531254test -s "$todo" || echo noop >> "$todo"1255test -n "$autosquash" && rearrange_squash "$todo"1256test -n "$cmd" && add_exec_commands "$todo"12571258todocount=$(git stripspace --strip-comments <"$todo" | wc -l)1259todocount=${todocount##* }12601261cat >>"$todo" <<EOF12621263$comment_char Rebase $shortrevisions onto $shortonto ($todocount command(s))1264EOF1265append_todo_help1266git stripspace --comment-lines >>"$todo" <<\EOF12671268However, if you remove everything, the rebase will be aborted.12691270EOF12711272if test -z "$keep_empty"1273then1274 printf '%s\n' "$comment_char Note that empty commits are commented out" >>"$todo"1275fi127612771278has_action "$todo" ||1279 return 212801281cp "$todo" "$todo".backup1282collapse_todo_ids1283git_sequence_editor "$todo" ||1284 die_abort "Could not execute editor"12851286has_action "$todo" ||1287 return 212881289check_todo_list12901291expand_todo_ids12921293test -d "$rewritten" || test -n "$force_rebase" || skip_unnecessary_picks12941295checkout_onto1296do_rest12971298}1299# ... and then we call the whole thing.1300git_rebase__interactive