.gitignore: "git-verify-commit" is a generated file
[git.git] / git-rebase.sh
blob06c810b64fe04d3675820e38d7eeabe7589dab56
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 cmd=
63 strategy=
64 strategy_opts=
65 do_merge=
66 merge_dir="$GIT_DIR"/rebase-merge
67 apply_dir="$GIT_DIR"/rebase-apply
68 verbose=
69 diffstat=
70 test "$(git config --bool rebase.stat)" = true && diffstat=t
71 autostash="$(git config --bool rebase.autostash || echo false)"
72 fork_point=auto
73 git_am_opt=
74 rebase_root=
75 force_rebase=
76 allow_rerere_autoupdate=
77 # Non-empty if a rebase was in progress when 'git rebase' was invoked
78 in_progress=
79 # One of {am, merge, interactive}
80 type=
81 # One of {"$GIT_DIR"/rebase-apply, "$GIT_DIR"/rebase-merge}
82 state_dir=
83 # One of {'', continue, skip, abort}, as parsed from command line
84 action=
85 preserve_merges=
86 autosquash=
87 keep_empty=
88 test "$(git config --bool rebase.autosquash)" = "true" && autosquash=t
89 gpg_sign_opt=
91 read_basic_state () {
92 test -f "$state_dir/head-name" &&
93 test -f "$state_dir/onto" &&
94 head_name=$(cat "$state_dir"/head-name) &&
95 onto=$(cat "$state_dir"/onto) &&
96 # We always write to orig-head, but interactive rebase used to write to
97 # head. Fall back to reading from head to cover for the case that the
98 # user upgraded git with an ongoing interactive rebase.
99 if test -f "$state_dir"/orig-head
100 then
101 orig_head=$(cat "$state_dir"/orig-head)
102 else
103 orig_head=$(cat "$state_dir"/head)
104 fi &&
105 GIT_QUIET=$(cat "$state_dir"/quiet) &&
106 test -f "$state_dir"/verbose && verbose=t
107 test -f "$state_dir"/strategy && strategy="$(cat "$state_dir"/strategy)"
108 test -f "$state_dir"/strategy_opts &&
109 strategy_opts="$(cat "$state_dir"/strategy_opts)"
110 test -f "$state_dir"/allow_rerere_autoupdate &&
111 allow_rerere_autoupdate="$(cat "$state_dir"/allow_rerere_autoupdate)"
112 test -f "$state_dir"/gpg_sign_opt &&
113 gpg_sign_opt="$(cat "$state_dir"/gpg_sign_opt)"
116 write_basic_state () {
117 echo "$head_name" > "$state_dir"/head-name &&
118 echo "$onto" > "$state_dir"/onto &&
119 echo "$orig_head" > "$state_dir"/orig-head &&
120 echo "$GIT_QUIET" > "$state_dir"/quiet &&
121 test t = "$verbose" && : > "$state_dir"/verbose
122 test -n "$strategy" && echo "$strategy" > "$state_dir"/strategy
123 test -n "$strategy_opts" && echo "$strategy_opts" > \
124 "$state_dir"/strategy_opts
125 test -n "$allow_rerere_autoupdate" && echo "$allow_rerere_autoupdate" > \
126 "$state_dir"/allow_rerere_autoupdate
127 test -n "$gpg_sign_opt" && echo "$gpg_sign_opt" > "$state_dir"/gpg_sign_opt
130 output () {
131 case "$verbose" in
133 output=$("$@" 2>&1 )
134 status=$?
135 test $status != 0 && printf "%s\n" "$output"
136 return $status
139 "$@"
141 esac
144 move_to_original_branch () {
145 case "$head_name" in
146 refs/*)
147 message="rebase finished: $head_name onto $onto"
148 git update-ref -m "$message" \
149 $head_name $(git rev-parse HEAD) $orig_head &&
150 git symbolic-ref \
151 -m "rebase finished: returning to $head_name" \
152 HEAD $head_name ||
153 die "$(gettext "Could not move back to $head_name")"
155 esac
158 apply_autostash () {
159 if test -f "$state_dir/autostash"
160 then
161 stash_sha1=$(cat "$state_dir/autostash")
162 if git stash apply $stash_sha1 2>&1 >/dev/null
163 then
164 echo "$(gettext 'Applied autostash.')"
165 else
166 git stash store -m "autostash" -q $stash_sha1 ||
167 die "$(eval_gettext "Cannot store \$stash_sha1")"
168 gettext 'Applying autostash resulted in conflicts.
169 Your changes are safe in the stash.
170 You can run "git stash pop" or "git stash drop" at any time.
176 finish_rebase () {
177 apply_autostash &&
178 git gc --auto &&
179 rm -rf "$state_dir"
182 run_specific_rebase () {
183 if [ "$interactive_rebase" = implied ]; then
184 GIT_EDITOR=:
185 export GIT_EDITOR
186 autosquash=
188 . git-rebase--$type
189 ret=$?
190 if test $ret -eq 0
191 then
192 finish_rebase
193 elif test $ret -eq 2 # special exit status for rebase -i
194 then
195 apply_autostash &&
196 rm -rf "$state_dir" &&
197 die "Nothing to do"
199 exit $ret
202 run_pre_rebase_hook () {
203 if test -z "$ok_to_skip_pre_rebase" &&
204 test -x "$GIT_DIR/hooks/pre-rebase"
205 then
206 "$GIT_DIR/hooks/pre-rebase" ${1+"$@"} ||
207 die "$(gettext "The pre-rebase hook refused to rebase.")"
211 test -f "$apply_dir"/applying &&
212 die "$(gettext "It looks like git-am is in progress. Cannot rebase.")"
214 if test -d "$apply_dir"
215 then
216 type=am
217 state_dir="$apply_dir"
218 elif test -d "$merge_dir"
219 then
220 if test -f "$merge_dir"/interactive
221 then
222 type=interactive
223 interactive_rebase=explicit
224 else
225 type=merge
227 state_dir="$merge_dir"
229 test -n "$type" && in_progress=t
231 total_argc=$#
232 while test $# != 0
234 case "$1" in
235 --no-verify)
236 ok_to_skip_pre_rebase=yes
238 --verify)
239 ok_to_skip_pre_rebase=
241 --continue|--skip|--abort|--edit-todo)
242 test $total_argc -eq 2 || usage
243 action=${1##--}
245 --onto=*)
246 onto="${1#--onto=}"
248 --exec=*)
249 cmd="${cmd}exec ${1#--exec=}${LF}"
251 --interactive)
252 interactive_rebase=explicit
254 --keep-empty)
255 keep_empty=yes
257 --preserve-merges)
258 preserve_merges=t
259 test -z "$interactive_rebase" && interactive_rebase=implied
261 --autosquash)
262 autosquash=t
264 --no-autosquash)
265 autosquash=
267 --fork-point)
268 fork_point=t
270 --no-fork-point)
271 fork_point=
273 --merge)
274 do_merge=t
276 --strategy-option=*)
277 strategy_opts="$strategy_opts $(git rev-parse --sq-quote "--${1#--strategy-option=}")"
278 do_merge=t
279 test -z "$strategy" && strategy=recursive
281 --strategy=*)
282 strategy="${1#--strategy=}"
283 do_merge=t
285 --no-stat)
286 diffstat=
288 --stat)
289 diffstat=t
291 --autostash)
292 autostash=true
294 --verbose)
295 verbose=t
296 diffstat=t
297 GIT_QUIET=
299 --quiet)
300 GIT_QUIET=t
301 git_am_opt="$git_am_opt -q"
302 verbose=
303 diffstat=
305 --whitespace=*)
306 git_am_opt="$git_am_opt --whitespace=${1#--whitespace=}"
307 case "${1#--whitespace=}" in
308 fix|strip)
309 force_rebase=t
311 esac
313 --ignore-whitespace)
314 git_am_opt="$git_am_opt $1"
316 --committer-date-is-author-date|--ignore-date)
317 git_am_opt="$git_am_opt $1"
318 force_rebase=t
320 -C*)
321 git_am_opt="$git_am_opt $1"
323 --root)
324 rebase_root=t
326 --force-rebase|--no-ff)
327 force_rebase=t
329 --rerere-autoupdate|--no-rerere-autoupdate)
330 allow_rerere_autoupdate="$1"
332 --gpg-sign)
333 gpg_sign_opt=-S
335 --gpg-sign=*)
336 gpg_sign_opt="-S${1#--gpg-sign=}"
339 shift
340 break
342 esac
343 shift
344 done
345 test $# -gt 2 && usage
347 if test -n "$cmd" &&
348 test "$interactive_rebase" != explicit
349 then
350 die "$(gettext "The --exec option must be used with the --interactive option")"
353 if test -n "$action"
354 then
355 test -z "$in_progress" && die "$(gettext "No rebase in progress?")"
356 # Only interactive rebase uses detailed reflog messages
357 if test "$type" = interactive && test "$GIT_REFLOG_ACTION" = rebase
358 then
359 GIT_REFLOG_ACTION="rebase -i ($action)"
360 export GIT_REFLOG_ACTION
364 if test "$action" = "edit-todo" && test "$type" != "interactive"
365 then
366 die "$(gettext "The --edit-todo action can only be used during interactive rebase.")"
369 case "$action" in
370 continue)
371 # Sanity check
372 git rev-parse --verify HEAD >/dev/null ||
373 die "$(gettext "Cannot read HEAD")"
374 git update-index --ignore-submodules --refresh &&
375 git diff-files --quiet --ignore-submodules || {
376 echo "$(gettext "You must edit all merge conflicts and then
377 mark them as resolved using git add")"
378 exit 1
380 read_basic_state
381 run_specific_rebase
383 skip)
384 output git reset --hard HEAD || exit $?
385 read_basic_state
386 run_specific_rebase
388 abort)
389 git rerere clear
390 read_basic_state
391 case "$head_name" in
392 refs/*)
393 git symbolic-ref -m "rebase: aborting" HEAD $head_name ||
394 die "$(eval_gettext "Could not move back to \$head_name")"
396 esac
397 output git reset --hard $orig_head
398 finish_rebase
399 exit
401 edit-todo)
402 run_specific_rebase
404 esac
406 # Make sure no rebase is in progress
407 if test -n "$in_progress"
408 then
409 state_dir_base=${state_dir##*/}
410 cmd_live_rebase="git rebase (--continue | --abort | --skip)"
411 cmd_clear_stale_rebase="rm -fr \"$state_dir\""
412 die "
413 $(eval_gettext 'It seems that there is already a $state_dir_base directory, and
414 I wonder if you are in the middle of another rebase. If that is the
415 case, please try
416 $cmd_live_rebase
417 If that is not the case, please
418 $cmd_clear_stale_rebase
419 and run me again. I am stopping in case you still have something
420 valuable there.')"
423 if test -n "$rebase_root" && test -z "$onto"
424 then
425 test -z "$interactive_rebase" && interactive_rebase=implied
428 if test -n "$interactive_rebase"
429 then
430 type=interactive
431 state_dir="$merge_dir"
432 elif test -n "$do_merge"
433 then
434 type=merge
435 state_dir="$merge_dir"
436 else
437 type=am
438 state_dir="$apply_dir"
441 if test -z "$rebase_root"
442 then
443 case "$#" in
445 if ! upstream_name=$(git rev-parse --symbolic-full-name \
446 --verify -q @{upstream} 2>/dev/null)
447 then
448 . git-parse-remote
449 error_on_missing_default_upstream "rebase" "rebase" \
450 "against" "git rebase <branch>"
453 test "$fork_point" = auto && fork_point=t
455 *) upstream_name="$1"
456 if test "$upstream_name" = "-"
457 then
458 upstream_name="@{-1}"
460 shift
462 esac
463 upstream=$(peel_committish "${upstream_name}") ||
464 die "$(eval_gettext "invalid upstream \$upstream_name")"
465 upstream_arg="$upstream_name"
466 else
467 if test -z "$onto"
468 then
469 empty_tree=$(git hash-object -t tree /dev/null)
470 onto=$(git commit-tree $empty_tree </dev/null)
471 squash_onto="$onto"
473 unset upstream_name
474 unset upstream
475 test $# -gt 1 && usage
476 upstream_arg=--root
479 # Make sure the branch to rebase onto is valid.
480 onto_name=${onto-"$upstream_name"}
481 case "$onto_name" in
482 *...*)
483 if left=${onto_name%...*} right=${onto_name#*...} &&
484 onto=$(git merge-base --all ${left:-HEAD} ${right:-HEAD})
485 then
486 case "$onto" in
487 ?*"$LF"?*)
488 die "$(eval_gettext "\$onto_name: there are more than one merge bases")"
491 die "$(eval_gettext "\$onto_name: there is no merge base")"
493 esac
494 else
495 die "$(eval_gettext "\$onto_name: there is no merge base")"
499 onto=$(peel_committish "$onto_name") ||
500 die "$(eval_gettext "Does not point to a valid commit: \$onto_name")"
502 esac
504 # If the branch to rebase is given, that is the branch we will rebase
505 # $branch_name -- branch being rebased, or HEAD (already detached)
506 # $orig_head -- commit object name of tip of the branch before rebasing
507 # $head_name -- refs/heads/<that-branch> or "detached HEAD"
508 switch_to=
509 case "$#" in
511 # Is it "rebase other $branchname" or "rebase other $commit"?
512 branch_name="$1"
513 switch_to="$1"
515 if git show-ref --verify --quiet -- "refs/heads/$1" &&
516 orig_head=$(git rev-parse -q --verify "refs/heads/$1")
517 then
518 head_name="refs/heads/$1"
519 elif orig_head=$(git rev-parse -q --verify "$1")
520 then
521 head_name="detached HEAD"
522 else
523 die "$(eval_gettext "fatal: no such branch: \$branch_name")"
527 # Do not need to switch branches, we are already on it.
528 if branch_name=$(git symbolic-ref -q HEAD)
529 then
530 head_name=$branch_name
531 branch_name=$(expr "z$branch_name" : 'zrefs/heads/\(.*\)')
532 else
533 head_name="detached HEAD"
534 branch_name=HEAD ;# detached
536 orig_head=$(git rev-parse --verify HEAD) || exit
539 die "BUG: unexpected number of arguments left to parse"
541 esac
543 if test "$fork_point" = t
544 then
545 new_upstream=$(git merge-base --fork-point "$upstream_name" \
546 "${switch_to:-HEAD}")
547 if test -n "$new_upstream"
548 then
549 upstream=$new_upstream
553 if test "$autostash" = true && ! (require_clean_work_tree) 2>/dev/null
554 then
555 stash_sha1=$(git stash create "autostash") ||
556 die "$(gettext 'Cannot autostash')"
558 mkdir -p "$state_dir" &&
559 echo $stash_sha1 >"$state_dir/autostash" &&
560 stash_abbrev=$(git rev-parse --short $stash_sha1) &&
561 echo "$(eval_gettext 'Created autostash: $stash_abbrev')" &&
562 git reset --hard
565 require_clean_work_tree "rebase" "$(gettext "Please commit or stash them.")"
567 # Now we are rebasing commits $upstream..$orig_head (or with --root,
568 # everything leading up to $orig_head) on top of $onto
570 # Check if we are already based on $onto with linear history,
571 # but this should be done only when upstream and onto are the same
572 # and if this is not an interactive rebase.
573 mb=$(git merge-base "$onto" "$orig_head")
574 if test "$type" != interactive && test "$upstream" = "$onto" &&
575 test "$mb" = "$onto" &&
576 # linear history?
577 ! (git rev-list --parents "$onto".."$orig_head" | sane_grep " .* ") > /dev/null
578 then
579 if test -z "$force_rebase"
580 then
581 # Lazily switch to the target branch if needed...
582 test -z "$switch_to" ||
583 GIT_REFLOG_ACTION="$GIT_REFLOG_ACTION: checkout $switch_to" \
584 git checkout "$switch_to" --
585 say "$(eval_gettext "Current branch \$branch_name is up to date.")"
586 finish_rebase
587 exit 0
588 else
589 say "$(eval_gettext "Current branch \$branch_name is up to date, rebase forced.")"
593 # If a hook exists, give it a chance to interrupt
594 run_pre_rebase_hook "$upstream_arg" "$@"
596 if test -n "$diffstat"
597 then
598 if test -n "$verbose"
599 then
600 echo "$(eval_gettext "Changes from \$mb to \$onto:")"
602 # We want color (if set), but no pager
603 GIT_PAGER='' git diff --stat --summary "$mb" "$onto"
606 test "$type" = interactive && run_specific_rebase
608 # Detach HEAD and reset the tree
609 say "$(gettext "First, rewinding head to replay your work on top of it...")"
611 GIT_REFLOG_ACTION="$GIT_REFLOG_ACTION: checkout $onto_name" \
612 git checkout -q "$onto^0" || die "could not detach HEAD"
613 git update-ref ORIG_HEAD $orig_head
615 # If the $onto is a proper descendant of the tip of the branch, then
616 # we just fast-forwarded.
617 if test "$mb" = "$orig_head"
618 then
619 say "$(eval_gettext "Fast-forwarded \$branch_name to \$onto_name.")"
620 move_to_original_branch
621 finish_rebase
622 exit 0
625 if test -n "$rebase_root"
626 then
627 revisions="$onto..$orig_head"
628 else
629 revisions="$upstream..$orig_head"
632 run_specific_rebase