branch: add test for -m renaming multiple config sections
[git.git] / git-rebase.sh
blobdb1deed8464f0643763ed6e3c5e54221cad8c985
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 signoff 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
47 quit! abort but keep HEAD where it is
49 . git-sh-setup
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 keep_empty=
90 test "$(git config --bool rebase.autosquash)" = "true" && autosquash=t
91 case "$(git config --bool commit.gpgsign)" in
92 true) gpg_sign_opt=-S ;;
93 *) gpg_sign_opt= ;;
94 esac
96 read_basic_state () {
97 test -f "$state_dir/head-name" &&
98 test -f "$state_dir/onto" &&
99 head_name=$(cat "$state_dir"/head-name) &&
100 onto=$(cat "$state_dir"/onto) &&
101 # We always write to orig-head, but interactive rebase used to write to
102 # head. Fall back to reading from head to cover for the case that the
103 # user upgraded git with an ongoing interactive rebase.
104 if test -f "$state_dir"/orig-head
105 then
106 orig_head=$(cat "$state_dir"/orig-head)
107 else
108 orig_head=$(cat "$state_dir"/head)
109 fi &&
110 GIT_QUIET=$(cat "$state_dir"/quiet) &&
111 test -f "$state_dir"/verbose && verbose=t
112 test -f "$state_dir"/strategy && strategy="$(cat "$state_dir"/strategy)"
113 test -f "$state_dir"/strategy_opts &&
114 strategy_opts="$(cat "$state_dir"/strategy_opts)"
115 test -f "$state_dir"/allow_rerere_autoupdate &&
116 allow_rerere_autoupdate="$(cat "$state_dir"/allow_rerere_autoupdate)"
117 test -f "$state_dir"/gpg_sign_opt &&
118 gpg_sign_opt="$(cat "$state_dir"/gpg_sign_opt)"
121 write_basic_state () {
122 echo "$head_name" > "$state_dir"/head-name &&
123 echo "$onto" > "$state_dir"/onto &&
124 echo "$orig_head" > "$state_dir"/orig-head &&
125 echo "$GIT_QUIET" > "$state_dir"/quiet &&
126 test t = "$verbose" && : > "$state_dir"/verbose
127 test -n "$strategy" && echo "$strategy" > "$state_dir"/strategy
128 test -n "$strategy_opts" && echo "$strategy_opts" > \
129 "$state_dir"/strategy_opts
130 test -n "$allow_rerere_autoupdate" && echo "$allow_rerere_autoupdate" > \
131 "$state_dir"/allow_rerere_autoupdate
132 test -n "$gpg_sign_opt" && echo "$gpg_sign_opt" > "$state_dir"/gpg_sign_opt
135 output () {
136 case "$verbose" in
138 output=$("$@" 2>&1 )
139 status=$?
140 test $status != 0 && printf "%s\n" "$output"
141 return $status
144 "$@"
146 esac
149 move_to_original_branch () {
150 case "$head_name" in
151 refs/*)
152 message="rebase finished: $head_name onto $onto"
153 git update-ref -m "$message" \
154 $head_name $(git rev-parse HEAD) $orig_head &&
155 git symbolic-ref \
156 -m "rebase finished: returning to $head_name" \
157 HEAD $head_name ||
158 die "$(eval_gettext "Could not move back to \$head_name")"
160 esac
163 apply_autostash () {
164 if test -f "$state_dir/autostash"
165 then
166 stash_sha1=$(cat "$state_dir/autostash")
167 if git stash apply $stash_sha1 2>&1 >/dev/null
168 then
169 echo "$(gettext 'Applied autostash.')"
170 else
171 git stash store -m "autostash" -q $stash_sha1 ||
172 die "$(eval_gettext "Cannot store \$stash_sha1")"
173 gettext 'Applying autostash resulted in conflicts.
174 Your changes are safe in the stash.
175 You can run "git stash pop" or "git stash drop" at any time.
181 finish_rebase () {
182 apply_autostash &&
183 { git gc --auto || true; } &&
184 rm -rf "$state_dir"
187 run_specific_rebase () {
188 if [ "$interactive_rebase" = implied ]; then
189 GIT_EDITOR=:
190 export GIT_EDITOR
191 autosquash=
193 . git-rebase--$type
194 ret=$?
195 if test $ret -eq 0
196 then
197 finish_rebase
198 elif test $ret -eq 2 # special exit status for rebase -i
199 then
200 apply_autostash &&
201 rm -rf "$state_dir" &&
202 die "Nothing to do"
204 exit $ret
207 run_pre_rebase_hook () {
208 if test -z "$ok_to_skip_pre_rebase" &&
209 test -x "$(git rev-parse --git-path hooks/pre-rebase)"
210 then
211 "$(git rev-parse --git-path hooks/pre-rebase)" ${1+"$@"} ||
212 die "$(gettext "The pre-rebase hook refused to rebase.")"
216 test -f "$apply_dir"/applying &&
217 die "$(gettext "It looks like git-am is in progress. Cannot rebase.")"
219 if test -d "$apply_dir"
220 then
221 type=am
222 state_dir="$apply_dir"
223 elif test -d "$merge_dir"
224 then
225 if test -f "$merge_dir"/interactive
226 then
227 type=interactive
228 interactive_rebase=explicit
229 else
230 type=merge
232 state_dir="$merge_dir"
234 test -n "$type" && in_progress=t
236 total_argc=$#
237 while test $# != 0
239 case "$1" in
240 --no-verify)
241 ok_to_skip_pre_rebase=yes
243 --verify)
244 ok_to_skip_pre_rebase=
246 --continue|--skip|--abort|--quit|--edit-todo)
247 test $total_argc -eq 2 || usage
248 action=${1##--}
250 --onto=*)
251 onto="${1#--onto=}"
253 --exec=*)
254 cmd="${cmd}exec ${1#--exec=}${LF}"
255 test -z "$interactive_rebase" && interactive_rebase=implied
257 --interactive)
258 interactive_rebase=explicit
260 --keep-empty)
261 keep_empty=yes
263 --preserve-merges)
264 preserve_merges=t
265 test -z "$interactive_rebase" && interactive_rebase=implied
267 --autosquash)
268 autosquash=t
270 --no-autosquash)
271 autosquash=
273 --fork-point)
274 fork_point=t
276 --no-fork-point)
277 fork_point=
279 --merge)
280 do_merge=t
282 --strategy-option=*)
283 strategy_opts="$strategy_opts $(git rev-parse --sq-quote "--${1#--strategy-option=}")"
284 do_merge=t
285 test -z "$strategy" && strategy=recursive
287 --strategy=*)
288 strategy="${1#--strategy=}"
289 do_merge=t
291 --no-stat)
292 diffstat=
294 --stat)
295 diffstat=t
297 --autostash)
298 autostash=true
300 --no-autostash)
301 autostash=false
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|--signoff|--no-signoff)
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 "$action"
357 then
358 test -z "$in_progress" && die "$(gettext "No rebase in progress?")"
359 # Only interactive rebase uses detailed reflog messages
360 if test "$type" = interactive && test "$GIT_REFLOG_ACTION" = rebase
361 then
362 GIT_REFLOG_ACTION="rebase -i ($action)"
363 export GIT_REFLOG_ACTION
367 if test "$action" = "edit-todo" && test "$type" != "interactive"
368 then
369 die "$(gettext "The --edit-todo action can only be used during interactive rebase.")"
372 case "$action" in
373 continue)
374 # Sanity check
375 git rev-parse --verify HEAD >/dev/null ||
376 die "$(gettext "Cannot read HEAD")"
377 git update-index --ignore-submodules --refresh &&
378 git diff-files --quiet --ignore-submodules || {
379 echo "$(gettext "You must edit all merge conflicts and then
380 mark them as resolved using git add")"
381 exit 1
383 read_basic_state
384 run_specific_rebase
386 skip)
387 output git reset --hard HEAD || exit $?
388 read_basic_state
389 run_specific_rebase
391 abort)
392 git rerere clear
393 read_basic_state
394 case "$head_name" in
395 refs/*)
396 git symbolic-ref -m "rebase: aborting" HEAD $head_name ||
397 die "$(eval_gettext "Could not move back to \$head_name")"
399 esac
400 output git reset --hard $orig_head
401 finish_rebase
402 exit
404 quit)
405 exec rm -rf "$state_dir"
407 edit-todo)
408 run_specific_rebase
410 esac
412 # Make sure no rebase is in progress
413 if test -n "$in_progress"
414 then
415 state_dir_base=${state_dir##*/}
416 cmd_live_rebase="git rebase (--continue | --abort | --skip)"
417 cmd_clear_stale_rebase="rm -fr \"$state_dir\""
418 die "
419 $(eval_gettext 'It seems that there is already a $state_dir_base directory, and
420 I wonder if you are in the middle of another rebase. If that is the
421 case, please try
422 $cmd_live_rebase
423 If that is not the case, please
424 $cmd_clear_stale_rebase
425 and run me again. I am stopping in case you still have something
426 valuable there.')"
429 if test -n "$rebase_root" && test -z "$onto"
430 then
431 test -z "$interactive_rebase" && interactive_rebase=implied
434 if test -n "$interactive_rebase"
435 then
436 type=interactive
437 state_dir="$merge_dir"
438 elif test -n "$do_merge"
439 then
440 type=merge
441 state_dir="$merge_dir"
442 else
443 type=am
444 state_dir="$apply_dir"
447 if test -z "$rebase_root"
448 then
449 case "$#" in
451 if ! upstream_name=$(git rev-parse --symbolic-full-name \
452 --verify -q @{upstream} 2>/dev/null)
453 then
454 . git-parse-remote
455 error_on_missing_default_upstream "rebase" "rebase" \
456 "against" "git rebase $(gettext '<branch>')"
459 test "$fork_point" = auto && fork_point=t
461 *) upstream_name="$1"
462 if test "$upstream_name" = "-"
463 then
464 upstream_name="@{-1}"
466 shift
468 esac
469 upstream=$(peel_committish "${upstream_name}") ||
470 die "$(eval_gettext "invalid upstream \$upstream_name")"
471 upstream_arg="$upstream_name"
472 else
473 if test -z "$onto"
474 then
475 empty_tree=$(git hash-object -t tree /dev/null)
476 onto=$(git commit-tree $empty_tree </dev/null)
477 squash_onto="$onto"
479 unset upstream_name
480 unset upstream
481 test $# -gt 1 && usage
482 upstream_arg=--root
485 # Make sure the branch to rebase onto is valid.
486 onto_name=${onto-"$upstream_name"}
487 case "$onto_name" in
488 *...*)
489 if left=${onto_name%...*} right=${onto_name#*...} &&
490 onto=$(git merge-base --all ${left:-HEAD} ${right:-HEAD})
491 then
492 case "$onto" in
493 ?*"$LF"?*)
494 die "$(eval_gettext "\$onto_name: there are more than one merge bases")"
497 die "$(eval_gettext "\$onto_name: there is no merge base")"
499 esac
500 else
501 die "$(eval_gettext "\$onto_name: there is no merge base")"
505 onto=$(peel_committish "$onto_name") ||
506 die "$(eval_gettext "Does not point to a valid commit: \$onto_name")"
508 esac
510 # If the branch to rebase is given, that is the branch we will rebase
511 # $branch_name -- branch being rebased, or HEAD (already detached)
512 # $orig_head -- commit object name of tip of the branch before rebasing
513 # $head_name -- refs/heads/<that-branch> or "detached HEAD"
514 switch_to=
515 case "$#" in
517 # Is it "rebase other $branchname" or "rebase other $commit"?
518 branch_name="$1"
519 switch_to="$1"
521 if git show-ref --verify --quiet -- "refs/heads/$1" &&
522 orig_head=$(git rev-parse -q --verify "refs/heads/$1")
523 then
524 head_name="refs/heads/$1"
525 elif orig_head=$(git rev-parse -q --verify "$1")
526 then
527 head_name="detached HEAD"
528 else
529 die "$(eval_gettext "fatal: no such branch: \$branch_name")"
533 # Do not need to switch branches, we are already on it.
534 if branch_name=$(git symbolic-ref -q HEAD)
535 then
536 head_name=$branch_name
537 branch_name=$(expr "z$branch_name" : 'zrefs/heads/\(.*\)')
538 else
539 head_name="detached HEAD"
540 branch_name=HEAD ;# detached
542 orig_head=$(git rev-parse --verify HEAD) || exit
545 die "BUG: unexpected number of arguments left to parse"
547 esac
549 if test "$fork_point" = t
550 then
551 new_upstream=$(git merge-base --fork-point "$upstream_name" \
552 "${switch_to:-HEAD}")
553 if test -n "$new_upstream"
554 then
555 restrict_revision=$new_upstream
559 if test "$autostash" = true && ! (require_clean_work_tree) 2>/dev/null
560 then
561 stash_sha1=$(git stash create "autostash") ||
562 die "$(gettext 'Cannot autostash')"
564 mkdir -p "$state_dir" &&
565 echo $stash_sha1 >"$state_dir/autostash" &&
566 stash_abbrev=$(git rev-parse --short $stash_sha1) &&
567 echo "$(eval_gettext 'Created autostash: $stash_abbrev')" &&
568 git reset --hard
571 require_clean_work_tree "rebase" "$(gettext "Please commit or stash them.")"
573 # Now we are rebasing commits $upstream..$orig_head (or with --root,
574 # everything leading up to $orig_head) on top of $onto
576 # Check if we are already based on $onto with linear history,
577 # but this should be done only when upstream and onto are the same
578 # and if this is not an interactive rebase.
579 mb=$(git merge-base "$onto" "$orig_head")
580 if test "$type" != interactive && test "$upstream" = "$onto" &&
581 test "$mb" = "$onto" && test -z "$restrict_revision" &&
582 # linear history?
583 ! (git rev-list --parents "$onto".."$orig_head" | sane_grep " .* ") > /dev/null
584 then
585 if test -z "$force_rebase"
586 then
587 # Lazily switch to the target branch if needed...
588 test -z "$switch_to" ||
589 GIT_REFLOG_ACTION="$GIT_REFLOG_ACTION: checkout $switch_to" \
590 git checkout -q "$switch_to" --
591 say "$(eval_gettext "Current branch \$branch_name is up to date.")"
592 finish_rebase
593 exit 0
594 else
595 say "$(eval_gettext "Current branch \$branch_name is up to date, rebase forced.")"
599 # If a hook exists, give it a chance to interrupt
600 run_pre_rebase_hook "$upstream_arg" "$@"
602 if test -n "$diffstat"
603 then
604 if test -n "$verbose"
605 then
606 echo "$(eval_gettext "Changes from \$mb to \$onto:")"
608 # We want color (if set), but no pager
609 GIT_PAGER='' git diff --stat --summary "$mb" "$onto"
612 test "$type" = interactive && run_specific_rebase
614 # Detach HEAD and reset the tree
615 say "$(gettext "First, rewinding head to replay your work on top of it...")"
617 GIT_REFLOG_ACTION="$GIT_REFLOG_ACTION: checkout $onto_name" \
618 git checkout -q "$onto^0" || die "could not detach HEAD"
619 git update-ref ORIG_HEAD $orig_head
621 # If the $onto is a proper descendant of the tip of the branch, then
622 # we just fast-forwarded.
623 if test "$mb" = "$orig_head"
624 then
625 say "$(eval_gettext "Fast-forwarded \$branch_name to \$onto_name.")"
626 move_to_original_branch
627 finish_rebase
628 exit 0
631 if test -n "$rebase_root"
632 then
633 revisions="$onto..$orig_head"
634 else
635 revisions="${restrict_revision-$upstream}..$orig_head"
638 run_specific_rebase