t3600: rename test to describe its functionality
[git/raj.git] / git-rebase.sh
blob48d7c5ded40e1801a36a897849e0f32b314e5981
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
46 quit! abort but keep HEAD where it is
48 . git-sh-setup
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 case "$(git config --bool commit.gpgsign)" in
91 true) gpg_sign_opt=-S ;;
92 *) gpg_sign_opt= ;;
93 esac
95 read_basic_state () {
96 test -f "$state_dir/head-name" &&
97 test -f "$state_dir/onto" &&
98 head_name=$(cat "$state_dir"/head-name) &&
99 onto=$(cat "$state_dir"/onto) &&
100 # We always write to orig-head, but interactive rebase used to write to
101 # head. Fall back to reading from head to cover for the case that the
102 # user upgraded git with an ongoing interactive rebase.
103 if test -f "$state_dir"/orig-head
104 then
105 orig_head=$(cat "$state_dir"/orig-head)
106 else
107 orig_head=$(cat "$state_dir"/head)
108 fi &&
109 GIT_QUIET=$(cat "$state_dir"/quiet) &&
110 test -f "$state_dir"/verbose && verbose=t
111 test -f "$state_dir"/strategy && strategy="$(cat "$state_dir"/strategy)"
112 test -f "$state_dir"/strategy_opts &&
113 strategy_opts="$(cat "$state_dir"/strategy_opts)"
114 test -f "$state_dir"/allow_rerere_autoupdate &&
115 allow_rerere_autoupdate="$(cat "$state_dir"/allow_rerere_autoupdate)"
116 test -f "$state_dir"/gpg_sign_opt &&
117 gpg_sign_opt="$(cat "$state_dir"/gpg_sign_opt)"
120 write_basic_state () {
121 echo "$head_name" > "$state_dir"/head-name &&
122 echo "$onto" > "$state_dir"/onto &&
123 echo "$orig_head" > "$state_dir"/orig-head &&
124 echo "$GIT_QUIET" > "$state_dir"/quiet &&
125 test t = "$verbose" && : > "$state_dir"/verbose
126 test -n "$strategy" && echo "$strategy" > "$state_dir"/strategy
127 test -n "$strategy_opts" && echo "$strategy_opts" > \
128 "$state_dir"/strategy_opts
129 test -n "$allow_rerere_autoupdate" && echo "$allow_rerere_autoupdate" > \
130 "$state_dir"/allow_rerere_autoupdate
131 test -n "$gpg_sign_opt" && echo "$gpg_sign_opt" > "$state_dir"/gpg_sign_opt
134 output () {
135 case "$verbose" in
137 output=$("$@" 2>&1 )
138 status=$?
139 test $status != 0 && printf "%s\n" "$output"
140 return $status
143 "$@"
145 esac
148 move_to_original_branch () {
149 case "$head_name" in
150 refs/*)
151 message="rebase finished: $head_name onto $onto"
152 git update-ref -m "$message" \
153 $head_name $(git rev-parse HEAD) $orig_head &&
154 git symbolic-ref \
155 -m "rebase finished: returning to $head_name" \
156 HEAD $head_name ||
157 die "$(eval_gettext "Could not move back to \$head_name")"
159 esac
162 apply_autostash () {
163 if test -f "$state_dir/autostash"
164 then
165 stash_sha1=$(cat "$state_dir/autostash")
166 if git stash apply $stash_sha1 2>&1 >/dev/null
167 then
168 echo "$(gettext 'Applied autostash.')"
169 else
170 git stash store -m "autostash" -q $stash_sha1 ||
171 die "$(eval_gettext "Cannot store \$stash_sha1")"
172 gettext 'Applying autostash resulted in conflicts.
173 Your changes are safe in the stash.
174 You can run "git stash pop" or "git stash drop" at any time.
180 finish_rebase () {
181 apply_autostash &&
182 { git gc --auto || true; } &&
183 rm -rf "$state_dir"
186 run_specific_rebase () {
187 if [ "$interactive_rebase" = implied ]; then
188 GIT_EDITOR=:
189 export GIT_EDITOR
190 autosquash=
192 . git-rebase--$type
193 ret=$?
194 if test $ret -eq 0
195 then
196 finish_rebase
197 elif test $ret -eq 2 # special exit status for rebase -i
198 then
199 apply_autostash &&
200 rm -rf "$state_dir" &&
201 die "Nothing to do"
203 exit $ret
206 run_pre_rebase_hook () {
207 if test -z "$ok_to_skip_pre_rebase" &&
208 test -x "$(git rev-parse --git-path hooks/pre-rebase)"
209 then
210 "$(git rev-parse --git-path hooks/pre-rebase)" ${1+"$@"} ||
211 die "$(gettext "The pre-rebase hook refused to rebase.")"
215 test -f "$apply_dir"/applying &&
216 die "$(gettext "It looks like git-am is in progress. Cannot rebase.")"
218 if test -d "$apply_dir"
219 then
220 type=am
221 state_dir="$apply_dir"
222 elif test -d "$merge_dir"
223 then
224 if test -f "$merge_dir"/interactive
225 then
226 type=interactive
227 interactive_rebase=explicit
228 else
229 type=merge
231 state_dir="$merge_dir"
233 test -n "$type" && in_progress=t
235 total_argc=$#
236 while test $# != 0
238 case "$1" in
239 --no-verify)
240 ok_to_skip_pre_rebase=yes
242 --verify)
243 ok_to_skip_pre_rebase=
245 --continue|--skip|--abort|--quit|--edit-todo)
246 test $total_argc -eq 2 || usage
247 action=${1##--}
249 --onto=*)
250 onto="${1#--onto=}"
252 --exec=*)
253 cmd="${cmd}exec ${1#--exec=}${LF}"
254 test -z "$interactive_rebase" && interactive_rebase=implied
256 --interactive)
257 interactive_rebase=explicit
259 --keep-empty)
260 keep_empty=yes
262 --preserve-merges)
263 preserve_merges=t
264 test -z "$interactive_rebase" && interactive_rebase=implied
266 --autosquash)
267 autosquash=t
269 --no-autosquash)
270 autosquash=
272 --fork-point)
273 fork_point=t
275 --no-fork-point)
276 fork_point=
278 --merge)
279 do_merge=t
281 --strategy-option=*)
282 strategy_opts="$strategy_opts $(git rev-parse --sq-quote "--${1#--strategy-option=}")"
283 do_merge=t
284 test -z "$strategy" && strategy=recursive
286 --strategy=*)
287 strategy="${1#--strategy=}"
288 do_merge=t
290 --no-stat)
291 diffstat=
293 --stat)
294 diffstat=t
296 --autostash)
297 autostash=true
299 --no-autostash)
300 autostash=false
302 --verbose)
303 verbose=t
304 diffstat=t
305 GIT_QUIET=
307 --quiet)
308 GIT_QUIET=t
309 git_am_opt="$git_am_opt -q"
310 verbose=
311 diffstat=
313 --whitespace=*)
314 git_am_opt="$git_am_opt --whitespace=${1#--whitespace=}"
315 case "${1#--whitespace=}" in
316 fix|strip)
317 force_rebase=t
319 esac
321 --ignore-whitespace)
322 git_am_opt="$git_am_opt $1"
324 --committer-date-is-author-date|--ignore-date)
325 git_am_opt="$git_am_opt $1"
326 force_rebase=t
328 -C*)
329 git_am_opt="$git_am_opt $1"
331 --root)
332 rebase_root=t
334 --force-rebase|--no-ff)
335 force_rebase=t
337 --rerere-autoupdate|--no-rerere-autoupdate)
338 allow_rerere_autoupdate="$1"
340 --gpg-sign)
341 gpg_sign_opt=-S
343 --gpg-sign=*)
344 gpg_sign_opt="-S${1#--gpg-sign=}"
347 shift
348 break
350 esac
351 shift
352 done
353 test $# -gt 2 && usage
355 if test -n "$action"
356 then
357 test -z "$in_progress" && die "$(gettext "No rebase in progress?")"
358 # Only interactive rebase uses detailed reflog messages
359 if test "$type" = interactive && test "$GIT_REFLOG_ACTION" = rebase
360 then
361 GIT_REFLOG_ACTION="rebase -i ($action)"
362 export GIT_REFLOG_ACTION
366 if test "$action" = "edit-todo" && test "$type" != "interactive"
367 then
368 die "$(gettext "The --edit-todo action can only be used during interactive rebase.")"
371 case "$action" in
372 continue)
373 # Sanity check
374 git rev-parse --verify HEAD >/dev/null ||
375 die "$(gettext "Cannot read HEAD")"
376 git update-index --ignore-submodules --refresh &&
377 git diff-files --quiet --ignore-submodules || {
378 echo "$(gettext "You must edit all merge conflicts and then
379 mark them as resolved using git add")"
380 exit 1
382 read_basic_state
383 run_specific_rebase
385 skip)
386 output git reset --hard HEAD || exit $?
387 read_basic_state
388 run_specific_rebase
390 abort)
391 git rerere clear
392 read_basic_state
393 case "$head_name" in
394 refs/*)
395 git symbolic-ref -m "rebase: aborting" HEAD $head_name ||
396 die "$(eval_gettext "Could not move back to \$head_name")"
398 esac
399 output git reset --hard $orig_head
400 finish_rebase
401 exit
403 quit)
404 exec rm -rf "$state_dir"
406 edit-todo)
407 run_specific_rebase
409 esac
411 # Make sure no rebase is in progress
412 if test -n "$in_progress"
413 then
414 state_dir_base=${state_dir##*/}
415 cmd_live_rebase="git rebase (--continue | --abort | --skip)"
416 cmd_clear_stale_rebase="rm -fr \"$state_dir\""
417 die "
418 $(eval_gettext 'It seems that there is already a $state_dir_base directory, and
419 I wonder if you are in the middle of another rebase. If that is the
420 case, please try
421 $cmd_live_rebase
422 If that is not the case, please
423 $cmd_clear_stale_rebase
424 and run me again. I am stopping in case you still have something
425 valuable there.')"
428 if test -n "$rebase_root" && test -z "$onto"
429 then
430 test -z "$interactive_rebase" && interactive_rebase=implied
433 if test -n "$interactive_rebase"
434 then
435 type=interactive
436 state_dir="$merge_dir"
437 elif test -n "$do_merge"
438 then
439 type=merge
440 state_dir="$merge_dir"
441 else
442 type=am
443 state_dir="$apply_dir"
446 if test -z "$rebase_root"
447 then
448 case "$#" in
450 if ! upstream_name=$(git rev-parse --symbolic-full-name \
451 --verify -q @{upstream} 2>/dev/null)
452 then
453 . git-parse-remote
454 error_on_missing_default_upstream "rebase" "rebase" \
455 "against" "git rebase $(gettext '<branch>')"
458 test "$fork_point" = auto && fork_point=t
460 *) upstream_name="$1"
461 if test "$upstream_name" = "-"
462 then
463 upstream_name="@{-1}"
465 shift
467 esac
468 upstream=$(peel_committish "${upstream_name}") ||
469 die "$(eval_gettext "invalid upstream \$upstream_name")"
470 upstream_arg="$upstream_name"
471 else
472 if test -z "$onto"
473 then
474 empty_tree=$(git hash-object -t tree /dev/null)
475 onto=$(git commit-tree $empty_tree </dev/null)
476 squash_onto="$onto"
478 unset upstream_name
479 unset upstream
480 test $# -gt 1 && usage
481 upstream_arg=--root
484 # Make sure the branch to rebase onto is valid.
485 onto_name=${onto-"$upstream_name"}
486 case "$onto_name" in
487 *...*)
488 if left=${onto_name%...*} right=${onto_name#*...} &&
489 onto=$(git merge-base --all ${left:-HEAD} ${right:-HEAD})
490 then
491 case "$onto" in
492 ?*"$LF"?*)
493 die "$(eval_gettext "\$onto_name: there are more than one merge bases")"
496 die "$(eval_gettext "\$onto_name: there is no merge base")"
498 esac
499 else
500 die "$(eval_gettext "\$onto_name: there is no merge base")"
504 onto=$(peel_committish "$onto_name") ||
505 die "$(eval_gettext "Does not point to a valid commit: \$onto_name")"
507 esac
509 # If the branch to rebase is given, that is the branch we will rebase
510 # $branch_name -- branch being rebased, or HEAD (already detached)
511 # $orig_head -- commit object name of tip of the branch before rebasing
512 # $head_name -- refs/heads/<that-branch> or "detached HEAD"
513 switch_to=
514 case "$#" in
516 # Is it "rebase other $branchname" or "rebase other $commit"?
517 branch_name="$1"
518 switch_to="$1"
520 if git show-ref --verify --quiet -- "refs/heads/$1" &&
521 orig_head=$(git rev-parse -q --verify "refs/heads/$1")
522 then
523 head_name="refs/heads/$1"
524 elif orig_head=$(git rev-parse -q --verify "$1")
525 then
526 head_name="detached HEAD"
527 else
528 die "$(eval_gettext "fatal: no such branch: \$branch_name")"
532 # Do not need to switch branches, we are already on it.
533 if branch_name=$(git symbolic-ref -q HEAD)
534 then
535 head_name=$branch_name
536 branch_name=$(expr "z$branch_name" : 'zrefs/heads/\(.*\)')
537 else
538 head_name="detached HEAD"
539 branch_name=HEAD ;# detached
541 orig_head=$(git rev-parse --verify HEAD) || exit
544 die "BUG: unexpected number of arguments left to parse"
546 esac
548 if test "$fork_point" = t
549 then
550 new_upstream=$(git merge-base --fork-point "$upstream_name" \
551 "${switch_to:-HEAD}")
552 if test -n "$new_upstream"
553 then
554 restrict_revision=$new_upstream
558 if test "$autostash" = true && ! (require_clean_work_tree) 2>/dev/null
559 then
560 stash_sha1=$(git stash create "autostash") ||
561 die "$(gettext 'Cannot autostash')"
563 mkdir -p "$state_dir" &&
564 echo $stash_sha1 >"$state_dir/autostash" &&
565 stash_abbrev=$(git rev-parse --short $stash_sha1) &&
566 echo "$(eval_gettext 'Created autostash: $stash_abbrev')" &&
567 git reset --hard
570 require_clean_work_tree "rebase" "$(gettext "Please commit or stash them.")"
572 # Now we are rebasing commits $upstream..$orig_head (or with --root,
573 # everything leading up to $orig_head) on top of $onto
575 # Check if we are already based on $onto with linear history,
576 # but this should be done only when upstream and onto are the same
577 # and if this is not an interactive rebase.
578 mb=$(git merge-base "$onto" "$orig_head")
579 if test "$type" != interactive && test "$upstream" = "$onto" &&
580 test "$mb" = "$onto" && test -z "$restrict_revision" &&
581 # linear history?
582 ! (git rev-list --parents "$onto".."$orig_head" | sane_grep " .* ") > /dev/null
583 then
584 if test -z "$force_rebase"
585 then
586 # Lazily switch to the target branch if needed...
587 test -z "$switch_to" ||
588 GIT_REFLOG_ACTION="$GIT_REFLOG_ACTION: checkout $switch_to" \
589 git checkout -q "$switch_to" --
590 say "$(eval_gettext "Current branch \$branch_name is up to date.")"
591 finish_rebase
592 exit 0
593 else
594 say "$(eval_gettext "Current branch \$branch_name is up to date, rebase forced.")"
598 # If a hook exists, give it a chance to interrupt
599 run_pre_rebase_hook "$upstream_arg" "$@"
601 if test -n "$diffstat"
602 then
603 if test -n "$verbose"
604 then
605 echo "$(eval_gettext "Changes from \$mb to \$onto:")"
607 # We want color (if set), but no pager
608 GIT_PAGER='' git diff --stat --summary "$mb" "$onto"
611 test "$type" = interactive && run_specific_rebase
613 # Detach HEAD and reset the tree
614 say "$(gettext "First, rewinding head to replay your work on top of it...")"
616 GIT_REFLOG_ACTION="$GIT_REFLOG_ACTION: checkout $onto_name" \
617 git checkout -q "$onto^0" || die "could not detach HEAD"
618 git update-ref ORIG_HEAD $orig_head
620 # If the $onto is a proper descendant of the tip of the branch, then
621 # we just fast-forwarded.
622 if test "$mb" = "$orig_head"
623 then
624 say "$(eval_gettext "Fast-forwarded \$branch_name to \$onto_name.")"
625 move_to_original_branch
626 finish_rebase
627 exit 0
630 if test -n "$rebase_root"
631 then
632 revisions="$onto..$orig_head"
633 else
634 revisions="${restrict_revision-$upstream}..$orig_head"
637 run_specific_rebase