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