Skip tests that fail due to incomplete implementations, missing tools...
[git/mingw/j6t.git] / git-rebase.sh
blob0c1eaea07681a437b209f8a5afaa4b713b7578b2
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 first-parent reply merges by picking the first-parent change
36 committer-date-is-author-date! passed to 'git am'
37 ignore-date! passed to 'git am'
38 whitespace=! passed to 'git apply'
39 ignore-whitespace! passed to 'git apply'
40 C=! passed to 'git apply'
41 S,gpg-sign? GPG-sign commits
42 Actions:
43 continue! continue
44 abort! abort and check out the original branch
45 skip! skip current patch and continue
46 edit-todo! edit the todo list during an interactive rebase
48 . git-sh-setup
49 . git-sh-i18n
50 set_reflog_action rebase
51 require_work_tree_exists
52 cd_to_toplevel
54 LF='
56 ok_to_skip_pre_rebase=
57 resolvemsg="
58 $(gettext 'When you have resolved this problem, run "git rebase --continue".
59 If you prefer to skip this patch, run "git rebase --skip" instead.
60 To check out the original branch and stop rebasing, run "git rebase --abort".')
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 rebase_root=
77 force_rebase=
78 allow_rerere_autoupdate=
79 # Non-empty if a rebase was in progress when 'git rebase' was invoked
80 in_progress=
81 # One of {am, merge, interactive}
82 type=
83 # One of {"$GIT_DIR"/rebase-apply, "$GIT_DIR"/rebase-merge}
84 state_dir=
85 # One of {'', continue, skip, abort}, as parsed from command line
86 action=
87 preserve_merges=
88 autosquash=
89 first_parent_only=
90 keep_empty=
91 test "$(git config --bool rebase.autosquash)" = "true" && autosquash=t
92 gpg_sign_opt=
94 read_basic_state () {
95 test -f "$state_dir/head-name" &&
96 test -f "$state_dir/onto" &&
97 head_name=$(cat "$state_dir"/head-name) &&
98 onto=$(cat "$state_dir"/onto) &&
99 # We always write to orig-head, but interactive rebase used to write to
100 # head. Fall back to reading from head to cover for the case that the
101 # user upgraded git with an ongoing interactive rebase.
102 if test -f "$state_dir"/orig-head
103 then
104 orig_head=$(cat "$state_dir"/orig-head)
105 else
106 orig_head=$(cat "$state_dir"/head)
107 fi &&
108 GIT_QUIET=$(cat "$state_dir"/quiet) &&
109 test -f "$state_dir"/verbose && verbose=t
110 test -f "$state_dir"/strategy && strategy="$(cat "$state_dir"/strategy)"
111 test -f "$state_dir"/strategy_opts &&
112 strategy_opts="$(cat "$state_dir"/strategy_opts)"
113 test -f "$state_dir"/allow_rerere_autoupdate &&
114 allow_rerere_autoupdate="$(cat "$state_dir"/allow_rerere_autoupdate)"
115 test -f "$state_dir"/gpg_sign_opt &&
116 gpg_sign_opt="$(cat "$state_dir"/gpg_sign_opt)"
119 write_basic_state () {
120 echo "$head_name" > "$state_dir"/head-name &&
121 echo "$onto" > "$state_dir"/onto &&
122 echo "$orig_head" > "$state_dir"/orig-head &&
123 echo "$GIT_QUIET" > "$state_dir"/quiet &&
124 test t = "$verbose" && : > "$state_dir"/verbose
125 test -n "$strategy" && echo "$strategy" > "$state_dir"/strategy
126 test -n "$strategy_opts" && echo "$strategy_opts" > \
127 "$state_dir"/strategy_opts
128 test -n "$allow_rerere_autoupdate" && echo "$allow_rerere_autoupdate" > \
129 "$state_dir"/allow_rerere_autoupdate
130 test -n "$gpg_sign_opt" && echo "$gpg_sign_opt" > "$state_dir"/gpg_sign_opt
133 output () {
134 case "$verbose" in
136 output=$("$@" 2>&1 )
137 status=$?
138 test $status != 0 && printf "%s\n" "$output"
139 return $status
142 "$@"
144 esac
147 move_to_original_branch () {
148 case "$head_name" in
149 refs/*)
150 message="rebase finished: $head_name onto $onto"
151 git update-ref -m "$message" \
152 $head_name $(git rev-parse HEAD) $orig_head &&
153 git symbolic-ref \
154 -m "rebase finished: returning to $head_name" \
155 HEAD $head_name ||
156 die "$(gettext "Could not move back to $head_name")"
158 esac
161 apply_autostash () {
162 if test -f "$state_dir/autostash"
163 then
164 stash_sha1=$(cat "$state_dir/autostash")
165 if git stash apply $stash_sha1 2>&1 >/dev/null
166 then
167 echo "$(gettext 'Applied autostash.')"
168 else
169 git stash store -m "autostash" -q $stash_sha1 ||
170 die "$(eval_gettext "Cannot store \$stash_sha1")"
171 gettext 'Applying autostash resulted in conflicts.
172 Your changes are safe in the stash.
173 You can run "git stash pop" or "git stash drop" at any time.
179 finish_rebase () {
180 apply_autostash &&
181 git gc --auto &&
182 rm -rf "$state_dir"
185 run_specific_rebase () {
186 if [ "$interactive_rebase" = implied ]; then
187 GIT_EDITOR=:
188 export GIT_EDITOR
189 autosquash=
191 . git-rebase--$type
192 ret=$?
193 if test $ret -eq 0
194 then
195 finish_rebase
196 elif test $ret -eq 2 # special exit status for rebase -i
197 then
198 apply_autostash &&
199 rm -rf "$state_dir" &&
200 die "Nothing to do"
202 exit $ret
205 run_pre_rebase_hook () {
206 if test -z "$ok_to_skip_pre_rebase" &&
207 test -x "$(git rev-parse --git-path hooks/pre-rebase)"
208 then
209 "$(git rev-parse --git-path hooks/pre-rebase)" ${1+"$@"} ||
210 die "$(gettext "The pre-rebase hook refused to rebase.")"
214 test -f "$apply_dir"/applying &&
215 die "$(gettext "It looks like git-am is in progress. Cannot rebase.")"
217 if test -d "$apply_dir"
218 then
219 type=am
220 state_dir="$apply_dir"
221 elif test -d "$merge_dir"
222 then
223 if test -f "$merge_dir"/interactive
224 then
225 type=interactive
226 interactive_rebase=explicit
227 else
228 type=merge
230 state_dir="$merge_dir"
232 test -n "$type" && in_progress=t
234 total_argc=$#
235 while test $# != 0
237 case "$1" in
238 --no-verify)
239 ok_to_skip_pre_rebase=yes
241 --verify)
242 ok_to_skip_pre_rebase=
244 --continue|--skip|--abort|--edit-todo)
245 test $total_argc -eq 2 || usage
246 action=${1##--}
248 --onto=*)
249 onto="${1#--onto=}"
251 --exec=*)
252 cmd="${cmd}exec ${1#--exec=}${LF}"
254 --interactive)
255 interactive_rebase=explicit
257 --keep-empty)
258 keep_empty=yes
260 --preserve-merges)
261 preserve_merges=t
262 test -z "$interactive_rebase" && interactive_rebase=implied
264 --autosquash)
265 autosquash=t
267 --no-autosquash)
268 autosquash=
270 --fork-point)
271 fork_point=t
273 --no-fork-point)
274 fork_point=
276 --merge)
277 do_merge=t
279 --strategy-option=*)
280 strategy_opts="$strategy_opts $(git rev-parse --sq-quote "--${1#--strategy-option=}")"
281 do_merge=t
282 test -z "$strategy" && strategy=recursive
284 --strategy=*)
285 strategy="${1#--strategy=}"
286 do_merge=t
288 --no-stat)
289 diffstat=
291 --stat)
292 diffstat=t
294 --autostash)
295 autostash=true
297 --no-autostash)
298 autostash=false
300 --first-parent)
301 first_parent_only=t
303 --verbose)
304 verbose=t
305 diffstat=t
306 GIT_QUIET=
308 --quiet)
309 GIT_QUIET=t
310 git_am_opt="$git_am_opt -q"
311 verbose=
312 diffstat=
314 --whitespace=*)
315 git_am_opt="$git_am_opt --whitespace=${1#--whitespace=}"
316 case "${1#--whitespace=}" in
317 fix|strip)
318 force_rebase=t
320 esac
322 --ignore-whitespace)
323 git_am_opt="$git_am_opt $1"
325 --committer-date-is-author-date|--ignore-date)
326 git_am_opt="$git_am_opt $1"
327 force_rebase=t
329 -C*)
330 git_am_opt="$git_am_opt $1"
332 --root)
333 rebase_root=t
335 --force-rebase|--no-ff)
336 force_rebase=t
338 --rerere-autoupdate|--no-rerere-autoupdate)
339 allow_rerere_autoupdate="$1"
341 --gpg-sign)
342 gpg_sign_opt=-S
344 --gpg-sign=*)
345 gpg_sign_opt="-S${1#--gpg-sign=}"
348 shift
349 break
351 esac
352 shift
353 done
354 test $# -gt 2 && usage
356 if test -n "$cmd" &&
357 test "$interactive_rebase" != explicit
358 then
359 die "$(gettext "The --exec option must be used with the --interactive option")"
362 if test -n "$action"
363 then
364 test -z "$in_progress" && die "$(gettext "No rebase in progress?")"
365 # Only interactive rebase uses detailed reflog messages
366 if test "$type" = interactive && test "$GIT_REFLOG_ACTION" = rebase
367 then
368 GIT_REFLOG_ACTION="rebase -i ($action)"
369 export GIT_REFLOG_ACTION
373 if test "$action" = "edit-todo" && test "$type" != "interactive"
374 then
375 die "$(gettext "The --edit-todo action can only be used during interactive rebase.")"
378 if test -n "$first_parent_only" && test -z "$preserve_merges"
379 then
380 die "$(gettext "Option --first-parent can only be used with -p.")"
383 case "$action" in
384 continue)
385 # Sanity check
386 git rev-parse --verify HEAD >/dev/null ||
387 die "$(gettext "Cannot read HEAD")"
388 git update-index --ignore-submodules --refresh &&
389 git diff-files --quiet --ignore-submodules || {
390 echo "$(gettext "You must edit all merge conflicts and then
391 mark them as resolved using git add")"
392 exit 1
394 read_basic_state
395 run_specific_rebase
397 skip)
398 output git reset --hard HEAD || exit $?
399 read_basic_state
400 run_specific_rebase
402 abort)
403 git rerere clear
404 read_basic_state
405 case "$head_name" in
406 refs/*)
407 git symbolic-ref -m "rebase: aborting" HEAD $head_name ||
408 die "$(eval_gettext "Could not move back to \$head_name")"
410 esac
411 output git reset --hard $orig_head
412 finish_rebase
413 exit
415 edit-todo)
416 run_specific_rebase
418 esac
420 # Make sure no rebase is in progress
421 if test -n "$in_progress"
422 then
423 state_dir_base=${state_dir##*/}
424 cmd_live_rebase="git rebase (--continue | --abort | --skip)"
425 cmd_clear_stale_rebase="rm -fr \"$state_dir\""
426 die "
427 $(eval_gettext 'It seems that there is already a $state_dir_base directory, and
428 I wonder if you are in the middle of another rebase. If that is the
429 case, please try
430 $cmd_live_rebase
431 If that is not the case, please
432 $cmd_clear_stale_rebase
433 and run me again. I am stopping in case you still have something
434 valuable there.')"
437 if test -n "$rebase_root" && test -z "$onto"
438 then
439 test -z "$interactive_rebase" && interactive_rebase=implied
442 if test -n "$interactive_rebase"
443 then
444 type=interactive
445 state_dir="$merge_dir"
446 elif test -n "$do_merge"
447 then
448 type=merge
449 state_dir="$merge_dir"
450 else
451 type=am
452 state_dir="$apply_dir"
455 if test -z "$rebase_root"
456 then
457 case "$#" in
459 if ! upstream_name=$(git rev-parse --symbolic-full-name \
460 --verify -q @{upstream} 2>/dev/null)
461 then
462 . git-parse-remote
463 error_on_missing_default_upstream "rebase" "rebase" \
464 "against" "git rebase <branch>"
467 test "$fork_point" = auto && fork_point=t
469 *) upstream_name="$1"
470 if test "$upstream_name" = "-"
471 then
472 upstream_name="@{-1}"
474 shift
476 esac
477 upstream=$(peel_committish "${upstream_name}") ||
478 die "$(eval_gettext "invalid upstream \$upstream_name")"
479 upstream_arg="$upstream_name"
480 else
481 if test -z "$onto"
482 then
483 empty_tree=$(git hash-object -t tree /dev/null)
484 onto=$(git commit-tree $empty_tree </dev/null)
485 squash_onto="$onto"
487 unset upstream_name
488 unset upstream
489 test $# -gt 1 && usage
490 upstream_arg=--root
493 # Make sure the branch to rebase onto is valid.
494 onto_name=${onto-"$upstream_name"}
495 case "$onto_name" in
496 *...*)
497 if left=${onto_name%...*} right=${onto_name#*...} &&
498 onto=$(git merge-base --all ${left:-HEAD} ${right:-HEAD})
499 then
500 case "$onto" in
501 ?*"$LF"?*)
502 die "$(eval_gettext "\$onto_name: there are more than one merge bases")"
505 die "$(eval_gettext "\$onto_name: there is no merge base")"
507 esac
508 else
509 die "$(eval_gettext "\$onto_name: there is no merge base")"
513 onto=$(peel_committish "$onto_name") ||
514 die "$(eval_gettext "Does not point to a valid commit: \$onto_name")"
516 esac
518 # If the branch to rebase is given, that is the branch we will rebase
519 # $branch_name -- branch being rebased, or HEAD (already detached)
520 # $orig_head -- commit object name of tip of the branch before rebasing
521 # $head_name -- refs/heads/<that-branch> or "detached HEAD"
522 switch_to=
523 case "$#" in
525 # Is it "rebase other $branchname" or "rebase other $commit"?
526 branch_name="$1"
527 switch_to="$1"
529 if git show-ref --verify --quiet -- "refs/heads/$1" &&
530 orig_head=$(git rev-parse -q --verify "refs/heads/$1")
531 then
532 head_name="refs/heads/$1"
533 elif orig_head=$(git rev-parse -q --verify "$1")
534 then
535 head_name="detached HEAD"
536 else
537 die "$(eval_gettext "fatal: no such branch: \$branch_name")"
541 # Do not need to switch branches, we are already on it.
542 if branch_name=$(git symbolic-ref -q HEAD)
543 then
544 head_name=$branch_name
545 branch_name=$(expr "z$branch_name" : 'zrefs/heads/\(.*\)')
546 else
547 head_name="detached HEAD"
548 branch_name=HEAD ;# detached
550 orig_head=$(git rev-parse --verify HEAD) || exit
553 die "BUG: unexpected number of arguments left to parse"
555 esac
557 if test "$fork_point" = t
558 then
559 new_upstream=$(git merge-base --fork-point "$upstream_name" \
560 "${switch_to:-HEAD}")
561 if test -n "$new_upstream"
562 then
563 restrict_revision=$new_upstream
567 if test "$autostash" = true && ! (require_clean_work_tree) 2>/dev/null
568 then
569 stash_sha1=$(git stash create "autostash") ||
570 die "$(gettext 'Cannot autostash')"
572 mkdir -p "$state_dir" &&
573 echo $stash_sha1 >"$state_dir/autostash" &&
574 stash_abbrev=$(git rev-parse --short $stash_sha1) &&
575 echo "$(eval_gettext 'Created autostash: $stash_abbrev')" &&
576 git reset --hard
579 require_clean_work_tree "rebase" "$(gettext "Please commit or stash them.")"
581 # Now we are rebasing commits $upstream..$orig_head (or with --root,
582 # everything leading up to $orig_head) on top of $onto
584 # Check if we are already based on $onto with linear history,
585 # but this should be done only when upstream and onto are the same
586 # and if this is not an interactive rebase.
587 mb=$(git merge-base "$onto" "$orig_head")
588 if test "$type" != interactive && test "$upstream" = "$onto" &&
589 test "$mb" = "$onto" && test -z "$restrict_revision" &&
590 # linear history?
591 ! (git rev-list --parents "$onto".."$orig_head" | sane_grep " .* ") > /dev/null
592 then
593 if test -z "$force_rebase"
594 then
595 # Lazily switch to the target branch if needed...
596 test -z "$switch_to" ||
597 GIT_REFLOG_ACTION="$GIT_REFLOG_ACTION: checkout $switch_to" \
598 git checkout -q "$switch_to" --
599 say "$(eval_gettext "Current branch \$branch_name is up to date.")"
600 finish_rebase
601 exit 0
602 else
603 say "$(eval_gettext "Current branch \$branch_name is up to date, rebase forced.")"
607 # If a hook exists, give it a chance to interrupt
608 run_pre_rebase_hook "$upstream_arg" "$@"
610 if test -n "$diffstat"
611 then
612 if test -n "$verbose"
613 then
614 echo "$(eval_gettext "Changes from \$mb to \$onto:")"
616 # We want color (if set), but no pager
617 GIT_PAGER='' git diff --stat --summary "$mb" "$onto"
620 test "$type" = interactive && run_specific_rebase
622 # Detach HEAD and reset the tree
623 say "$(gettext "First, rewinding head to replay your work on top of it...")"
625 GIT_REFLOG_ACTION="$GIT_REFLOG_ACTION: checkout $onto_name" \
626 git checkout -q "$onto^0" || die "could not detach HEAD"
627 git update-ref ORIG_HEAD $orig_head
629 # If the $onto is a proper descendant of the tip of the branch, then
630 # we just fast-forwarded.
631 if test "$mb" = "$orig_head"
632 then
633 say "$(eval_gettext "Fast-forwarded \$branch_name to \$onto_name.")"
634 move_to_original_branch
635 finish_rebase
636 exit 0
639 if test -n "$rebase_root"
640 then
641 revisions="$onto..$orig_head"
642 else
643 revisions="${restrict_revision-$upstream}..$orig_head"
646 run_specific_rebase