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 | cut -c1) 97:${comment_char:=#} 98 99warn () { 100printf'%s\n'"$*">&2 101} 102 103# Output the commit message for the specified commit. 104commit_message () { 105 git cat-file commit "$1"|sed"1,/^$/d" 106} 107 108orig_reflog_action="$GIT_REFLOG_ACTION" 109 110comment_for_reflog () { 111case"$orig_reflog_action"in 112''|rebase*) 113 GIT_REFLOG_ACTION="rebase -i ($1)" 114export GIT_REFLOG_ACTION 115;; 116esac 117} 118 119last_count= 120mark_action_done () { 121sed-e1q <"$todo">>"$done" 122sed-e1d <"$todo">>"$todo".new 123mv-f"$todo".new "$todo" 124 new_count=$(git stripspace --strip-comments <"$done" | wc -l) 125echo$new_count>"$msgnum" 126 total=$(($new_count + $(git stripspace --strip-comments <"$todo" | wc -l))) 127echo$total>"$end" 128iftest"$last_count"!="$new_count" 129then 130 last_count=$new_count 131printf"Rebasing (%d/%d)\r"$new_count $total 132test -z"$verbose"||echo 133fi 134} 135 136# Put the last action marked done at the beginning of the todo list 137# again. If there has not been an action marked done yet, leave the list of 138# items on the todo list unchanged. 139reschedule_last_action () { 140tail-n1"$done"|cat-"$todo">"$todo".new 141sed-e \$d<"$done">"$done".new 142mv-f"$todo".new "$todo" 143mv-f"$done".new "$done" 144} 145 146append_todo_help () { 147 git stripspace --comment-lines>>"$todo"<<\EOF 148 149Commands: 150 p, pick = use commit 151 r, reword = use commit, but edit the commit message 152 e, edit = use commit, but stop for amending 153 s, squash = use commit, but meld into previous commit 154 f, fixup = like "squash", but discard this commit's log message 155 x, exec = run command (the rest of the line) using shell 156 d, drop = remove commit 157 158These lines can be re-ordered; they are executed from top to bottom. 159 160EOF 161 if test$(get_missing_commit_check_level)= error 162 then 163 git stripspace --comment-lines >>"$todo" <<\EOF 164Do not remove any line. Use 'drop' explicitly to remove a commit. 165EOF 166 else 167 git stripspace --comment-lines >>"$todo" <<\EOF 168If you remove a line here THAT COMMIT WILL BE LOST. 169EOF 170 fi 171} 172 173make_patch () { 174 sha1_and_parents="$(git rev-list --parents -1 "$1")" 175 case "$sha1_and_parents" in 176 ?*''?*''?*) 177 git diff --cc$sha1_and_parents 178 ;; 179 ?*''?*) 180 git diff-tree -p "$1^!" 181 ;; 182 *) 183 echo "Root commit" 184 ;; 185 esac > "$state_dir"/patch 186 test -f "$msg" || 187 commit_message "$1" > "$msg" 188 test -f "$author_script" || 189 get_author_ident_from_commit "$1" > "$author_script" 190} 191 192die_with_patch () { 193 echo "$1" > "$state_dir"/stopped-sha 194 make_patch "$1" 195 die "$2" 196} 197 198exit_with_patch () { 199 echo "$1" > "$state_dir"/stopped-sha 200 make_patch$1 201 git rev-parse --verify HEAD > "$amend" 202 gpg_sign_opt_quoted=${gpg_sign_opt:+$(git rev-parse --sq-quote "$gpg_sign_opt")} 203 warn "You can amend the commit now, with" 204 warn 205 warn " git commit --amend$gpg_sign_opt_quoted" 206 warn 207 warn "Once you are satisfied with your changes, run" 208 warn 209 warn " git rebase --continue" 210 warn 211 exit$2 212} 213 214die_abort () { 215 apply_autostash 216 rm -rf "$state_dir" 217 die "$1" 218} 219 220has_action () { 221 test -n "$(git stripspace --strip-comments <"$1")" 222} 223 224is_empty_commit() { 225 tree=$(git rev-parse -q --verify "$1"^{tree} 2>/dev/null || 226 die "$1: not a commit that can be picked") 227 ptree=$(git rev-parse -q --verify "$1"^^{tree} 2>/dev/null || 228 ptree=4b825dc642cb6eb9a060e54bf8d69288fbee4904) 229 test "$tree" = "$ptree" 230} 231 232is_merge_commit() 233{ 234 git rev-parse --verify --quiet "$1"^2 >/dev/null 2>&1 235} 236 237# Run command with GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL, and 238# GIT_AUTHOR_DATE exported from the current environment. 239do_with_author () { 240 ( 241 export GIT_AUTHOR_NAME GIT_AUTHOR_EMAIL GIT_AUTHOR_DATE 242 "$@" 243 ) 244} 245 246git_sequence_editor () { 247 if test -z "$GIT_SEQUENCE_EDITOR" 248 then 249 GIT_SEQUENCE_EDITOR="$(git config sequence.editor)" 250 if [ -z "$GIT_SEQUENCE_EDITOR" ] 251 then 252 GIT_SEQUENCE_EDITOR="$(git var GIT_EDITOR)" || return $? 253 fi 254 fi 255 256 eval "$GIT_SEQUENCE_EDITOR" '"$@"' 257} 258 259pick_one () { 260 ff=--ff 261 262 case "$1" in -n) sha1=$2; ff= ;; *) sha1=$1;; esac 263 case "$force_rebase" in '') ;; ?*) ff= ;; esac 264 output git rev-parse --verify$sha1|| die "Invalid commit name:$sha1" 265 266 if is_empty_commit "$sha1" 267 then 268 empty_args="--allow-empty" 269 fi 270 271 test -d "$rewritten" && 272 pick_one_preserving_merges "$@" && return 273 output eval git cherry-pick \ 274${gpg_sign_opt:+$(git rev-parse --sq-quote "$gpg_sign_opt")}\ 275 "$strategy_args"$empty_args$ff"$@" 276 277 # If cherry-pick dies it leaves the to-be-picked commit unrecorded. Reschedule 278 # previous task so this commit is not lost. 279 ret=$? 280 case "$ret" in [01]) ;; *) reschedule_last_action ;; esac 281 return$ret 282} 283 284pick_one_preserving_merges () { 285 fast_forward=t 286 case "$1" in 287 -n) 288 fast_forward=f 289 sha1=$2 290 ;; 291 *) 292 sha1=$1 293 ;; 294 esac 295 sha1=$(git rev-parse $sha1) 296 297 if test -f "$state_dir"/current-commit 298 then 299 if test "$fast_forward" = t 300 then 301 while read current_commit 302 do 303 git rev-parse HEAD > "$rewritten"/$current_commit 304 done <"$state_dir"/current-commit 305 rm "$state_dir"/current-commit || 306 die "Cannot write current commit's replacement sha1" 307 fi 308 fi 309 310 echo$sha1>> "$state_dir"/current-commit 311 312 # rewrite parents; if none were rewritten, we can fast-forward. 313 new_parents= 314 pend="$(git rev-list --parents -1 $sha1 | cut -d' ' -s -f2-)" 315 if test "$pend" = "" 316 then 317 pend=" root" 318 fi 319 while [ "$pend" != "" ] 320 do 321 p=$(expr "$pend" : ' \([^ ]*\)') 322 pend="${pend# $p}" 323 324 if test -f "$rewritten"/$p 325 then 326 new_p=$(cat "$rewritten"/$p) 327 328 # If the todo reordered commits, and our parent is marked for 329 # rewriting, but hasn't been gotten to yet, assume the user meant to 330 # drop it on top of the current HEAD 331 if test -z "$new_p" 332 then 333 new_p=$(git rev-parse HEAD) 334 fi 335 336 test$p!=$new_p&& fast_forward=f 337 case "$new_parents" in 338 *$new_p*) 339 ;; # do nothing; that parent is already there 340 *) 341 new_parents="$new_parents $new_p" 342 ;; 343 esac 344 else 345 if test -f "$dropped"/$p 346 then 347 fast_forward=f 348 replacement="$(cat "$dropped"/$p)" 349 test -z "$replacement" && replacement=root 350 pend="$replacement$pend" 351 else 352 new_parents="$new_parents $p" 353 fi 354 fi 355 done 356 case$fast_forwardin 357 t) 358 output warn "Fast-forward to $sha1" 359 output git reset --hard$sha1|| 360 die "Cannot fast-forward to $sha1" 361 ;; 362 f) 363 first_parent=$(expr "$new_parents" : ' \([^ ]*\)') 364 365 if [ "$1" != "-n" ] 366 then 367 # detach HEAD to current parent 368 output git checkout$first_parent2> /dev/null || 369 die "Cannot move HEAD to $first_parent" 370 fi 371 372 case "$new_parents" in 373 ' '*' '*) 374 test "a$1" = a-n && die "Refusing to squash a merge:$sha1" 375 376 # redo merge 377 author_script_content=$(get_author_ident_from_commit $sha1) 378 eval "$author_script_content" 379 msg_content="$(commit_message $sha1)" 380 # No point in merging the first parent, that's HEAD 381 new_parents=${new_parents# $first_parent} 382 merge_args="--no-log --no-ff" 383 if ! do_with_author output eval \ 384 'git merge${gpg_sign_opt:+"$gpg_sign_opt"}\ 385$merge_args$strategy_args-m "$msg_content"$new_parents' 386 then 387 printf "%s\n" "$msg_content" > "$GIT_DIR"/MERGE_MSG 388 die_with_patch$sha1"Error redoing merge $sha1" 389 fi 390 echo "$sha1 $(git rev-parse HEAD^0)" >> "$rewritten_list" 391 ;; 392 *) 393 output eval git cherry-pick \ 394${gpg_sign_opt:+$(git rev-parse --sq-quote "$gpg_sign_opt")}\ 395 "$strategy_args" "$@" || 396 die_with_patch$sha1"Could not pick $sha1" 397 ;; 398 esac 399 ;; 400 esac 401} 402 403nth_string () { 404 case "$1" in 405 *1[0-9]|*[04-9]) echo "$1"th;; 406 *1) echo "$1"st;; 407 *2) echo "$1"nd;; 408 *3) echo "$1"rd;; 409 esac 410} 411 412update_squash_messages () { 413 if test -f "$squash_msg"; then 414 mv "$squash_msg" "$squash_msg".bak || exit 415 count=$(($(sed -n \ 416 -e "1s/^. This is a combination of \(.*\) commits\./\1/p" \ 417 -e "q" < "$squash_msg".bak)+1)) 418 { 419 printf '%s\n' "$comment_char This is a combination of $count commits." 420 sed -e 1d -e '2,/^./{ 421 /^$/d 422 }' <"$squash_msg".bak 423 } >"$squash_msg" 424 else 425 commit_message HEAD > "$fixup_msg" || die "Cannot write$fixup_msg" 426 count=2 427 { 428 printf '%s\n' "$comment_char This is a combination of 2 commits." 429 printf '%s\n' "$comment_char The first commit's message is:" 430 echo 431 cat "$fixup_msg" 432 } >"$squash_msg" 433 fi 434 case$1in 435 squash) 436 rm -f "$fixup_msg" 437 echo 438 printf '%s\n' "$comment_charThis is the$(nth_string $count)commit message:" 439 echo 440 commit_message$2 441 ;; 442 fixup) 443 echo 444 printf '%s\n' "$comment_charThe$(nth_string $count)commit message will be skipped:" 445 echo 446 # Change the space after the comment character to TAB: 447 commit_message$2| git stripspace --comment-lines | sed -e 's/ / /' 448 ;; 449 esac >>"$squash_msg" 450} 451 452peek_next_command () { 453 git stripspace --strip-comments <"$todo" | sed -n -e 's/ .*//p' -e q 454} 455 456# A squash/fixup has failed. Prepare the long version of the squash 457# commit message, then die_with_patch. This code path requires the 458# user to edit the combined commit message for all commits that have 459# been squashed/fixedup so far. So also erase the old squash 460# messages, effectively causing the combined commit to be used as the 461# new basis for any further squash/fixups. Args: sha1 rest 462die_failed_squash() { 463 mv "$squash_msg" "$msg" || exit 464 rm -f "$fixup_msg" 465 cp "$msg" "$GIT_DIR"/MERGE_MSG || exit 466 warn 467 warn "Could not apply$1...$2" 468 die_with_patch$1"" 469} 470 471flush_rewritten_pending() { 472 test -s "$rewritten_pending" || return 473 newsha1="$(git rev-parse HEAD^0)" 474 sed "s/$/$newsha1/" < "$rewritten_pending" >> "$rewritten_list" 475 rm -f "$rewritten_pending" 476} 477 478record_in_rewritten() { 479 oldsha1="$(git rev-parse $1)" 480 echo "$oldsha1" >> "$rewritten_pending" 481 482 case "$(peek_next_command)" in 483 squash|s|fixup|f) 484 ;; 485 *) 486 flush_rewritten_pending 487 ;; 488 esac 489} 490 491do_pick () { 492 if test "$(git rev-parse HEAD)" = "$squash_onto" 493 then 494 # Set the correct commit message and author info on the 495 # sentinel root before cherry-picking the original changes 496 # without committing (-n). Finally, update the sentinel again 497 # to include these changes. If the cherry-pick results in a 498 # conflict, this means our behaviour is similar to a standard 499 # failed cherry-pick during rebase, with a dirty index to 500 # resolve before manually running git commit --amend then git 501 # rebase --continue. 502 git commit --allow-empty --allow-empty-message --amend \ 503 --no-post-rewrite -n -q -C$1&& 504 pick_one -n$1&& 505 git commit --allow-empty --allow-empty-message \ 506 --amend --no-post-rewrite -n -q -C$1\ 507${gpg_sign_opt:+"$gpg_sign_opt"}|| 508 die_with_patch$1"Could not apply$1...$2" 509 else 510 pick_one$1|| 511 die_with_patch$1"Could not apply$1...$2" 512 fi 513} 514 515do_next () { 516 rm -f "$msg" "$author_script" "$amend" "$state_dir"/stopped-sha || exit 517 read -r command sha1 rest < "$todo" 518 case "$command" in 519 "$comment_char"*|''|noop|drop|d) 520 mark_action_done 521 ;; 522 "$cr") 523 # Work around CR left by "read" (e.g. with Git for Windows' Bash). 524 mark_action_done 525;; 526 pick|p) 527 comment_for_reflog pick 528 529 mark_action_done 530 do_pick $sha1"$rest" 531 record_in_rewritten $sha1 532;; 533 reword|r) 534 comment_for_reflog reword 535 536 mark_action_done 537 do_pick $sha1"$rest" 538 git commit --amend --no-post-rewrite${gpg_sign_opt:+"$gpg_sign_opt"}|| { 539 warn "Could not amend commit after successfully picking$sha1...$rest" 540 warn "This is most likely due to an empty commit message, or the pre-commit hook" 541 warn "failed. If the pre-commit hook failed, you may need to resolve the issue before" 542 warn "you are able to reword the commit." 543 exit_with_patch $sha11 544} 545 record_in_rewritten $sha1 546;; 547 edit|e) 548 comment_for_reflog edit 549 550 mark_action_done 551 do_pick $sha1"$rest" 552 sha1_abbrev=$(git rev-parse --short $sha1) 553 warn "Stopped at$sha1_abbrev...$rest" 554 exit_with_patch $sha10 555;; 556 squash|s|fixup|f) 557case"$command"in 558 squash|s) 559 squash_style=squash 560;; 561 fixup|f) 562 squash_style=fixup 563;; 564esac 565 comment_for_reflog $squash_style 566 567test -f"$done"&& has_action "$done"|| 568 die "Cannot '$squash_style' without a previous commit" 569 570 mark_action_done 571 update_squash_messages $squash_style $sha1 572 author_script_content=$(get_author_ident_from_commit HEAD) 573echo"$author_script_content">"$author_script" 574eval"$author_script_content" 575if! pick_one -n$sha1 576then 577 git rev-parse --verify HEAD >"$amend" 578 die_failed_squash $sha1"$rest" 579fi 580case"$(peek_next_command)"in 581 squash|s|fixup|f) 582# This is an intermediate commit; its message will only be 583# used in case of trouble. So use the long version: 584 do_with_author output git commit --amend --no-verify -F"$squash_msg" \ 585${gpg_sign_opt:+"$gpg_sign_opt"}|| 586 die_failed_squash $sha1"$rest" 587;; 588*) 589# This is the final command of this squash/fixup group 590iftest -f"$fixup_msg" 591then 592 do_with_author git commit --amend --no-verify -F"$fixup_msg" \ 593${gpg_sign_opt:+"$gpg_sign_opt"}|| 594 die_failed_squash $sha1"$rest" 595else 596cp"$squash_msg""$GIT_DIR"/SQUASH_MSG ||exit 597rm-f"$GIT_DIR"/MERGE_MSG 598 do_with_author git commit --amend --no-verify -F"$GIT_DIR"/SQUASH_MSG -e \ 599${gpg_sign_opt:+"$gpg_sign_opt"}|| 600 die_failed_squash $sha1"$rest" 601fi 602rm-f"$squash_msg""$fixup_msg" 603;; 604esac 605 record_in_rewritten $sha1 606;; 607 x|"exec") 608read -r command rest <"$todo" 609 mark_action_done 610printf'Executing: %s\n'"$rest" 611"${SHELL:-@SHELL_PATH@}"-c"$rest"# Actual execution 612 status=$? 613# Run in subshell because require_clean_work_tree can die. 614 dirty=f 615(require_clean_work_tree "rebase"2>/dev/null) || dirty=t 616iftest"$status"-ne0 617then 618 warn "Execution failed:$rest" 619test"$dirty"= f || 620 warn "and made changes to the index and/or the working tree" 621 622 warn "You can fix the problem, and then run" 623 warn 624 warn " git rebase --continue" 625 warn 626iftest$status-eq127# command not found 627then 628 status=1 629fi 630exit"$status" 631eliftest"$dirty"= t 632then 633 warn "Execution succeeded:$rest" 634 warn "but left changes to the index and/or the working tree" 635 warn "Commit or stash your changes, and then run" 636 warn 637 warn " git rebase --continue" 638 warn 639exit1 640fi 641;; 642*) 643 warn "Unknown command:$command$sha1$rest" 644 fixtodo="Please fix this using 'git rebase --edit-todo'." 645if git rev-parse --verify -q"$sha1">/dev/null 646then 647 die_with_patch $sha1"$fixtodo" 648else 649 die "$fixtodo" 650fi 651;; 652esac 653test -s"$todo"&&return 654 655 comment_for_reflog finish && 656 newhead=$(git rev-parse HEAD)&& 657case$head_namein 658 refs/*) 659 message="$GIT_REFLOG_ACTION:$head_nameonto$onto"&& 660 git update-ref -m"$message"$head_name $newhead $orig_head&& 661 git symbolic-ref \ 662-m"$GIT_REFLOG_ACTION: returning to$head_name" \ 663 HEAD $head_name 664;; 665esac&& { 666test!-f"$state_dir"/verbose || 667 git diff-tree --stat$orig_head..HEAD 668} && 669{ 670test -s"$rewritten_list"&& 671 git notes copy --for-rewrite=rebase <"$rewritten_list"|| 672 true # we don't care if this copying failed 673} && 674 hook="$(git rev-parse --git-path hooks/post-rewrite)" 675iftest -x"$hook"&&test -s"$rewritten_list";then 676"$hook" rebase <"$rewritten_list" 677 true # we don't care if this hook failed 678fi&& 679 warn "Successfully rebased and updated$head_name." 680 681return1# not failure; just to break the do_rest loop 682} 683 684# can only return 0, when the infinite loop breaks 685do_rest () { 686while: 687do 688 do_next ||break 689done 690} 691 692# skip picking commits whose parents are unchanged 693skip_unnecessary_picks () { 694 fd=3 695whileread -r command rest 696do 697# fd=3 means we skip the command 698case"$fd,$command"in 6993,pick|3,p) 700# pick a commit whose parent is current $onto -> skip 701 sha1=${rest%% *} 702case"$(git rev-parse --verify --quiet "$sha1"^)"in 703"$onto"*) 704 onto=$sha1 705;; 706*) 707 fd=1 708;; 709esac 710;; 7113,"$comment_char"*|3,) 712# copy comments 713;; 714*) 715 fd=1 716;; 717esac 718printf'%s\n'"$command${rest:+ }$rest">&$fd 719done<"$todo">"$todo.new"3>>"$done"&& 720mv-f"$todo".new "$todo"&& 721case"$(peek_next_command)"in 722 squash|s|fixup|f) 723 record_in_rewritten "$onto" 724;; 725esac|| 726 die "Could not skip unnecessary pick commands" 727} 728 729transform_todo_ids () { 730whileread -r command rest 731do 732case"$command"in 733"$comment_char"* |exec) 734# Be careful for oddball commands like 'exec' 735# that do not have a SHA-1 at the beginning of $rest. 736;; 737*) 738 sha1=$(git rev-parse --verify --quiet "$@" ${rest%%[ ]*})&& 739 rest="$sha1${rest#*[ ]}" 740;; 741esac 742printf'%s\n'"$command${rest:+ }$rest" 743done<"$todo">"$todo.new"&& 744mv-f"$todo.new""$todo" 745} 746 747expand_todo_ids() { 748 transform_todo_ids 749} 750 751collapse_todo_ids() { 752 transform_todo_ids --short 753} 754 755# Rearrange the todo list that has both "pick sha1 msg" and 756# "pick sha1 fixup!/squash! msg" appears in it so that the latter 757# comes immediately after the former, and change "pick" to 758# "fixup"/"squash". 759# 760# Note that if the config has specified a custom instruction format 761# each log message will be re-retrieved in order to normalize the 762# autosquash arrangement 763rearrange_squash () { 764# extract fixup!/squash! lines and resolve any referenced sha1's 765whileread -r pick sha1 message 766do 767test -z"${format}"|| message=$(git log -n 1 --format="%s" ${sha1}) 768case"$message"in 769"squash! "*|"fixup! "*) 770 action="${message%%!*}" 771 rest=$message 772 prefix= 773# skip all squash! or fixup! (but save for later) 774while: 775do 776case"$rest"in 777"squash! "*|"fixup! "*) 778 prefix="$prefix${rest%%!*}," 779 rest="${rest#*! }" 780;; 781*) 782break 783;; 784esac 785done 786printf'%s %s %s %s\n'"$sha1""$action""$prefix""$rest" 787# if it's a single word, try to resolve to a full sha1 and 788# emit a second copy. This allows us to match on both message 789# and on sha1 prefix 790iftest"${rest#* }"="$rest";then 791 fullsha="$(git rev-parse -q --verify "$rest" 2>/dev/null)" 792iftest -n"$fullsha";then 793# prefix the action to uniquely identify this line as 794# intended for full sha1 match 795echo"$sha1+$action$prefix$fullsha" 796fi 797fi 798esac 799done>"$1.sq"<"$1" 800test -s"$1.sq"||return 801 802 used= 803whileread -r pick sha1 message 804do 805case"$used"in 806*"$sha1"*)continue;; 807esac 808printf'%s\n'"$pick$sha1$message" 809test -z"${format}"|| message=$(git log -n 1 --format="%s" ${sha1}) 810 used="$used$sha1" 811whileread -r squash action msg_prefix msg_content 812do 813case"$used"in 814*"$squash"*)continue;; 815esac 816 emit=0 817case"$action"in 818+*) 819 action="${action#+}" 820# full sha1 prefix test 821case"$msg_content"in"$sha1"*) emit=1;;esac;; 822*) 823# message prefix test 824case"$message"in"$msg_content"*) emit=1;;esac;; 825esac 826iftest$emit=1;then 827iftest -n"${format}" 828then 829 msg_content=$(git log -n 1 --format="${format}" ${squash}) 830else 831 msg_content="$(echo "$msg_prefix" | sed "s/,/! /g")$msg_content" 832fi 833printf'%s\n'"$action$squash$msg_content" 834 used="$used$squash" 835fi 836done<"$1.sq" 837done>"$1.rearranged"<"$1" 838cat"$1.rearranged">"$1" 839rm-f"$1.sq""$1.rearranged" 840} 841 842# Add commands after a pick or after a squash/fixup serie 843# in the todo list. 844add_exec_commands () { 845{ 846 first=t 847whileread -r insn rest 848do 849case$insnin 850 pick) 851test -n"$first"|| 852printf"%s""$cmd" 853;; 854esac 855printf"%s %s\n""$insn""$rest" 856 first= 857done 858printf"%s""$cmd" 859} <"$1">"$1.new"&& 860mv"$1.new""$1" 861} 862 863# Check if the SHA-1 passed as an argument is a 864# correct one, if not then print $2 in "$todo".badsha 865# $1: the SHA-1 to test 866# $2: the line number of the input 867# $3: the input filename 868check_commit_sha () { 869 badsha=0 870iftest -z"$1" 871then 872 badsha=1 873else 874 sha1_verif="$(git rev-parse --verify --quiet $1^{commit})" 875iftest -z"$sha1_verif" 876then 877 badsha=1 878fi 879fi 880 881iftest$badsha-ne0 882then 883 line="$(sed -n -e "${2}p" "$3")" 884 warn "Warning: the SHA-1 is missing or isn't" \ 885"a commit in the following line:" 886 warn " -$line" 887 warn 888fi 889 890return$badsha 891} 892 893# prints the bad commits and bad commands 894# from the todolist in stdin 895check_bad_cmd_and_sha () { 896 retval=0 897 lineno=0 898whileread -r command rest 899do 900 lineno=$(( $lineno + 1 )) 901case$commandin 902"$comment_char"*|''|noop|x|exec) 903# Doesn't expect a SHA-1 904;; 905"$cr") 906# Work around CR left by "read" (e.g. with Git for 907# Windows' Bash). 908;; 909 pick|p|drop|d|reword|r|edit|e|squash|s|fixup|f) 910if! check_commit_sha "${rest%%[ ]*}""$lineno""$1" 911then 912 retval=1 913fi 914;; 915*) 916 line="$(sed -n -e "${lineno}p" "$1")" 917 warn "Warning: the command isn't recognized" \ 918"in the following line:" 919 warn " -$line" 920 warn 921 retval=1 922;; 923esac 924done<"$1" 925return$retval 926} 927 928# Print the list of the SHA-1 of the commits 929# from stdin to stdout 930todo_list_to_sha_list () { 931 git stripspace --strip-comments| 932whileread -r command sha1 rest 933do 934case$commandin 935"$comment_char"*|''|noop|x|"exec") 936;; 937*) 938 long_sha=$(git rev-list --no-walk "$sha1" 2>/dev/null) 939printf"%s\n""$long_sha" 940;; 941esac 942done 943} 944 945# Use warn for each line in stdin 946warn_lines () { 947whileread -r line 948do 949 warn " -$line" 950done 951} 952 953# Switch to the branch in $into and notify it in the reflog 954checkout_onto () { 955 GIT_REFLOG_ACTION="$GIT_REFLOG_ACTION: checkout$onto_name" 956 output git checkout $onto|| die_abort "could not detach HEAD" 957 git update-ref ORIG_HEAD $orig_head 958} 959 960get_missing_commit_check_level () { 961 check_level=$(git config --get rebase.missingCommitsCheck) 962 check_level=${check_level:-ignore} 963# Don't be case sensitive 964printf'%s'"$check_level"|tr'A-Z''a-z' 965} 966 967# Check if the user dropped some commits by mistake 968# Behaviour determined by rebase.missingCommitsCheck. 969# Check if there is an unrecognized command or a 970# bad SHA-1 in a command. 971check_todo_list () { 972 raise_error=f 973 974 check_level=$(get_missing_commit_check_level) 975 976case"$check_level"in 977 warn|error) 978# Get the SHA-1 of the commits 979 todo_list_to_sha_list <"$todo".backup >"$todo".oldsha1 980 todo_list_to_sha_list <"$todo">"$todo".newsha1 981 982# Sort the SHA-1 and compare them 983sort-u"$todo".oldsha1 >"$todo".oldsha1+ 984mv"$todo".oldsha1+"$todo".oldsha1 985sort-u"$todo".newsha1 >"$todo".newsha1+ 986mv"$todo".newsha1+"$todo".newsha1 987comm-2 -3"$todo".oldsha1 "$todo".newsha1 >"$todo".miss 988 989# Warn about missing commits 990iftest -s"$todo".miss 991then 992test"$check_level"= error && raise_error=t 993 994 warn "Warning: some commits may have been dropped" \ 995"accidentally." 996 warn "Dropped commits (newer to older):" 997 998# Make the list user-friendly and display 999 opt="--no-walk=sorted --format=oneline --abbrev-commit --stdin"1000 git rev-list$opt<"$todo".miss | warn_lines10011002 warn "To avoid this message, use\"drop\"to" \1003"explicitly remove a commit."1004 warn1005 warn "Use 'git config rebase.missingCommitsCheck' to change" \1006"the level of warnings."1007 warn "The possible behaviours are: ignore, warn, error."1008 warn1009fi1010;;1011 ignore)1012;;1013*)1014 warn "Unrecognized setting$check_levelfor option" \1015"rebase.missingCommitsCheck. Ignoring."1016;;1017esac10181019if! check_bad_cmd_and_sha "$todo"1020then1021 raise_error=t1022fi10231024iftest$raise_error= t1025then1026# Checkout before the first commit of the1027# rebase: this way git rebase --continue1028# will work correctly as it expects HEAD to be1029# placed before the commit of the next action1030 checkout_onto10311032 warn "You can fix this with 'git rebase --edit-todo'."1033 die "Or you can abort the rebase with 'git rebase --abort'."1034fi1035}10361037# The whole contents of this file is run by dot-sourcing it from1038# inside a shell function. It used to be that "return"s we see1039# below were not inside any function, and expected to return1040# to the function that dot-sourced us.1041#1042# However, older (9.x) versions of FreeBSD /bin/sh misbehave on such a1043# construct and continue to run the statements that follow such a "return".1044# As a work-around, we introduce an extra layer of a function1045# here, and immediately call it after defining it.1046git_rebase__interactive () {10471048case"$action"in1049continue)1050# do we have anything to commit?1051if git diff-index --cached --quiet HEAD --1052then1053# Nothing to commit -- skip this commit10541055test!-f"$GIT_DIR"/CHERRY_PICK_HEAD ||1056rm"$GIT_DIR"/CHERRY_PICK_HEAD ||1057 die "Could not remove CHERRY_PICK_HEAD"1058else1059if!test -f"$author_script"1060then1061 gpg_sign_opt_quoted=${gpg_sign_opt:+$(git rev-parse --sq-quote "$gpg_sign_opt")}1062 die "You have staged changes in your working tree. If these changes are meant to be1063squashed into the previous commit, run:10641065 git commit --amend$gpg_sign_opt_quoted10661067If they are meant to go into a new commit, run:10681069 git commit$gpg_sign_opt_quoted10701071In both case, once you're done, continue with:10721073 git rebase --continue1074"1075fi1076 . "$author_script"||1077 die "Error trying to find the author identity to amend commit"1078iftest -f"$amend"1079then1080 current_head=$(git rev-parse --verify HEAD)1081test"$current_head"=$(cat "$amend")||1082 die "\1083You have uncommitted changes in your working tree. Please, commit them1084first and then run 'git rebase --continue' again."1085 do_with_author git commit --amend --no-verify -F"$msg"-e \1086${gpg_sign_opt:+"$gpg_sign_opt"}||1087 die "Could not commit staged changes."1088else1089 do_with_author git commit --no-verify -F"$msg"-e \1090${gpg_sign_opt:+"$gpg_sign_opt"}||1091 die "Could not commit staged changes."1092fi1093fi10941095iftest -r"$state_dir"/stopped-sha1096then1097 record_in_rewritten "$(cat "$state_dir"/stopped-sha)"1098fi10991100 require_clean_work_tree "rebase"1101 do_rest1102return01103;;1104skip)1105 git rerere clear11061107 do_rest1108return01109;;1110edit-todo)1111 git stripspace --strip-comments<"$todo">"$todo".new1112mv-f"$todo".new "$todo"1113 collapse_todo_ids1114 append_todo_help1115 git stripspace --comment-lines>>"$todo"<<\EOF11161117You are editing the todo file of an ongoing interactive rebase.1118To continue rebase after editing, run:1119 git rebase --continue11201121EOF11221123 git_sequence_editor "$todo"||1124 die "Could not execute editor"1125 expand_todo_ids11261127exit1128;;1129esac11301131git var GIT_COMMITTER_IDENT >/dev/null ||1132 die "You need to set your committer info first"11331134comment_for_reflog start11351136iftest!-z"$switch_to"1137then1138 GIT_REFLOG_ACTION="$GIT_REFLOG_ACTION: checkout$switch_to"1139 output git checkout "$switch_to"--||1140 die "Could not checkout$switch_to"11411142 comment_for_reflog start1143fi11441145orig_head=$(git rev-parse --verify HEAD)|| die "No HEAD?"1146mkdir-p"$state_dir"|| die "Could not create temporary$state_dir"11471148: >"$state_dir"/interactive || die "Could not mark as interactive"1149write_basic_state1150iftest t ="$preserve_merges"1151then1152iftest -z"$rebase_root"1153then1154mkdir"$rewritten"&&1155for c in$(git merge-base --all $orig_head $upstream)1156do1157echo$onto>"$rewritten"/$c||1158 die "Could not init rewritten commits"1159done1160else1161mkdir"$rewritten"&&1162echo$onto>"$rewritten"/root ||1163 die "Could not init rewritten commits"1164fi1165# No cherry-pick because our first pass is to determine1166# parents to rewrite and skipping dropped commits would1167# prematurely end our probe1168 merges_option=1169else1170 merges_option="--no-merges --cherry-pick"1171fi11721173shorthead=$(git rev-parse --short $orig_head)1174shortonto=$(git rev-parse --short $onto)1175iftest -z"$rebase_root"1176# this is now equivalent to ! -z "$upstream"1177then1178 shortupstream=$(git rev-parse --short $upstream)1179 revisions=$upstream...$orig_head1180 shortrevisions=$shortupstream..$shorthead1181else1182 revisions=$onto...$orig_head1183 shortrevisions=$shorthead1184fi1185format=$(git config --get rebase.instructionFormat)1186# the 'rev-list .. | sed' requires %m to parse; the instruction requires %H to parse1187git rev-list$merges_option--format="%m%H${format:-%s}" \1188--reverse --left-right --topo-order \1189$revisions ${restrict_revision+^$restrict_revision}| \1190sed-n"s/^>//p"|1191whileread -r sha1 rest1192do11931194iftest -z"$keep_empty"&& is_empty_commit $sha1&& ! is_merge_commit $sha11195then1196 comment_out="$comment_char"1197else1198 comment_out=1199fi12001201iftest t !="$preserve_merges"1202then1203printf'%s\n'"${comment_out}pick$sha1$rest">>"$todo"1204else1205iftest -z"$rebase_root"1206then1207 preserve=t1208for p in$(git rev-list --parents -1 $sha1 | cut -d' ' -s -f2-)1209do1210iftest -f"$rewritten"/$p1211then1212 preserve=f1213fi1214done1215else1216 preserve=f1217fi1218iftest f ="$preserve"1219then1220touch"$rewritten"/$sha11221printf'%s\n'"${comment_out}pick$sha1$rest">>"$todo"1222fi1223fi1224done12251226# Watch for commits that been dropped by --cherry-pick1227iftest t ="$preserve_merges"1228then1229mkdir"$dropped"1230# Save all non-cherry-picked changes1231 git rev-list$revisions--left-right --cherry-pick| \1232sed-n"s/^>//p">"$state_dir"/not-cherry-picks1233# Now all commits and note which ones are missing in1234# not-cherry-picks and hence being dropped1235 git rev-list$revisions|1236whilereadrev1237do1238iftest -f"$rewritten"/$rev&&1239! sane_grep "$rev""$state_dir"/not-cherry-picks>/dev/null1240then1241# Use -f2 because if rev-list is telling us this commit is1242# not worthwhile, we don't want to track its multiple heads,1243# just the history of its first-parent for others that will1244# be rebasing on top of it1245 git rev-list --parents -1$rev| cut -d' '-s -f2>"$dropped"/$rev1246 sha1=$(git rev-list -1 $rev)1247 sane_grep -v"^[a-z][a-z]*$sha1"<"$todo">"${todo}2";mv"${todo}2""$todo"1248rm"$rewritten"/$rev1249fi1250done1251fi12521253test -s"$todo"||echo noop >>"$todo"1254test -n"$autosquash"&& rearrange_squash "$todo"1255test -n"$cmd"&& add_exec_commands "$todo"12561257todocount=$(git stripspace --strip-comments <"$todo" | wc -l)1258todocount=${todocount##* }12591260cat>>"$todo"<<EOF12611262$comment_charRebase$shortrevisionsonto$shortonto($todocountcommand(s))1263EOF1264append_todo_help1265git stripspace --comment-lines>>"$todo"<<\EOF12661267However,if you remove everything, the rebase will be aborted.12681269EOF12701271iftest -z"$keep_empty"1272then1273printf'%s\n'"$comment_charNote that empty commits are commented out">>"$todo"1274fi127512761277has_action "$todo"||1278return212791280cp"$todo""$todo".backup1281collapse_todo_ids1282git_sequence_editor "$todo"||1283 die_abort "Could not execute editor"12841285has_action "$todo"||1286return212871288check_todo_list12891290expand_todo_ids12911292test -d"$rewritten"||test -n"$force_rebase"|| skip_unnecessary_picks12931294checkout_onto1295do_rest12961297}1298# ... and then we call the whole thing.1299git_rebase__interactive