Merge branch 'js/mailinfo'
[git] / git-rebase--interactive.sh
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 USAGE='(--continue | --abort | --skip | [--preserve-merges] [--verbose]
14         [--onto <branch>] <upstream> [<branch>])'
15
16 OPTIONS_SPEC=
17 . git-sh-setup
18 require_work_tree
19
20 DOTEST="$GIT_DIR/.dotest-merge"
21 TODO="$DOTEST"/git-rebase-todo
22 DONE="$DOTEST"/done
23 MSG="$DOTEST"/message
24 SQUASH_MSG="$DOTEST"/message-squash
25 REWRITTEN="$DOTEST"/rewritten
26 PRESERVE_MERGES=
27 STRATEGY=
28 VERBOSE=
29 test -d "$REWRITTEN" && PRESERVE_MERGES=t
30 test -f "$DOTEST"/strategy && STRATEGY="$(cat "$DOTEST"/strategy)"
31 test -f "$DOTEST"/verbose && VERBOSE=t
32
33 GIT_CHERRY_PICK_HELP="  After resolving the conflicts,
34 mark the corrected paths with 'git add <paths>', and
35 run 'git rebase --continue'"
36 export GIT_CHERRY_PICK_HELP
37
38 warn () {
39         echo "$*" >&2
40 }
41
42 output () {
43         case "$VERBOSE" in
44         '')
45                 output=$("$@" 2>&1 )
46                 status=$?
47                 test $status != 0 && printf "%s\n" "$output"
48                 return $status
49                 ;;
50         *)
51                 "$@"
52                 ;;
53         esac
54 }
55
56 require_clean_work_tree () {
57         # test if working tree is dirty
58         git rev-parse --verify HEAD > /dev/null &&
59         git update-index --ignore-submodules --refresh &&
60         git diff-files --quiet --ignore-submodules &&
61         git diff-index --cached --quiet HEAD --ignore-submodules -- ||
62         die "Working tree is dirty"
63 }
64
65 ORIG_REFLOG_ACTION="$GIT_REFLOG_ACTION"
66
67 comment_for_reflog () {
68         case "$ORIG_REFLOG_ACTION" in
69         ''|rebase*)
70                 GIT_REFLOG_ACTION="rebase -i ($1)"
71                 export GIT_REFLOG_ACTION
72                 ;;
73         esac
74 }
75
76 last_count=
77 mark_action_done () {
78         sed -e 1q < "$TODO" >> "$DONE"
79         sed -e 1d < "$TODO" >> "$TODO".new
80         mv -f "$TODO".new "$TODO"
81         count=$(grep -c '^[^#]' < "$DONE")
82         total=$(($count+$(grep -c '^[^#]' < "$TODO")))
83         if test "$last_count" != "$count"
84         then
85                 last_count=$count
86                 printf "Rebasing (%d/%d)\r" $count $total
87                 test -z "$VERBOSE" || echo
88         fi
89 }
90
91 make_patch () {
92         parent_sha1=$(git rev-parse --verify "$1"^) ||
93                 die "Cannot get patch for $1^"
94         git diff-tree -p "$parent_sha1".."$1" > "$DOTEST"/patch
95         test -f "$DOTEST"/message ||
96                 git cat-file commit "$1" | sed "1,/^$/d" > "$DOTEST"/message
97         test -f "$DOTEST"/author-script ||
98                 get_author_ident_from_commit "$1" > "$DOTEST"/author-script
99 }
100
101 die_with_patch () {
102         make_patch "$1"
103         git rerere
104         die "$2"
105 }
106
107 die_abort () {
108         rm -rf "$DOTEST"
109         die "$1"
110 }
111
112 has_action () {
113         grep '^[^#]' "$1" >/dev/null
114 }
115
116 pick_one () {
117         no_ff=
118         case "$1" in -n) sha1=$2; no_ff=t ;; *) sha1=$1 ;; esac
119         output git rev-parse --verify $sha1 || die "Invalid commit name: $sha1"
120         test -d "$REWRITTEN" &&
121                 pick_one_preserving_merges "$@" && return
122         parent_sha1=$(git rev-parse --verify $sha1^) ||
123                 die "Could not get the parent of $sha1"
124         current_sha1=$(git rev-parse --verify HEAD)
125         if test "$no_ff$current_sha1" = "$parent_sha1"; then
126                 output git reset --hard $sha1
127                 test "a$1" = a-n && output git reset --soft $current_sha1
128                 sha1=$(git rev-parse --short $sha1)
129                 output warn Fast forward to $sha1
130         else
131                 output git cherry-pick "$@"
132         fi
133 }
134
135 pick_one_preserving_merges () {
136         case "$1" in -n) sha1=$2 ;; *) sha1=$1 ;; esac
137         sha1=$(git rev-parse $sha1)
138
139         if test -f "$DOTEST"/current-commit
140         then
141                 current_commit=$(cat "$DOTEST"/current-commit) &&
142                 git rev-parse HEAD > "$REWRITTEN"/$current_commit &&
143                 rm "$DOTEST"/current-commit ||
144                 die "Cannot write current commit's replacement sha1"
145         fi
146
147         # rewrite parents; if none were rewritten, we can fast-forward.
148         fast_forward=t
149         preserve=t
150         new_parents=
151         for p in $(git rev-list --parents -1 $sha1 | cut -d' ' -f2-)
152         do
153                 if test -f "$REWRITTEN"/$p
154                 then
155                         preserve=f
156                         new_p=$(cat "$REWRITTEN"/$p)
157                         test $p != $new_p && fast_forward=f
158                         case "$new_parents" in
159                         *$new_p*)
160                                 ;; # do nothing; that parent is already there
161                         *)
162                                 new_parents="$new_parents $new_p"
163                                 ;;
164                         esac
165                 fi
166         done
167         case $fast_forward in
168         t)
169                 output warn "Fast forward to $sha1"
170                 test $preserve = f || echo $sha1 > "$REWRITTEN"/$sha1
171                 ;;
172         f)
173                 test "a$1" = a-n && die "Refusing to squash a merge: $sha1"
174
175                 first_parent=$(expr "$new_parents" : ' \([^ ]*\)')
176                 # detach HEAD to current parent
177                 output git checkout $first_parent 2> /dev/null ||
178                         die "Cannot move HEAD to $first_parent"
179
180                 echo $sha1 > "$DOTEST"/current-commit
181                 case "$new_parents" in
182                 ' '*' '*)
183                         # redo merge
184                         author_script=$(get_author_ident_from_commit $sha1)
185                         eval "$author_script"
186                         msg="$(git cat-file commit $sha1 | sed -e '1,/^$/d')"
187                         # No point in merging the first parent, that's HEAD
188                         new_parents=${new_parents# $first_parent}
189                         if ! GIT_AUTHOR_NAME="$GIT_AUTHOR_NAME" \
190                                 GIT_AUTHOR_EMAIL="$GIT_AUTHOR_EMAIL" \
191                                 GIT_AUTHOR_DATE="$GIT_AUTHOR_DATE" \
192                                 output git merge $STRATEGY -m "$msg" \
193                                         $new_parents
194                         then
195                                 git rerere
196                                 printf "%s\n" "$msg" > "$GIT_DIR"/MERGE_MSG
197                                 die Error redoing merge $sha1
198                         fi
199                         ;;
200                 *)
201                         output git cherry-pick "$@" ||
202                                 die_with_patch $sha1 "Could not pick $sha1"
203                         ;;
204                 esac
205                 ;;
206         esac
207 }
208
209 nth_string () {
210         case "$1" in
211         *1[0-9]|*[04-9]) echo "$1"th;;
212         *1) echo "$1"st;;
213         *2) echo "$1"nd;;
214         *3) echo "$1"rd;;
215         esac
216 }
217
218 make_squash_message () {
219         if test -f "$SQUASH_MSG"; then
220                 COUNT=$(($(sed -n "s/^# This is [^0-9]*\([1-9][0-9]*\).*/\1/p" \
221                         < "$SQUASH_MSG" | sed -ne '$p')+1))
222                 echo "# This is a combination of $COUNT commits."
223                 sed -e 1d -e '2,/^./{
224                         /^$/d
225                 }' <"$SQUASH_MSG"
226         else
227                 COUNT=2
228                 echo "# This is a combination of two commits."
229                 echo "# The first commit's message is:"
230                 echo
231                 git cat-file commit HEAD | sed -e '1,/^$/d'
232         fi
233         echo
234         echo "# This is the $(nth_string $COUNT) commit message:"
235         echo
236         git cat-file commit $1 | sed -e '1,/^$/d'
237 }
238
239 peek_next_command () {
240         sed -n "1s/ .*$//p" < "$TODO"
241 }
242
243 do_next () {
244         rm -f "$DOTEST"/message "$DOTEST"/author-script \
245                 "$DOTEST"/amend || exit
246         read command sha1 rest < "$TODO"
247         case "$command" in
248         '#'*|'')
249                 mark_action_done
250                 ;;
251         pick|p)
252                 comment_for_reflog pick
253
254                 mark_action_done
255                 pick_one $sha1 ||
256                         die_with_patch $sha1 "Could not apply $sha1... $rest"
257                 ;;
258         edit|e)
259                 comment_for_reflog edit
260
261                 mark_action_done
262                 pick_one $sha1 ||
263                         die_with_patch $sha1 "Could not apply $sha1... $rest"
264                 make_patch $sha1
265                 : > "$DOTEST"/amend
266                 warn
267                 warn "You can amend the commit now, with"
268                 warn
269                 warn "  git commit --amend"
270                 warn
271                 warn "Once you are satisfied with your changes, run"
272                 warn
273                 warn "  git rebase --continue"
274                 warn
275                 exit 0
276                 ;;
277         squash|s)
278                 comment_for_reflog squash
279
280                 has_action "$DONE" ||
281                         die "Cannot 'squash' without a previous commit"
282
283                 mark_action_done
284                 make_squash_message $sha1 > "$MSG"
285                 case "$(peek_next_command)" in
286                 squash|s)
287                         EDIT_COMMIT=
288                         USE_OUTPUT=output
289                         cp "$MSG" "$SQUASH_MSG"
290                         ;;
291                 *)
292                         EDIT_COMMIT=-e
293                         USE_OUTPUT=
294                         rm -f "$SQUASH_MSG" || exit
295                         ;;
296                 esac
297
298                 failed=f
299                 author_script=$(get_author_ident_from_commit HEAD)
300                 output git reset --soft HEAD^
301                 pick_one -n $sha1 || failed=t
302                 echo "$author_script" > "$DOTEST"/author-script
303                 if test $failed = f
304                 then
305                         # This is like --amend, but with a different message
306                         eval "$author_script"
307                         GIT_AUTHOR_NAME="$GIT_AUTHOR_NAME" \
308                         GIT_AUTHOR_EMAIL="$GIT_AUTHOR_EMAIL" \
309                         GIT_AUTHOR_DATE="$GIT_AUTHOR_DATE" \
310                         $USE_OUTPUT git commit --no-verify -F "$MSG" $EDIT_COMMIT || failed=t
311                 fi
312                 if test $failed = t
313                 then
314                         cp "$MSG" "$GIT_DIR"/MERGE_MSG
315                         warn
316                         warn "Could not apply $sha1... $rest"
317                         die_with_patch $sha1 ""
318                 fi
319                 ;;
320         *)
321                 warn "Unknown command: $command $sha1 $rest"
322                 die_with_patch $sha1 "Please fix this in the file $TODO."
323                 ;;
324         esac
325         test -s "$TODO" && return
326
327         comment_for_reflog finish &&
328         HEADNAME=$(cat "$DOTEST"/head-name) &&
329         OLDHEAD=$(cat "$DOTEST"/head) &&
330         SHORTONTO=$(git rev-parse --short $(cat "$DOTEST"/onto)) &&
331         if test -d "$REWRITTEN"
332         then
333                 test -f "$DOTEST"/current-commit &&
334                         current_commit=$(cat "$DOTEST"/current-commit) &&
335                         git rev-parse HEAD > "$REWRITTEN"/$current_commit
336                 if test -f "$REWRITTEN"/$OLDHEAD
337                 then
338                         NEWHEAD=$(cat "$REWRITTEN"/$OLDHEAD)
339                 else
340                         NEWHEAD=$OLDHEAD
341                 fi
342         else
343                 NEWHEAD=$(git rev-parse HEAD)
344         fi &&
345         case $HEADNAME in
346         refs/*)
347                 message="$GIT_REFLOG_ACTION: $HEADNAME onto $SHORTONTO)" &&
348                 git update-ref -m "$message" $HEADNAME $NEWHEAD $OLDHEAD &&
349                 git symbolic-ref HEAD $HEADNAME
350                 ;;
351         esac && {
352                 test ! -f "$DOTEST"/verbose ||
353                         git diff-tree --stat $(cat "$DOTEST"/head)..HEAD
354         } &&
355         rm -rf "$DOTEST" &&
356         git gc --auto &&
357         warn "Successfully rebased and updated $HEADNAME."
358
359         exit
360 }
361
362 do_rest () {
363         while :
364         do
365                 do_next
366         done
367 }
368
369 while test $# != 0
370 do
371         case "$1" in
372         --continue)
373                 comment_for_reflog continue
374
375                 test -d "$DOTEST" || die "No interactive rebase running"
376
377                 # Sanity check
378                 git rev-parse --verify HEAD >/dev/null ||
379                         die "Cannot read HEAD"
380                 git update-index --ignore-submodules --refresh &&
381                         git diff-files --quiet --ignore-submodules ||
382                         die "Working tree is dirty"
383
384                 # do we have anything to commit?
385                 if git diff-index --cached --quiet --ignore-submodules HEAD --
386                 then
387                         : Nothing to commit -- skip this
388                 else
389                         . "$DOTEST"/author-script ||
390                                 die "Cannot find the author identity"
391                         if test -f "$DOTEST"/amend
392                         then
393                                 git reset --soft HEAD^ ||
394                                 die "Cannot rewind the HEAD"
395                         fi
396                         export GIT_AUTHOR_NAME GIT_AUTHOR_EMAIL GIT_AUTHOR_DATE &&
397                         git commit --no-verify -F "$DOTEST"/message -e ||
398                         die "Could not commit staged changes."
399                 fi
400
401                 require_clean_work_tree
402                 do_rest
403                 ;;
404         --abort)
405                 comment_for_reflog abort
406
407                 git rerere clear
408                 test -d "$DOTEST" || die "No interactive rebase running"
409
410                 HEADNAME=$(cat "$DOTEST"/head-name)
411                 HEAD=$(cat "$DOTEST"/head)
412                 case $HEADNAME in
413                 refs/*)
414                         git symbolic-ref HEAD $HEADNAME
415                         ;;
416                 esac &&
417                 output git reset --hard $HEAD &&
418                 rm -rf "$DOTEST"
419                 exit
420                 ;;
421         --skip)
422                 comment_for_reflog skip
423
424                 git rerere clear
425                 test -d "$DOTEST" || die "No interactive rebase running"
426
427                 output git reset --hard && do_rest
428                 ;;
429         -s|--strategy)
430                 case "$#,$1" in
431                 *,*=*)
432                         STRATEGY="-s "$(expr "z$1" : 'z-[^=]*=\(.*\)') ;;
433                 1,*)
434                         usage ;;
435                 *)
436                         STRATEGY="-s $2"
437                         shift ;;
438                 esac
439                 ;;
440         -m|--merge)
441                 # we use merge anyway
442                 ;;
443         -C*)
444                 die "Interactive rebase uses merge, so $1 does not make sense"
445                 ;;
446         -v|--verbose)
447                 VERBOSE=t
448                 ;;
449         -p|--preserve-merges)
450                 PRESERVE_MERGES=t
451                 ;;
452         -i|--interactive)
453                 # yeah, we know
454                 ;;
455         ''|-h)
456                 usage
457                 ;;
458         *)
459                 test -d "$DOTEST" &&
460                         die "Interactive rebase already started"
461
462                 git var GIT_COMMITTER_IDENT >/dev/null ||
463                         die "You need to set your committer info first"
464
465                 comment_for_reflog start
466
467                 ONTO=
468                 case "$1" in
469                 --onto)
470                         ONTO=$(git rev-parse --verify "$2") ||
471                                 die "Does not point to a valid commit: $2"
472                         shift; shift
473                         ;;
474                 esac
475
476                 require_clean_work_tree
477
478                 if test ! -z "$2"
479                 then
480                         output git show-ref --verify --quiet "refs/heads/$2" ||
481                                 die "Invalid branchname: $2"
482                         output git checkout "$2" ||
483                                 die "Could not checkout $2"
484                 fi
485
486                 HEAD=$(git rev-parse --verify HEAD) || die "No HEAD?"
487                 UPSTREAM=$(git rev-parse --verify "$1") || die "Invalid base"
488
489                 mkdir "$DOTEST" || die "Could not create temporary $DOTEST"
490
491                 test -z "$ONTO" && ONTO=$UPSTREAM
492
493                 : > "$DOTEST"/interactive || die "Could not mark as interactive"
494                 git symbolic-ref HEAD > "$DOTEST"/head-name 2> /dev/null ||
495                         echo "detached HEAD" > "$DOTEST"/head-name
496
497                 echo $HEAD > "$DOTEST"/head
498                 echo $UPSTREAM > "$DOTEST"/upstream
499                 echo $ONTO > "$DOTEST"/onto
500                 test -z "$STRATEGY" || echo "$STRATEGY" > "$DOTEST"/strategy
501                 test t = "$VERBOSE" && : > "$DOTEST"/verbose
502                 if test t = "$PRESERVE_MERGES"
503                 then
504                         # $REWRITTEN contains files for each commit that is
505                         # reachable by at least one merge base of $HEAD and
506                         # $UPSTREAM. They are not necessarily rewritten, but
507                         # their children might be.
508                         # This ensures that commits on merged, but otherwise
509                         # unrelated side branches are left alone. (Think "X"
510                         # in the man page's example.)
511                         mkdir "$REWRITTEN" &&
512                         for c in $(git merge-base --all $HEAD $UPSTREAM)
513                         do
514                                 echo $ONTO > "$REWRITTEN"/$c ||
515                                         die "Could not init rewritten commits"
516                         done
517                         MERGES_OPTION=
518                 else
519                         MERGES_OPTION=--no-merges
520                 fi
521
522                 SHORTUPSTREAM=$(git rev-parse --short $UPSTREAM)
523                 SHORTHEAD=$(git rev-parse --short $HEAD)
524                 SHORTONTO=$(git rev-parse --short $ONTO)
525                 git rev-list $MERGES_OPTION --pretty=oneline --abbrev-commit \
526                         --abbrev=7 --reverse --left-right --cherry-pick \
527                         $UPSTREAM...$HEAD | \
528                         sed -n "s/^>/pick /p" > "$TODO"
529                 cat >> "$TODO" << EOF
530
531 # Rebase $SHORTUPSTREAM..$SHORTHEAD onto $SHORTONTO
532 #
533 # Commands:
534 #  pick = use commit
535 #  edit = use commit, but stop for amending
536 #  squash = use commit, but meld into previous commit
537 #
538 # If you remove a line here THAT COMMIT WILL BE LOST.
539 # However, if you remove everything, the rebase will be aborted.
540 #
541 EOF
542
543                 has_action "$TODO" ||
544                         die_abort "Nothing to do"
545
546                 cp "$TODO" "$TODO".backup
547                 git_editor "$TODO" ||
548                         die "Could not execute editor"
549
550                 has_action "$TODO" ||
551                         die_abort "Nothing to do"
552
553                 output git checkout $ONTO && do_rest
554                 ;;
555         esac
556         shift
557 done