Merge branch 'ab/checkout-default-remote'
[git] / git-rebase.sh
1 #!/bin/sh
2 #
3 # Copyright (c) 2005 Junio C Hamano.
4 #
5
6 SUBDIRECTORY_OK=Yes
7 OPTIONS_KEEPDASHDASH=
8 OPTIONS_STUCKLONG=t
9 OPTIONS_SPEC="\
10 git rebase [-i] [options] [--exec <cmd>] [--onto <newbase>] [<upstream>] [<branch>]
11 git rebase [-i] [options] [--exec <cmd>] [--onto <newbase>] --root [<branch>]
12 git rebase --continue | --abort | --skip | --edit-todo
13 --
14  Available options are
15 v,verbose!         display a diffstat of what changed upstream
16 q,quiet!           be quiet. implies --no-stat
17 autostash          automatically stash/stash pop before and after
18 fork-point         use 'merge-base --fork-point' to refine upstream
19 onto=!             rebase onto given branch instead of upstream
20 r,rebase-merges?   try to rebase merges instead of skipping them
21 p,preserve-merges! try to recreate merges instead of ignoring them
22 s,strategy=!       use the given merge strategy
23 X,strategy-option=! pass the argument through to the merge strategy
24 no-ff!             cherry-pick all commits, even if unchanged
25 f,force-rebase!    cherry-pick all commits, even if unchanged
26 m,merge!           use merging strategies to rebase
27 i,interactive!     let the user edit the list of commits to rebase
28 x,exec=!           add exec lines after each commit of the editable list
29 k,keep-empty       preserve empty commits during rebase
30 allow-empty-message allow rebasing commits with empty messages
31 stat!              display a diffstat of what changed upstream
32 n,no-stat!         do not show diffstat of what changed upstream
33 verify             allow pre-rebase hook to run
34 rerere-autoupdate  allow rerere to update index with resolved conflicts
35 root!              rebase all reachable commits up to the root(s)
36 autosquash         move commits that begin with squash!/fixup! under -i
37 signoff            add a Signed-off-by: line to each commit
38 committer-date-is-author-date! passed to 'git am'
39 ignore-date!       passed to 'git am'
40 whitespace=!       passed to 'git apply'
41 ignore-whitespace! passed to 'git apply'
42 C=!                passed to 'git apply'
43 S,gpg-sign?        GPG-sign commits
44  Actions:
45 continue!          continue
46 abort!             abort and check out the original branch
47 skip!              skip current patch and continue
48 edit-todo!         edit the todo list during an interactive rebase
49 quit!              abort but keep HEAD where it is
50 show-current-patch! show the patch file being applied or merged
51 "
52 . git-sh-setup
53 set_reflog_action rebase
54 require_work_tree_exists
55 cd_to_toplevel
56
57 LF='
58 '
59 ok_to_skip_pre_rebase=
60 resolvemsg="
61 $(gettext 'Resolve all conflicts manually, mark them as resolved with
62 "git add/rm <conflicted_files>", then run "git rebase --continue".
63 You can instead skip this commit: run "git rebase --skip".
64 To abort and get back to the state before "git rebase", run "git rebase --abort".')
65 "
66 squash_onto=
67 unset onto
68 unset restrict_revision
69 cmd=
70 strategy=
71 strategy_opts=
72 do_merge=
73 merge_dir="$GIT_DIR"/rebase-merge
74 apply_dir="$GIT_DIR"/rebase-apply
75 verbose=
76 diffstat=
77 test "$(git config --bool rebase.stat)" = true && diffstat=t
78 autostash="$(git config --bool rebase.autostash || echo false)"
79 fork_point=auto
80 git_am_opt=
81 git_format_patch_opt=
82 rebase_root=
83 force_rebase=
84 allow_rerere_autoupdate=
85 # Non-empty if a rebase was in progress when 'git rebase' was invoked
86 in_progress=
87 # One of {am, merge, interactive}
88 type=
89 # One of {"$GIT_DIR"/rebase-apply, "$GIT_DIR"/rebase-merge}
90 state_dir=
91 # One of {'', continue, skip, abort}, as parsed from command line
92 action=
93 rebase_merges=
94 rebase_cousins=
95 preserve_merges=
96 autosquash=
97 keep_empty=
98 allow_empty_message=--allow-empty-message
99 signoff=
100 test "$(git config --bool rebase.autosquash)" = "true" && autosquash=t
101 case "$(git config --bool commit.gpgsign)" in
102 true)   gpg_sign_opt=-S ;;
103 *)      gpg_sign_opt= ;;
104 esac
105
106 read_basic_state () {
107         test -f "$state_dir/head-name" &&
108         test -f "$state_dir/onto" &&
109         head_name=$(cat "$state_dir"/head-name) &&
110         onto=$(cat "$state_dir"/onto) &&
111         # We always write to orig-head, but interactive rebase used to write to
112         # head. Fall back to reading from head to cover for the case that the
113         # user upgraded git with an ongoing interactive rebase.
114         if test -f "$state_dir"/orig-head
115         then
116                 orig_head=$(cat "$state_dir"/orig-head)
117         else
118                 orig_head=$(cat "$state_dir"/head)
119         fi &&
120         GIT_QUIET=$(cat "$state_dir"/quiet) &&
121         test -f "$state_dir"/verbose && verbose=t
122         test -f "$state_dir"/strategy && strategy="$(cat "$state_dir"/strategy)"
123         test -f "$state_dir"/strategy_opts &&
124                 strategy_opts="$(cat "$state_dir"/strategy_opts)"
125         test -f "$state_dir"/allow_rerere_autoupdate &&
126                 allow_rerere_autoupdate="$(cat "$state_dir"/allow_rerere_autoupdate)"
127         test -f "$state_dir"/gpg_sign_opt &&
128                 gpg_sign_opt="$(cat "$state_dir"/gpg_sign_opt)"
129         test -f "$state_dir"/signoff && {
130                 signoff="$(cat "$state_dir"/signoff)"
131                 force_rebase=t
132         }
133 }
134
135 write_basic_state () {
136         echo "$head_name" > "$state_dir"/head-name &&
137         echo "$onto" > "$state_dir"/onto &&
138         echo "$orig_head" > "$state_dir"/orig-head &&
139         echo "$GIT_QUIET" > "$state_dir"/quiet &&
140         test t = "$verbose" && : > "$state_dir"/verbose
141         test -n "$strategy" && echo "$strategy" > "$state_dir"/strategy
142         test -n "$strategy_opts" && echo "$strategy_opts" > \
143                 "$state_dir"/strategy_opts
144         test -n "$allow_rerere_autoupdate" && echo "$allow_rerere_autoupdate" > \
145                 "$state_dir"/allow_rerere_autoupdate
146         test -n "$gpg_sign_opt" && echo "$gpg_sign_opt" > "$state_dir"/gpg_sign_opt
147         test -n "$signoff" && echo "$signoff" >"$state_dir"/signoff
148 }
149
150 output () {
151         case "$verbose" in
152         '')
153                 output=$("$@" 2>&1 )
154                 status=$?
155                 test $status != 0 && printf "%s\n" "$output"
156                 return $status
157                 ;;
158         *)
159                 "$@"
160                 ;;
161         esac
162 }
163
164 move_to_original_branch () {
165         case "$head_name" in
166         refs/*)
167                 message="rebase finished: $head_name onto $onto"
168                 git update-ref -m "$message" \
169                         $head_name $(git rev-parse HEAD) $orig_head &&
170                 git symbolic-ref \
171                         -m "rebase finished: returning to $head_name" \
172                         HEAD $head_name ||
173                 die "$(eval_gettext "Could not move back to \$head_name")"
174                 ;;
175         esac
176 }
177
178 apply_autostash () {
179         if test -f "$state_dir/autostash"
180         then
181                 stash_sha1=$(cat "$state_dir/autostash")
182                 if git stash apply $stash_sha1 >/dev/null 2>&1
183                 then
184                         echo "$(gettext 'Applied autostash.')" >&2
185                 else
186                         git stash store -m "autostash" -q $stash_sha1 ||
187                         die "$(eval_gettext "Cannot store \$stash_sha1")"
188                         gettext 'Applying autostash resulted in conflicts.
189 Your changes are safe in the stash.
190 You can run "git stash pop" or "git stash drop" at any time.
191 ' >&2
192                 fi
193         fi
194 }
195
196 finish_rebase () {
197         rm -f "$(git rev-parse --git-path REBASE_HEAD)"
198         apply_autostash &&
199         { git gc --auto || true; } &&
200         rm -rf "$state_dir"
201 }
202
203 run_specific_rebase () {
204         if [ "$interactive_rebase" = implied ]; then
205                 GIT_EDITOR=:
206                 export GIT_EDITOR
207                 autosquash=
208         fi
209         . git-rebase--$type
210
211         if test -z "$preserve_merges"
212         then
213                 git_rebase__$type
214         else
215                 git_rebase__preserve_merges
216         fi
217
218         ret=$?
219         if test $ret -eq 0
220         then
221                 finish_rebase
222         elif test $ret -eq 2 # special exit status for rebase -i
223         then
224                 apply_autostash &&
225                 rm -rf "$state_dir" &&
226                 die "Nothing to do"
227         fi
228         exit $ret
229 }
230
231 run_pre_rebase_hook () {
232         if test -z "$ok_to_skip_pre_rebase" &&
233            test -x "$(git rev-parse --git-path hooks/pre-rebase)"
234         then
235                 "$(git rev-parse --git-path hooks/pre-rebase)" ${1+"$@"} ||
236                 die "$(gettext "The pre-rebase hook refused to rebase.")"
237         fi
238 }
239
240 test -f "$apply_dir"/applying &&
241         die "$(gettext "It looks like 'git am' is in progress. Cannot rebase.")"
242
243 if test -d "$apply_dir"
244 then
245         type=am
246         state_dir="$apply_dir"
247 elif test -d "$merge_dir"
248 then
249         if test -d "$merge_dir"/rewritten
250         then
251                 type=preserve-merges
252                 interactive_rebase=explicit
253                 preserve_merges=t
254         elif test -f "$merge_dir"/interactive
255         then
256                 type=interactive
257                 interactive_rebase=explicit
258         else
259                 type=merge
260         fi
261         state_dir="$merge_dir"
262 fi
263 test -n "$type" && in_progress=t
264
265 total_argc=$#
266 while test $# != 0
267 do
268         case "$1" in
269         --no-verify)
270                 ok_to_skip_pre_rebase=yes
271                 ;;
272         --verify)
273                 ok_to_skip_pre_rebase=
274                 ;;
275         --continue|--skip|--abort|--quit|--edit-todo|--show-current-patch)
276                 test $total_argc -eq 2 || usage
277                 action=${1##--}
278                 ;;
279         --onto=*)
280                 onto="${1#--onto=}"
281                 ;;
282         --exec=*)
283                 cmd="${cmd}exec ${1#--exec=}${LF}"
284                 test -z "$interactive_rebase" && interactive_rebase=implied
285                 ;;
286         --interactive)
287                 interactive_rebase=explicit
288                 ;;
289         --keep-empty)
290                 keep_empty=yes
291                 ;;
292         --allow-empty-message)
293                 allow_empty_message=--allow-empty-message
294                 ;;
295         --no-keep-empty)
296                 keep_empty=
297                 ;;
298         --rebase-merges)
299                 rebase_merges=t
300                 test -z "$interactive_rebase" && interactive_rebase=implied
301                 ;;
302         --rebase-merges=*)
303                 rebase_merges=t
304                 case "${1#*=}" in
305                 rebase-cousins) rebase_cousins=t;;
306                 no-rebase-cousins) rebase_cousins=;;
307                 *) die "Unknown mode: $1";;
308                 esac
309                 test -z "$interactive_rebase" && interactive_rebase=implied
310                 ;;
311         --preserve-merges)
312                 preserve_merges=t
313                 test -z "$interactive_rebase" && interactive_rebase=implied
314                 ;;
315         --autosquash)
316                 autosquash=t
317                 ;;
318         --no-autosquash)
319                 autosquash=
320                 ;;
321         --fork-point)
322                 fork_point=t
323                 ;;
324         --no-fork-point)
325                 fork_point=
326                 ;;
327         --merge)
328                 do_merge=t
329                 ;;
330         --strategy-option=*)
331                 strategy_opts="$strategy_opts $(git rev-parse --sq-quote "--${1#--strategy-option=}" | sed -e s/^.//)"
332                 do_merge=t
333                 test -z "$strategy" && strategy=recursive
334                 ;;
335         --strategy=*)
336                 strategy="${1#--strategy=}"
337                 do_merge=t
338                 ;;
339         --no-stat)
340                 diffstat=
341                 ;;
342         --stat)
343                 diffstat=t
344                 ;;
345         --autostash)
346                 autostash=true
347                 ;;
348         --no-autostash)
349                 autostash=false
350                 ;;
351         --verbose)
352                 verbose=t
353                 diffstat=t
354                 GIT_QUIET=
355                 ;;
356         --quiet)
357                 GIT_QUIET=t
358                 git_am_opt="$git_am_opt -q"
359                 verbose=
360                 diffstat=
361                 ;;
362         --whitespace=*)
363                 git_am_opt="$git_am_opt --whitespace=${1#--whitespace=}"
364                 case "${1#--whitespace=}" in
365                 fix|strip)
366                         force_rebase=t
367                         ;;
368                 esac
369                 ;;
370         --ignore-whitespace)
371                 git_am_opt="$git_am_opt $1"
372                 ;;
373         --signoff)
374                 signoff=--signoff
375                 ;;
376         --no-signoff)
377                 signoff=
378                 ;;
379         --committer-date-is-author-date|--ignore-date)
380                 git_am_opt="$git_am_opt $1"
381                 force_rebase=t
382                 ;;
383         -C*)
384                 git_am_opt="$git_am_opt $1"
385                 ;;
386         --root)
387                 rebase_root=t
388                 ;;
389         --force-rebase|--no-ff)
390                 force_rebase=t
391                 ;;
392         --rerere-autoupdate|--no-rerere-autoupdate)
393                 allow_rerere_autoupdate="$1"
394                 ;;
395         --gpg-sign)
396                 gpg_sign_opt=-S
397                 ;;
398         --gpg-sign=*)
399                 gpg_sign_opt="-S${1#--gpg-sign=}"
400                 ;;
401         --)
402                 shift
403                 break
404                 ;;
405         *)
406                 usage
407                 ;;
408         esac
409         shift
410 done
411 test $# -gt 2 && usage
412
413 if test -n "$action"
414 then
415         test -z "$in_progress" && die "$(gettext "No rebase in progress?")"
416         # Only interactive rebase uses detailed reflog messages
417         if test -n "$interactive_rebase" && test "$GIT_REFLOG_ACTION" = rebase
418         then
419                 GIT_REFLOG_ACTION="rebase -i ($action)"
420                 export GIT_REFLOG_ACTION
421         fi
422 fi
423
424 if test "$action" = "edit-todo" && test -z "$interactive_rebase"
425 then
426         die "$(gettext "The --edit-todo action can only be used during interactive rebase.")"
427 fi
428
429 case "$action" in
430 continue)
431         # Sanity check
432         git rev-parse --verify HEAD >/dev/null ||
433                 die "$(gettext "Cannot read HEAD")"
434         git update-index --ignore-submodules --refresh &&
435         git diff-files --quiet --ignore-submodules || {
436                 echo "$(gettext "You must edit all merge conflicts and then
437 mark them as resolved using git add")"
438                 exit 1
439         }
440         read_basic_state
441         run_specific_rebase
442         ;;
443 skip)
444         output git reset --hard HEAD || exit $?
445         read_basic_state
446         run_specific_rebase
447         ;;
448 abort)
449         git rerere clear
450         read_basic_state
451         case "$head_name" in
452         refs/*)
453                 git symbolic-ref -m "rebase: aborting" HEAD $head_name ||
454                 die "$(eval_gettext "Could not move back to \$head_name")"
455                 ;;
456         esac
457         output git reset --hard $orig_head
458         finish_rebase
459         exit
460         ;;
461 quit)
462         exec rm -rf "$state_dir"
463         ;;
464 edit-todo)
465         run_specific_rebase
466         ;;
467 show-current-patch)
468         run_specific_rebase
469         die "BUG: run_specific_rebase is not supposed to return here"
470         ;;
471 esac
472
473 # Make sure no rebase is in progress
474 if test -n "$in_progress"
475 then
476         state_dir_base=${state_dir##*/}
477         cmd_live_rebase="git rebase (--continue | --abort | --skip)"
478         cmd_clear_stale_rebase="rm -fr \"$state_dir\""
479         die "
480 $(eval_gettext 'It seems that there is already a $state_dir_base directory, and
481 I wonder if you are in the middle of another rebase.  If that is the
482 case, please try
483         $cmd_live_rebase
484 If that is not the case, please
485         $cmd_clear_stale_rebase
486 and run me again.  I am stopping in case you still have something
487 valuable there.')"
488 fi
489
490 if test -n "$rebase_root" && test -z "$onto"
491 then
492         test -z "$interactive_rebase" && interactive_rebase=implied
493 fi
494
495 if test -n "$keep_empty"
496 then
497         test -z "$interactive_rebase" && interactive_rebase=implied
498 fi
499
500 if test -n "$interactive_rebase"
501 then
502         if test -z "$preserve_merges"
503         then
504                 type=interactive
505         else
506                 type=preserve-merges
507         fi
508
509         state_dir="$merge_dir"
510 elif test -n "$do_merge"
511 then
512         type=merge
513         state_dir="$merge_dir"
514 else
515         type=am
516         state_dir="$apply_dir"
517 fi
518
519 if test -t 2 && test -z "$GIT_QUIET"
520 then
521         git_format_patch_opt="$git_format_patch_opt --progress"
522 fi
523
524 if test -n "$git_am_opt"; then
525         incompatible_opts=$(echo " $git_am_opt " | \
526                             sed -e 's/ -q / /g' -e 's/^ \(.*\) $/\1/')
527         if test -n "$interactive_rebase"
528         then
529                 if test -n "$incompatible_opts"
530                 then
531                         die "$(gettext "error: cannot combine interactive options (--interactive, --exec, --rebase-merges, --preserve-merges, --keep-empty, --root + --onto) with am options ($incompatible_opts)")"
532                 fi
533         fi
534         if test -n "$do_merge"; then
535                 if test -n "$incompatible_opts"
536                 then
537                         die "$(gettext "error: cannot combine merge options (--merge, --strategy, --strategy-option) with am options ($incompatible_opts)")"
538                 fi
539         fi
540 fi
541
542 if test -n "$signoff"
543 then
544         test -n "$preserve_merges" &&
545                 die "$(gettext "error: cannot combine '--signoff' with '--preserve-merges'")"
546         git_am_opt="$git_am_opt $signoff"
547         force_rebase=t
548 fi
549
550 if test -n "$preserve_merges"
551 then
552         # Note: incompatibility with --signoff handled in signoff block above
553         # Note: incompatibility with --interactive is just a strong warning;
554         #       git-rebase.txt caveats with "unless you know what you are doing"
555         test -n "$rebase_merges" &&
556                 die "$(gettext "error: cannot combine '--preserve_merges' with '--rebase-merges'")"
557 fi
558
559 if test -n "$rebase_merges"
560 then
561         test -n "$strategy_opts" &&
562                 die "$(gettext "error: cannot combine '--rebase_merges' with '--strategy-option'")"
563         test -n "$strategy" &&
564                 die "$(gettext "error: cannot combine '--rebase_merges' with '--strategy'")"
565 fi
566
567 if test -z "$rebase_root"
568 then
569         case "$#" in
570         0)
571                 if ! upstream_name=$(git rev-parse --symbolic-full-name \
572                         --verify -q @{upstream} 2>/dev/null)
573                 then
574                         . git-parse-remote
575                         error_on_missing_default_upstream "rebase" "rebase" \
576                                 "against" "git rebase $(gettext '<branch>')"
577                 fi
578
579                 test "$fork_point" = auto && fork_point=t
580                 ;;
581         *)      upstream_name="$1"
582                 if test "$upstream_name" = "-"
583                 then
584                         upstream_name="@{-1}"
585                 fi
586                 shift
587                 ;;
588         esac
589         upstream=$(peel_committish "${upstream_name}") ||
590         die "$(eval_gettext "invalid upstream '\$upstream_name'")"
591         upstream_arg="$upstream_name"
592 else
593         if test -z "$onto"
594         then
595                 empty_tree=$(git hash-object -t tree /dev/null)
596                 onto=$(git commit-tree $empty_tree </dev/null)
597                 squash_onto="$onto"
598         fi
599         unset upstream_name
600         unset upstream
601         test $# -gt 1 && usage
602         upstream_arg=--root
603 fi
604
605 # Make sure the branch to rebase onto is valid.
606 onto_name=${onto-"$upstream_name"}
607 case "$onto_name" in
608 *...*)
609         if      left=${onto_name%...*} right=${onto_name#*...} &&
610                 onto=$(git merge-base --all ${left:-HEAD} ${right:-HEAD})
611         then
612                 case "$onto" in
613                 ?*"$LF"?*)
614                         die "$(eval_gettext "\$onto_name: there are more than one merge bases")"
615                         ;;
616                 '')
617                         die "$(eval_gettext "\$onto_name: there is no merge base")"
618                         ;;
619                 esac
620         else
621                 die "$(eval_gettext "\$onto_name: there is no merge base")"
622         fi
623         ;;
624 *)
625         onto=$(peel_committish "$onto_name") ||
626         die "$(eval_gettext "Does not point to a valid commit: \$onto_name")"
627         ;;
628 esac
629
630 # If the branch to rebase is given, that is the branch we will rebase
631 # $branch_name -- branch/commit being rebased, or HEAD (already detached)
632 # $orig_head -- commit object name of tip of the branch before rebasing
633 # $head_name -- refs/heads/<that-branch> or "detached HEAD"
634 switch_to=
635 case "$#" in
636 1)
637         # Is it "rebase other $branchname" or "rebase other $commit"?
638         branch_name="$1"
639         switch_to="$1"
640
641         # Is it a local branch?
642         if git show-ref --verify --quiet -- "refs/heads/$branch_name" &&
643            orig_head=$(git rev-parse -q --verify "refs/heads/$branch_name")
644         then
645                 head_name="refs/heads/$branch_name"
646         # If not is it a valid ref (branch or commit)?
647         elif orig_head=$(git rev-parse -q --verify "$branch_name")
648         then
649                 head_name="detached HEAD"
650
651         else
652                 die "$(eval_gettext "fatal: no such branch/commit '\$branch_name'")"
653         fi
654         ;;
655 0)
656         # Do not need to switch branches, we are already on it.
657         if branch_name=$(git symbolic-ref -q HEAD)
658         then
659                 head_name=$branch_name
660                 branch_name=$(expr "z$branch_name" : 'zrefs/heads/\(.*\)')
661         else
662                 head_name="detached HEAD"
663                 branch_name=HEAD
664         fi
665         orig_head=$(git rev-parse --verify HEAD) || exit
666         ;;
667 *)
668         die "BUG: unexpected number of arguments left to parse"
669         ;;
670 esac
671
672 if test "$fork_point" = t
673 then
674         new_upstream=$(git merge-base --fork-point "$upstream_name" \
675                         "${switch_to:-HEAD}")
676         if test -n "$new_upstream"
677         then
678                 restrict_revision=$new_upstream
679         fi
680 fi
681
682 if test "$autostash" = true && ! (require_clean_work_tree) 2>/dev/null
683 then
684         stash_sha1=$(git stash create "autostash") ||
685         die "$(gettext 'Cannot autostash')"
686
687         mkdir -p "$state_dir" &&
688         echo $stash_sha1 >"$state_dir/autostash" &&
689         stash_abbrev=$(git rev-parse --short $stash_sha1) &&
690         echo "$(eval_gettext 'Created autostash: $stash_abbrev')" &&
691         git reset --hard
692 fi
693
694 require_clean_work_tree "rebase" "$(gettext "Please commit or stash them.")"
695
696 # Now we are rebasing commits $upstream..$orig_head (or with --root,
697 # everything leading up to $orig_head) on top of $onto
698
699 # Check if we are already based on $onto with linear history,
700 # but this should be done only when upstream and onto are the same
701 # and if this is not an interactive rebase.
702 mb=$(git merge-base "$onto" "$orig_head")
703 if test -z "$interactive_rebase" && test "$upstream" = "$onto" &&
704         test "$mb" = "$onto" && test -z "$restrict_revision" &&
705         # linear history?
706         ! (git rev-list --parents "$onto".."$orig_head" | sane_grep " .* ") > /dev/null
707 then
708         if test -z "$force_rebase"
709         then
710                 # Lazily switch to the target branch if needed...
711                 test -z "$switch_to" ||
712                 GIT_REFLOG_ACTION="$GIT_REFLOG_ACTION: checkout $switch_to" \
713                         git checkout -q "$switch_to" --
714                 if test "$branch_name" = "HEAD" &&
715                          ! git symbolic-ref -q HEAD
716                 then
717                         say "$(eval_gettext "HEAD is up to date.")"
718                 else
719                         say "$(eval_gettext "Current branch \$branch_name is up to date.")"
720                 fi
721                 finish_rebase
722                 exit 0
723         else
724                 if test "$branch_name" = "HEAD" &&
725                          ! git symbolic-ref -q HEAD
726                 then
727                         say "$(eval_gettext "HEAD is up to date, rebase forced.")"
728                 else
729                         say "$(eval_gettext "Current branch \$branch_name is up to date, rebase forced.")"
730                 fi
731         fi
732 fi
733
734 # If a hook exists, give it a chance to interrupt
735 run_pre_rebase_hook "$upstream_arg" "$@"
736
737 if test -n "$diffstat"
738 then
739         if test -n "$verbose"
740         then
741                 echo "$(eval_gettext "Changes from \$mb to \$onto:")"
742         fi
743         # We want color (if set), but no pager
744         GIT_PAGER='' git diff --stat --summary "$mb" "$onto"
745 fi
746
747 test -n "$interactive_rebase" && run_specific_rebase
748
749 # Detach HEAD and reset the tree
750 say "$(gettext "First, rewinding head to replay your work on top of it...")"
751
752 GIT_REFLOG_ACTION="$GIT_REFLOG_ACTION: checkout $onto_name" \
753         git checkout -q "$onto^0" || die "could not detach HEAD"
754 git update-ref ORIG_HEAD $orig_head
755
756 # If the $onto is a proper descendant of the tip of the branch, then
757 # we just fast-forwarded.
758 if test "$mb" = "$orig_head"
759 then
760         say "$(eval_gettext "Fast-forwarded \$branch_name to \$onto_name.")"
761         move_to_original_branch
762         finish_rebase
763         exit 0
764 fi
765
766 if test -n "$rebase_root"
767 then
768         revisions="$onto..$orig_head"
769 else
770         revisions="${restrict_revision-$upstream}..$orig_head"
771 fi
772
773 run_specific_rebase