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