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