git-multimail: update to release 1.2.0
[git.git] / git-rebase.sh
blobaf7ba5fd90c3000892ed31893e1812514e4f3773
1 #!/bin/sh
3 # Copyright (c) 2005 Junio C Hamano.
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
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 p,preserve-merges! try to recreate merges instead of ignoring them
21 s,strategy=! use the given merge strategy
22 no-ff! cherry-pick all commits, even if unchanged
23 m,merge! use merging strategies to rebase
24 i,interactive! let the user edit the list of commits to rebase
25 x,exec=! add exec lines after each commit of the editable list
26 k,keep-empty preserve empty commits during rebase
27 f,force-rebase! force rebase even if branch is up to date
28 X,strategy-option=! pass the argument through to the merge strategy
29 stat! display a diffstat of what changed upstream
30 n,no-stat! do not show diffstat of what changed upstream
31 verify allow pre-rebase hook to run
32 rerere-autoupdate allow rerere to update index with resolved conflicts
33 root! rebase all reachable commits up to the root(s)
34 autosquash move commits that begin with squash!/fixup! under -i
35 committer-date-is-author-date! passed to 'git am'
36 ignore-date! passed to 'git am'
37 whitespace=! passed to 'git apply'
38 ignore-whitespace! passed to 'git apply'
39 C=! passed to 'git apply'
40 S,gpg-sign? GPG-sign commits
41 Actions:
42 continue! continue
43 abort! abort and check out the original branch
44 skip! skip current patch and continue
45 edit-todo! edit the todo list during an interactive rebase
47 . git-sh-setup
48 . git-sh-i18n
49 set_reflog_action rebase
50 require_work_tree_exists
51 cd_to_toplevel
53 LF='
55 ok_to_skip_pre_rebase=
56 resolvemsg="
57 $(gettext 'When you have resolved this problem, run "git rebase --continue".
58 If you prefer to skip this patch, run "git rebase --skip" instead.
59 To check out the original branch and stop rebasing, run "git rebase --abort".')
61 unset onto
62 unset restrict_revision
63 cmd=
64 strategy=
65 strategy_opts=
66 do_merge=
67 merge_dir="$GIT_DIR"/rebase-merge
68 apply_dir="$GIT_DIR"/rebase-apply
69 verbose=
70 diffstat=
71 test "$(git config --bool rebase.stat)" = true && diffstat=t
72 autostash="$(git config --bool rebase.autostash || echo false)"
73 fork_point=auto
74 git_am_opt=
75 rebase_root=
76 force_rebase=
77 allow_rerere_autoupdate=
78 # Non-empty if a rebase was in progress when 'git rebase' was invoked
79 in_progress=
80 # One of {am, merge, interactive}
81 type=
82 # One of {"$GIT_DIR"/rebase-apply, "$GIT_DIR"/rebase-merge}
83 state_dir=
84 # One of {'', continue, skip, abort}, as parsed from command line
85 action=
86 preserve_merges=
87 autosquash=
88 keep_empty=
89 test "$(git config --bool rebase.autosquash)" = "true" && autosquash=t
90 gpg_sign_opt=
92 read_basic_state () {
93 test -f "$state_dir/head-name" &&
94 test -f "$state_dir/onto" &&
95 head_name=$(cat "$state_dir"/head-name) &&
96 onto=$(cat "$state_dir"/onto) &&
97 # We always write to orig-head, but interactive rebase used to write to
98 # head. Fall back to reading from head to cover for the case that the
99 # user upgraded git with an ongoing interactive rebase.
100 if test -f "$state_dir"/orig-head
101 then
102 orig_head=$(cat "$state_dir"/orig-head)
103 else
104 orig_head=$(cat "$state_dir"/head)
105 fi &&
106 GIT_QUIET=$(cat "$state_dir"/quiet) &&
107 test -f "$state_dir"/verbose && verbose=t
108 test -f "$state_dir"/strategy && strategy="$(cat "$state_dir"/strategy)"
109 test -f "$state_dir"/strategy_opts &&
110 strategy_opts="$(cat "$state_dir"/strategy_opts)"
111 test -f "$state_dir"/allow_rerere_autoupdate &&
112 allow_rerere_autoupdate="$(cat "$state_dir"/allow_rerere_autoupdate)"
113 test -f "$state_dir"/gpg_sign_opt &&
114 gpg_sign_opt="$(cat "$state_dir"/gpg_sign_opt)"
117 write_basic_state () {
118 echo "$head_name" > "$state_dir"/head-name &&
119 echo "$onto" > "$state_dir"/onto &&
120 echo "$orig_head" > "$state_dir"/orig-head &&
121 echo "$GIT_QUIET" > "$state_dir"/quiet &&
122 test t = "$verbose" && : > "$state_dir"/verbose
123 test -n "$strategy" && echo "$strategy" > "$state_dir"/strategy
124 test -n "$strategy_opts" && echo "$strategy_opts" > \
125 "$state_dir"/strategy_opts
126 test -n "$allow_rerere_autoupdate" && echo "$allow_rerere_autoupdate" > \
127 "$state_dir"/allow_rerere_autoupdate
128 test -n "$gpg_sign_opt" && echo "$gpg_sign_opt" > "$state_dir"/gpg_sign_opt
131 output () {
132 case "$verbose" in
134 output=$("$@" 2>&1 )
135 status=$?
136 test $status != 0 && printf "%s\n" "$output"
137 return $status
140 "$@"
142 esac
145 move_to_original_branch () {
146 case "$head_name" in
147 refs/*)
148 message="rebase finished: $head_name onto $onto"
149 git update-ref -m "$message" \
150 $head_name $(git rev-parse HEAD) $orig_head &&
151 git symbolic-ref \
152 -m "rebase finished: returning to $head_name" \
153 HEAD $head_name ||
154 die "$(gettext "Could not move back to $head_name")"
156 esac
159 apply_autostash () {
160 if test -f "$state_dir/autostash"
161 then
162 stash_sha1=$(cat "$state_dir/autostash")
163 if git stash apply $stash_sha1 2>&1 >/dev/null
164 then
165 echo "$(gettext 'Applied autostash.')"
166 else
167 git stash store -m "autostash" -q $stash_sha1 ||
168 die "$(eval_gettext "Cannot store \$stash_sha1")"
169 gettext 'Applying autostash resulted in conflicts.
170 Your changes are safe in the stash.
171 You can run "git stash pop" or "git stash drop" at any time.
177 finish_rebase () {
178 apply_autostash &&
179 git gc --auto &&
180 rm -rf "$state_dir"
183 run_specific_rebase () {
184 if [ "$interactive_rebase" = implied ]; then
185 GIT_EDITOR=:
186 export GIT_EDITOR
187 autosquash=
189 . git-rebase--$type
190 ret=$?
191 if test $ret -eq 0
192 then
193 finish_rebase
194 elif test $ret -eq 2 # special exit status for rebase -i
195 then
196 apply_autostash &&
197 rm -rf "$state_dir" &&
198 die "Nothing to do"
200 exit $ret
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.")"
212 test -f "$apply_dir"/applying &&
213 die "$(gettext "It looks like git-am is in progress. Cannot rebase.")"
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 -f "$merge_dir"/interactive
222 then
223 type=interactive
224 interactive_rebase=explicit
225 else
226 type=merge
228 state_dir="$merge_dir"
230 test -n "$type" && in_progress=t
232 total_argc=$#
233 while test $# != 0
235 case "$1" in
236 --no-verify)
237 ok_to_skip_pre_rebase=yes
239 --verify)
240 ok_to_skip_pre_rebase=
242 --continue|--skip|--abort|--edit-todo)
243 test $total_argc -eq 2 || usage
244 action=${1##--}
246 --onto=*)
247 onto="${1#--onto=}"
249 --exec=*)
250 cmd="${cmd}exec ${1#--exec=}${LF}"
252 --interactive)
253 interactive_rebase=explicit
255 --keep-empty)
256 keep_empty=yes
258 --preserve-merges)
259 preserve_merges=t
260 test -z "$interactive_rebase" && interactive_rebase=implied
262 --autosquash)
263 autosquash=t
265 --no-autosquash)
266 autosquash=
268 --fork-point)
269 fork_point=t
271 --no-fork-point)
272 fork_point=
274 --merge)
275 do_merge=t
277 --strategy-option=*)
278 strategy_opts="$strategy_opts $(git rev-parse --sq-quote "--${1#--strategy-option=}")"
279 do_merge=t
280 test -z "$strategy" && strategy=recursive
282 --strategy=*)
283 strategy="${1#--strategy=}"
284 do_merge=t
286 --no-stat)
287 diffstat=
289 --stat)
290 diffstat=t
292 --autostash)
293 autostash=true
295 --no-autostash)
296 autostash=false
298 --verbose)
299 verbose=t
300 diffstat=t
301 GIT_QUIET=
303 --quiet)
304 GIT_QUIET=t
305 git_am_opt="$git_am_opt -q"
306 verbose=
307 diffstat=
309 --whitespace=*)
310 git_am_opt="$git_am_opt --whitespace=${1#--whitespace=}"
311 case "${1#--whitespace=}" in
312 fix|strip)
313 force_rebase=t
315 esac
317 --ignore-whitespace)
318 git_am_opt="$git_am_opt $1"
320 --committer-date-is-author-date|--ignore-date)
321 git_am_opt="$git_am_opt $1"
322 force_rebase=t
324 -C*)
325 git_am_opt="$git_am_opt $1"
327 --root)
328 rebase_root=t
330 --force-rebase|--no-ff)
331 force_rebase=t
333 --rerere-autoupdate|--no-rerere-autoupdate)
334 allow_rerere_autoupdate="$1"
336 --gpg-sign)
337 gpg_sign_opt=-S
339 --gpg-sign=*)
340 gpg_sign_opt="-S${1#--gpg-sign=}"
343 shift
344 break
346 esac
347 shift
348 done
349 test $# -gt 2 && usage
351 if test -n "$cmd" &&
352 test "$interactive_rebase" != explicit
353 then
354 die "$(gettext "The --exec option must be used with the --interactive option")"
357 if test -n "$action"
358 then
359 test -z "$in_progress" && die "$(gettext "No rebase in progress?")"
360 # Only interactive rebase uses detailed reflog messages
361 if test "$type" = interactive && test "$GIT_REFLOG_ACTION" = rebase
362 then
363 GIT_REFLOG_ACTION="rebase -i ($action)"
364 export GIT_REFLOG_ACTION
368 if test "$action" = "edit-todo" && test "$type" != "interactive"
369 then
370 die "$(gettext "The --edit-todo action can only be used during interactive rebase.")"
373 case "$action" in
374 continue)
375 # Sanity check
376 git rev-parse --verify HEAD >/dev/null ||
377 die "$(gettext "Cannot read HEAD")"
378 git update-index --ignore-submodules --refresh &&
379 git diff-files --quiet --ignore-submodules || {
380 echo "$(gettext "You must edit all merge conflicts and then
381 mark them as resolved using git add")"
382 exit 1
384 read_basic_state
385 run_specific_rebase
387 skip)
388 output git reset --hard HEAD || exit $?
389 read_basic_state
390 run_specific_rebase
392 abort)
393 git rerere clear
394 read_basic_state
395 case "$head_name" in
396 refs/*)
397 git symbolic-ref -m "rebase: aborting" HEAD $head_name ||
398 die "$(eval_gettext "Could not move back to \$head_name")"
400 esac
401 output git reset --hard $orig_head
402 finish_rebase
403 exit
405 edit-todo)
406 run_specific_rebase
408 esac
410 # Make sure no rebase is in progress
411 if test -n "$in_progress"
412 then
413 state_dir_base=${state_dir##*/}
414 cmd_live_rebase="git rebase (--continue | --abort | --skip)"
415 cmd_clear_stale_rebase="rm -fr \"$state_dir\""
416 die "
417 $(eval_gettext 'It seems that there is already a $state_dir_base directory, and
418 I wonder if you are in the middle of another rebase. If that is the
419 case, please try
420 $cmd_live_rebase
421 If that is not the case, please
422 $cmd_clear_stale_rebase
423 and run me again. I am stopping in case you still have something
424 valuable there.')"
427 if test -n "$rebase_root" && test -z "$onto"
428 then
429 test -z "$interactive_rebase" && interactive_rebase=implied
432 if test -n "$interactive_rebase"
433 then
434 type=interactive
435 state_dir="$merge_dir"
436 elif test -n "$do_merge"
437 then
438 type=merge
439 state_dir="$merge_dir"
440 else
441 type=am
442 state_dir="$apply_dir"
445 if test -z "$rebase_root"
446 then
447 case "$#" in
449 if ! upstream_name=$(git rev-parse --symbolic-full-name \
450 --verify -q @{upstream} 2>/dev/null)
451 then
452 . git-parse-remote
453 error_on_missing_default_upstream "rebase" "rebase" \
454 "against" "git rebase <branch>"
457 test "$fork_point" = auto && fork_point=t
459 *) upstream_name="$1"
460 if test "$upstream_name" = "-"
461 then
462 upstream_name="@{-1}"
464 shift
466 esac
467 upstream=$(peel_committish "${upstream_name}") ||
468 die "$(eval_gettext "invalid upstream \$upstream_name")"
469 upstream_arg="$upstream_name"
470 else
471 if test -z "$onto"
472 then
473 empty_tree=$(git hash-object -t tree /dev/null)
474 onto=$(git commit-tree $empty_tree </dev/null)
475 squash_onto="$onto"
477 unset upstream_name
478 unset upstream
479 test $# -gt 1 && usage
480 upstream_arg=--root
483 # Make sure the branch to rebase onto is valid.
484 onto_name=${onto-"$upstream_name"}
485 case "$onto_name" in
486 *...*)
487 if left=${onto_name%...*} right=${onto_name#*...} &&
488 onto=$(git merge-base --all ${left:-HEAD} ${right:-HEAD})
489 then
490 case "$onto" in
491 ?*"$LF"?*)
492 die "$(eval_gettext "\$onto_name: there are more than one merge bases")"
495 die "$(eval_gettext "\$onto_name: there is no merge base")"
497 esac
498 else
499 die "$(eval_gettext "\$onto_name: there is no merge base")"
503 onto=$(peel_committish "$onto_name") ||
504 die "$(eval_gettext "Does not point to a valid commit: \$onto_name")"
506 esac
508 # If the branch to rebase is given, that is the branch we will rebase
509 # $branch_name -- branch being rebased, or HEAD (already detached)
510 # $orig_head -- commit object name of tip of the branch before rebasing
511 # $head_name -- refs/heads/<that-branch> or "detached HEAD"
512 switch_to=
513 case "$#" in
515 # Is it "rebase other $branchname" or "rebase other $commit"?
516 branch_name="$1"
517 switch_to="$1"
519 if git show-ref --verify --quiet -- "refs/heads/$1" &&
520 orig_head=$(git rev-parse -q --verify "refs/heads/$1")
521 then
522 head_name="refs/heads/$1"
523 elif orig_head=$(git rev-parse -q --verify "$1")
524 then
525 head_name="detached HEAD"
526 else
527 die "$(eval_gettext "fatal: no such branch: \$branch_name")"
531 # Do not need to switch branches, we are already on it.
532 if branch_name=$(git symbolic-ref -q HEAD)
533 then
534 head_name=$branch_name
535 branch_name=$(expr "z$branch_name" : 'zrefs/heads/\(.*\)')
536 else
537 head_name="detached HEAD"
538 branch_name=HEAD ;# detached
540 orig_head=$(git rev-parse --verify HEAD) || exit
543 die "BUG: unexpected number of arguments left to parse"
545 esac
547 if test "$fork_point" = t
548 then
549 new_upstream=$(git merge-base --fork-point "$upstream_name" \
550 "${switch_to:-HEAD}")
551 if test -n "$new_upstream"
552 then
553 restrict_revision=$new_upstream
557 if test "$autostash" = true && ! (require_clean_work_tree) 2>/dev/null
558 then
559 stash_sha1=$(git stash create "autostash") ||
560 die "$(gettext 'Cannot autostash')"
562 mkdir -p "$state_dir" &&
563 echo $stash_sha1 >"$state_dir/autostash" &&
564 stash_abbrev=$(git rev-parse --short $stash_sha1) &&
565 echo "$(eval_gettext 'Created autostash: $stash_abbrev')" &&
566 git reset --hard
569 require_clean_work_tree "rebase" "$(gettext "Please commit or stash them.")"
571 # Now we are rebasing commits $upstream..$orig_head (or with --root,
572 # everything leading up to $orig_head) on top of $onto
574 # Check if we are already based on $onto with linear history,
575 # but this should be done only when upstream and onto are the same
576 # and if this is not an interactive rebase.
577 mb=$(git merge-base "$onto" "$orig_head")
578 if test "$type" != interactive && test "$upstream" = "$onto" &&
579 test "$mb" = "$onto" && test -z "$restrict_revision" &&
580 # linear history?
581 ! (git rev-list --parents "$onto".."$orig_head" | sane_grep " .* ") > /dev/null
582 then
583 if test -z "$force_rebase"
584 then
585 # Lazily switch to the target branch if needed...
586 test -z "$switch_to" ||
587 GIT_REFLOG_ACTION="$GIT_REFLOG_ACTION: checkout $switch_to" \
588 git checkout -q "$switch_to" --
589 say "$(eval_gettext "Current branch \$branch_name is up to date.")"
590 finish_rebase
591 exit 0
592 else
593 say "$(eval_gettext "Current branch \$branch_name is up to date, rebase forced.")"
597 # If a hook exists, give it a chance to interrupt
598 run_pre_rebase_hook "$upstream_arg" "$@"
600 if test -n "$diffstat"
601 then
602 if test -n "$verbose"
603 then
604 echo "$(eval_gettext "Changes from \$mb to \$onto:")"
606 # We want color (if set), but no pager
607 GIT_PAGER='' git diff --stat --summary "$mb" "$onto"
610 test "$type" = interactive && run_specific_rebase
612 # Detach HEAD and reset the tree
613 say "$(gettext "First, rewinding head to replay your work on top of it...")"
615 GIT_REFLOG_ACTION="$GIT_REFLOG_ACTION: checkout $onto_name" \
616 git checkout -q "$onto^0" || die "could not detach HEAD"
617 git update-ref ORIG_HEAD $orig_head
619 # If the $onto is a proper descendant of the tip of the branch, then
620 # we just fast-forwarded.
621 if test "$mb" = "$orig_head"
622 then
623 say "$(eval_gettext "Fast-forwarded \$branch_name to \$onto_name.")"
624 move_to_original_branch
625 finish_rebase
626 exit 0
629 if test -n "$rebase_root"
630 then
631 revisions="$onto..$orig_head"
632 else
633 revisions="${restrict_revision-$upstream}..$orig_head"
636 run_specific_rebase