Start preparing for 1.8.4.2
[alt-git.git] / git-rebase.sh
blob226752fbff62f4f27da95f7d711c898503fd7148
1 #!/bin/sh
3 # Copyright (c) 2005 Junio C Hamano.
6 SUBDIRECTORY_OK=Yes
7 OPTIONS_KEEPDASHDASH=
8 OPTIONS_SPEC="\
9 git rebase [-i] [options] [--exec <cmd>] [--onto <newbase>] [<upstream>] [<branch>]
10 git rebase [-i] [options] [--exec <cmd>] [--onto <newbase>] --root [<branch>]
11 git-rebase --continue | --abort | --skip | --edit-todo
13 Available options are
14 v,verbose! display a diffstat of what changed upstream
15 q,quiet! be quiet. implies --no-stat
16 autostash! automatically stash/stash pop before and after
17 onto=! rebase onto given branch instead of upstream
18 p,preserve-merges! try to recreate merges instead of ignoring them
19 s,strategy=! use the given merge strategy
20 no-ff! cherry-pick all commits, even if unchanged
21 m,merge! use merging strategies to rebase
22 i,interactive! let the user edit the list of commits to rebase
23 x,exec=! add exec lines after each commit of the editable list
24 k,keep-empty preserve empty commits during rebase
25 f,force-rebase! force rebase even if branch is up to date
26 X,strategy-option=! pass the argument through to the merge strategy
27 stat! display a diffstat of what changed upstream
28 n,no-stat! do not show diffstat of what changed upstream
29 verify allow pre-rebase hook to run
30 rerere-autoupdate allow rerere to update index with resolved conflicts
31 root! rebase all reachable commits up to the root(s)
32 autosquash move commits that begin with squash!/fixup! under -i
33 committer-date-is-author-date! passed to 'git am'
34 ignore-date! passed to 'git am'
35 whitespace=! passed to 'git apply'
36 ignore-whitespace! passed to 'git apply'
37 C=! passed to 'git apply'
38 Actions:
39 continue! continue
40 abort! abort and check out the original branch
41 skip! skip current patch and continue
42 edit-todo! edit the todo list during an interactive rebase
44 . git-sh-setup
45 . git-sh-i18n
46 set_reflog_action rebase
47 require_work_tree_exists
48 cd_to_toplevel
50 LF='
52 ok_to_skip_pre_rebase=
53 resolvemsg="
54 $(gettext 'When you have resolved this problem, run "git rebase --continue".
55 If you prefer to skip this patch, run "git rebase --skip" instead.
56 To check out the original branch and stop rebasing, run "git rebase --abort".')
58 unset onto
59 cmd=
60 strategy=
61 strategy_opts=
62 do_merge=
63 merge_dir="$GIT_DIR"/rebase-merge
64 apply_dir="$GIT_DIR"/rebase-apply
65 verbose=
66 diffstat=
67 test "$(git config --bool rebase.stat)" = true && diffstat=t
68 autostash="$(git config --bool rebase.autostash || echo false)"
69 git_am_opt=
70 rebase_root=
71 force_rebase=
72 allow_rerere_autoupdate=
73 # Non-empty if a rebase was in progress when 'git rebase' was invoked
74 in_progress=
75 # One of {am, merge, interactive}
76 type=
77 # One of {"$GIT_DIR"/rebase-apply, "$GIT_DIR"/rebase-merge}
78 state_dir=
79 # One of {'', continue, skip, abort}, as parsed from command line
80 action=
81 preserve_merges=
82 autosquash=
83 keep_empty=
84 test "$(git config --bool rebase.autosquash)" = "true" && autosquash=t
86 read_basic_state () {
87 test -f "$state_dir/head-name" &&
88 test -f "$state_dir/onto" &&
89 head_name=$(cat "$state_dir"/head-name) &&
90 onto=$(cat "$state_dir"/onto) &&
91 # We always write to orig-head, but interactive rebase used to write to
92 # head. Fall back to reading from head to cover for the case that the
93 # user upgraded git with an ongoing interactive rebase.
94 if test -f "$state_dir"/orig-head
95 then
96 orig_head=$(cat "$state_dir"/orig-head)
97 else
98 orig_head=$(cat "$state_dir"/head)
99 fi &&
100 GIT_QUIET=$(cat "$state_dir"/quiet) &&
101 test -f "$state_dir"/verbose && verbose=t
102 test -f "$state_dir"/strategy && strategy="$(cat "$state_dir"/strategy)"
103 test -f "$state_dir"/strategy_opts &&
104 strategy_opts="$(cat "$state_dir"/strategy_opts)"
105 test -f "$state_dir"/allow_rerere_autoupdate &&
106 allow_rerere_autoupdate="$(cat "$state_dir"/allow_rerere_autoupdate)"
109 write_basic_state () {
110 echo "$head_name" > "$state_dir"/head-name &&
111 echo "$onto" > "$state_dir"/onto &&
112 echo "$orig_head" > "$state_dir"/orig-head &&
113 echo "$GIT_QUIET" > "$state_dir"/quiet &&
114 test t = "$verbose" && : > "$state_dir"/verbose
115 test -n "$strategy" && echo "$strategy" > "$state_dir"/strategy
116 test -n "$strategy_opts" && echo "$strategy_opts" > \
117 "$state_dir"/strategy_opts
118 test -n "$allow_rerere_autoupdate" && echo "$allow_rerere_autoupdate" > \
119 "$state_dir"/allow_rerere_autoupdate
122 output () {
123 case "$verbose" in
125 output=$("$@" 2>&1 )
126 status=$?
127 test $status != 0 && printf "%s\n" "$output"
128 return $status
131 "$@"
133 esac
136 move_to_original_branch () {
137 case "$head_name" in
138 refs/*)
139 message="rebase finished: $head_name onto $onto"
140 git update-ref -m "$message" \
141 $head_name $(git rev-parse HEAD) $orig_head &&
142 git symbolic-ref \
143 -m "rebase finished: returning to $head_name" \
144 HEAD $head_name ||
145 die "$(gettext "Could not move back to $head_name")"
147 esac
150 finish_rebase () {
151 if test -f "$state_dir/autostash"
152 then
153 stash_sha1=$(cat "$state_dir/autostash")
154 if git stash apply $stash_sha1 2>&1 >/dev/null
155 then
156 echo "$(gettext 'Applied autostash.')"
157 else
158 git stash store -m "autostash" -q $stash_sha1 ||
159 die "$(eval_gettext "Cannot store \$stash_sha1")"
160 gettext 'Applying autostash resulted in conflicts.
161 Your changes are safe in the stash.
162 You can run "git stash pop" or "git stash drop" at any time.
166 git gc --auto &&
167 rm -rf "$state_dir"
170 run_specific_rebase_internal () {
171 if [ "$interactive_rebase" = implied ]; then
172 GIT_EDITOR=:
173 export GIT_EDITOR
174 autosquash=
176 # On FreeBSD, the shell's "return" returns from the current
177 # function, not from the current file inclusion.
178 # run_specific_rebase_internal has the file inclusion as a
179 # last statement, so POSIX and FreeBSD's return will do the
180 # same thing.
181 . git-rebase--$type
184 run_specific_rebase () {
185 run_specific_rebase_internal
186 ret=$?
187 if test $ret -eq 0
188 then
189 finish_rebase
191 exit $ret
194 run_pre_rebase_hook () {
195 if test -z "$ok_to_skip_pre_rebase" &&
196 test -x "$GIT_DIR/hooks/pre-rebase"
197 then
198 "$GIT_DIR/hooks/pre-rebase" ${1+"$@"} ||
199 die "$(gettext "The pre-rebase hook refused to rebase.")"
203 test -f "$apply_dir"/applying &&
204 die "$(gettext "It looks like git-am is in progress. Cannot rebase.")"
206 if test -d "$apply_dir"
207 then
208 type=am
209 state_dir="$apply_dir"
210 elif test -d "$merge_dir"
211 then
212 if test -f "$merge_dir"/interactive
213 then
214 type=interactive
215 interactive_rebase=explicit
216 else
217 type=merge
219 state_dir="$merge_dir"
221 test -n "$type" && in_progress=t
223 total_argc=$#
224 while test $# != 0
226 case "$1" in
227 --no-verify)
228 ok_to_skip_pre_rebase=yes
230 --verify)
231 ok_to_skip_pre_rebase=
233 --continue|--skip|--abort|--edit-todo)
234 test $total_argc -eq 2 || usage
235 action=${1##--}
237 --onto)
238 test 2 -le "$#" || usage
239 onto="$2"
240 shift
243 test 2 -le "$#" || usage
244 cmd="${cmd}exec $2${LF}"
245 shift
248 interactive_rebase=explicit
251 keep_empty=yes
254 preserve_merges=t
255 test -z "$interactive_rebase" && interactive_rebase=implied
257 --autosquash)
258 autosquash=t
260 --no-autosquash)
261 autosquash=
263 -M|-m)
264 do_merge=t
267 shift
268 strategy_opts="$strategy_opts $(git rev-parse --sq-quote "--$1")"
269 do_merge=t
270 test -z "$strategy" && strategy=recursive
273 shift
274 strategy="$1"
275 do_merge=t
278 diffstat=
280 --stat)
281 diffstat=t
283 --autostash)
284 autostash=true
287 verbose=t
288 diffstat=t
289 GIT_QUIET=
292 GIT_QUIET=t
293 git_am_opt="$git_am_opt -q"
294 verbose=
295 diffstat=
297 --whitespace)
298 shift
299 git_am_opt="$git_am_opt --whitespace=$1"
300 case "$1" in
301 fix|strip)
302 force_rebase=t
304 esac
306 --ignore-whitespace)
307 git_am_opt="$git_am_opt $1"
309 --committer-date-is-author-date|--ignore-date)
310 git_am_opt="$git_am_opt $1"
311 force_rebase=t
314 shift
315 git_am_opt="$git_am_opt -C$1"
317 --root)
318 rebase_root=t
320 -f|--no-ff)
321 force_rebase=t
323 --rerere-autoupdate|--no-rerere-autoupdate)
324 allow_rerere_autoupdate="$1"
327 shift
328 break
330 esac
331 shift
332 done
333 test $# -gt 2 && usage
335 if test -n "$cmd" &&
336 test "$interactive_rebase" != explicit
337 then
338 die "$(gettext "The --exec option must be used with the --interactive option")"
341 if test -n "$action"
342 then
343 test -z "$in_progress" && die "$(gettext "No rebase in progress?")"
344 # Only interactive rebase uses detailed reflog messages
345 if test "$type" = interactive && test "$GIT_REFLOG_ACTION" = rebase
346 then
347 GIT_REFLOG_ACTION="rebase -i ($action)"
348 export GIT_REFLOG_ACTION
352 if test "$action" = "edit-todo" && test "$type" != "interactive"
353 then
354 die "$(gettext "The --edit-todo action can only be used during interactive rebase.")"
357 case "$action" in
358 continue)
359 # Sanity check
360 git rev-parse --verify HEAD >/dev/null ||
361 die "$(gettext "Cannot read HEAD")"
362 git update-index --ignore-submodules --refresh &&
363 git diff-files --quiet --ignore-submodules || {
364 echo "$(gettext "You must edit all merge conflicts and then
365 mark them as resolved using git add")"
366 exit 1
368 read_basic_state
369 run_specific_rebase
371 skip)
372 output git reset --hard HEAD || exit $?
373 read_basic_state
374 run_specific_rebase
376 abort)
377 git rerere clear
378 read_basic_state
379 case "$head_name" in
380 refs/*)
381 git symbolic-ref -m "rebase: aborting" HEAD $head_name ||
382 die "$(eval_gettext "Could not move back to \$head_name")"
384 esac
385 output git reset --hard $orig_head
386 finish_rebase
387 exit
389 edit-todo)
390 run_specific_rebase
392 esac
394 # Make sure no rebase is in progress
395 if test -n "$in_progress"
396 then
397 state_dir_base=${state_dir##*/}
398 cmd_live_rebase="git rebase (--continue | --abort | --skip)"
399 cmd_clear_stale_rebase="rm -fr \"$state_dir\""
400 die "
401 $(eval_gettext 'It seems that there is already a $state_dir_base directory, and
402 I wonder if you are in the middle of another rebase. If that is the
403 case, please try
404 $cmd_live_rebase
405 If that is not the case, please
406 $cmd_clear_stale_rebase
407 and run me again. I am stopping in case you still have something
408 valuable there.')"
411 if test -n "$rebase_root" && test -z "$onto"
412 then
413 test -z "$interactive_rebase" && interactive_rebase=implied
416 if test -n "$interactive_rebase"
417 then
418 type=interactive
419 state_dir="$merge_dir"
420 elif test -n "$do_merge"
421 then
422 type=merge
423 state_dir="$merge_dir"
424 else
425 type=am
426 state_dir="$apply_dir"
429 if test -z "$rebase_root"
430 then
431 case "$#" in
433 if ! upstream_name=$(git rev-parse --symbolic-full-name \
434 --verify -q @{upstream} 2>/dev/null)
435 then
436 . git-parse-remote
437 error_on_missing_default_upstream "rebase" "rebase" \
438 "against" "git rebase <branch>"
441 *) upstream_name="$1"
442 shift
444 esac
445 upstream=$(peel_committish "${upstream_name}") ||
446 die "$(eval_gettext "invalid upstream \$upstream_name")"
447 upstream_arg="$upstream_name"
448 else
449 if test -z "$onto"
450 then
451 empty_tree=`git hash-object -t tree /dev/null`
452 onto=`git commit-tree $empty_tree </dev/null`
453 squash_onto="$onto"
455 unset upstream_name
456 unset upstream
457 test $# -gt 1 && usage
458 upstream_arg=--root
461 # Make sure the branch to rebase onto is valid.
462 onto_name=${onto-"$upstream_name"}
463 case "$onto_name" in
464 *...*)
465 if left=${onto_name%...*} right=${onto_name#*...} &&
466 onto=$(git merge-base --all ${left:-HEAD} ${right:-HEAD})
467 then
468 case "$onto" in
469 ?*"$LF"?*)
470 die "$(eval_gettext "\$onto_name: there are more than one merge bases")"
473 die "$(eval_gettext "\$onto_name: there is no merge base")"
475 esac
476 else
477 die "$(eval_gettext "\$onto_name: there is no merge base")"
481 onto=$(peel_committish "$onto_name") ||
482 die "$(eval_gettext "Does not point to a valid commit: \$onto_name")"
484 esac
486 # If the branch to rebase is given, that is the branch we will rebase
487 # $branch_name -- branch being rebased, or HEAD (already detached)
488 # $orig_head -- commit object name of tip of the branch before rebasing
489 # $head_name -- refs/heads/<that-branch> or "detached HEAD"
490 switch_to=
491 case "$#" in
493 # Is it "rebase other $branchname" or "rebase other $commit"?
494 branch_name="$1"
495 switch_to="$1"
497 if git show-ref --verify --quiet -- "refs/heads/$1" &&
498 orig_head=$(git rev-parse -q --verify "refs/heads/$1")
499 then
500 head_name="refs/heads/$1"
501 elif orig_head=$(git rev-parse -q --verify "$1")
502 then
503 head_name="detached HEAD"
504 else
505 die "$(eval_gettext "fatal: no such branch: \$branch_name")"
509 # Do not need to switch branches, we are already on it.
510 if branch_name=`git symbolic-ref -q HEAD`
511 then
512 head_name=$branch_name
513 branch_name=`expr "z$branch_name" : 'zrefs/heads/\(.*\)'`
514 else
515 head_name="detached HEAD"
516 branch_name=HEAD ;# detached
518 orig_head=$(git rev-parse --verify HEAD) || exit
521 die "BUG: unexpected number of arguments left to parse"
523 esac
525 if test "$autostash" = true && ! (require_clean_work_tree) 2>/dev/null
526 then
527 stash_sha1=$(git stash create "autostash") ||
528 die "$(gettext 'Cannot autostash')"
530 mkdir -p "$state_dir" &&
531 echo $stash_sha1 >"$state_dir/autostash" &&
532 stash_abbrev=$(git rev-parse --short $stash_sha1) &&
533 echo "$(eval_gettext 'Created autostash: $stash_abbrev')" &&
534 git reset --hard
537 require_clean_work_tree "rebase" "$(gettext "Please commit or stash them.")"
539 # Now we are rebasing commits $upstream..$orig_head (or with --root,
540 # everything leading up to $orig_head) on top of $onto
542 # Check if we are already based on $onto with linear history,
543 # but this should be done only when upstream and onto are the same
544 # and if this is not an interactive rebase.
545 mb=$(git merge-base "$onto" "$orig_head")
546 if test "$type" != interactive && test "$upstream" = "$onto" &&
547 test "$mb" = "$onto" &&
548 # linear history?
549 ! (git rev-list --parents "$onto".."$orig_head" | sane_grep " .* ") > /dev/null
550 then
551 if test -z "$force_rebase"
552 then
553 # Lazily switch to the target branch if needed...
554 test -z "$switch_to" ||
555 GIT_REFLOG_ACTION="$GIT_REFLOG_ACTION: checkout $switch_to" \
556 git checkout "$switch_to" --
557 say "$(eval_gettext "Current branch \$branch_name is up to date.")"
558 finish_rebase
559 exit 0
560 else
561 say "$(eval_gettext "Current branch \$branch_name is up to date, rebase forced.")"
565 # If a hook exists, give it a chance to interrupt
566 run_pre_rebase_hook "$upstream_arg" "$@"
568 if test -n "$diffstat"
569 then
570 if test -n "$verbose"
571 then
572 echo "$(eval_gettext "Changes from \$mb to \$onto:")"
574 # We want color (if set), but no pager
575 GIT_PAGER='' git diff --stat --summary "$mb" "$onto"
578 test "$type" = interactive && run_specific_rebase
580 # Detach HEAD and reset the tree
581 say "$(gettext "First, rewinding head to replay your work on top of it...")"
583 GIT_REFLOG_ACTION="$GIT_REFLOG_ACTION: checkout $onto_name" \
584 git checkout -q "$onto^0" || die "could not detach HEAD"
585 git update-ref ORIG_HEAD $orig_head
587 # If the $onto is a proper descendant of the tip of the branch, then
588 # we just fast-forwarded.
589 if test "$mb" = "$orig_head"
590 then
591 say "$(eval_gettext "Fast-forwarded \$branch_name to \$onto_name.")"
592 move_to_original_branch
593 finish_rebase
594 exit 0
597 if test -n "$rebase_root"
598 then
599 revisions="$onto..$orig_head"
600 else
601 revisions="$upstream..$orig_head"
604 run_specific_rebase