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