Merge branch 'as/pretty-truncate' into maint
[git.git] / git-rebase.sh
blob4543815ffd6b0d49466edc3059f6d085b79ebf8a
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 finish_rebase () {
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.
174 git gc --auto &&
175 rm -rf "$state_dir"
178 run_specific_rebase () {
179 if [ "$interactive_rebase" = implied ]; then
180 GIT_EDITOR=:
181 export GIT_EDITOR
182 autosquash=
184 . git-rebase--$type
185 ret=$?
186 if test $ret -eq 0
187 then
188 finish_rebase
190 exit $ret
193 run_pre_rebase_hook () {
194 if test -z "$ok_to_skip_pre_rebase" &&
195 test -x "$GIT_DIR/hooks/pre-rebase"
196 then
197 "$GIT_DIR/hooks/pre-rebase" ${1+"$@"} ||
198 die "$(gettext "The pre-rebase hook refused to rebase.")"
202 test -f "$apply_dir"/applying &&
203 die "$(gettext "It looks like git-am is in progress. Cannot rebase.")"
205 if test -d "$apply_dir"
206 then
207 type=am
208 state_dir="$apply_dir"
209 elif test -d "$merge_dir"
210 then
211 if test -f "$merge_dir"/interactive
212 then
213 type=interactive
214 interactive_rebase=explicit
215 else
216 type=merge
218 state_dir="$merge_dir"
220 test -n "$type" && in_progress=t
222 total_argc=$#
223 while test $# != 0
225 case "$1" in
226 --no-verify)
227 ok_to_skip_pre_rebase=yes
229 --verify)
230 ok_to_skip_pre_rebase=
232 --continue|--skip|--abort|--edit-todo)
233 test $total_argc -eq 2 || usage
234 action=${1##--}
236 --onto=*)
237 onto="${1#--onto=}"
239 --exec=*)
240 cmd="${cmd}exec ${1#--exec=}${LF}"
242 --interactive)
243 interactive_rebase=explicit
245 --keep-empty)
246 keep_empty=yes
248 --preserve-merges)
249 preserve_merges=t
250 test -z "$interactive_rebase" && interactive_rebase=implied
252 --autosquash)
253 autosquash=t
255 --no-autosquash)
256 autosquash=
258 --fork-point)
259 fork_point=t
261 --no-fork-point)
262 fork_point=
264 --merge)
265 do_merge=t
267 --strategy-option=*)
268 strategy_opts="$strategy_opts $(git rev-parse --sq-quote "--${1#--strategy-option=}")"
269 do_merge=t
270 test -z "$strategy" && strategy=recursive
272 --strategy=*)
273 strategy="${1#--strategy=}"
274 do_merge=t
276 --no-stat)
277 diffstat=
279 --stat)
280 diffstat=t
282 --autostash)
283 autostash=true
285 --verbose)
286 verbose=t
287 diffstat=t
288 GIT_QUIET=
290 --quiet)
291 GIT_QUIET=t
292 git_am_opt="$git_am_opt -q"
293 verbose=
294 diffstat=
296 --whitespace=*)
297 git_am_opt="$git_am_opt --whitespace=${1#--whitespace=}"
298 case "${1#--whitespace=}" in
299 fix|strip)
300 force_rebase=t
302 esac
304 --ignore-whitespace)
305 git_am_opt="$git_am_opt $1"
307 --committer-date-is-author-date|--ignore-date)
308 git_am_opt="$git_am_opt $1"
309 force_rebase=t
311 -C*)
312 git_am_opt="$git_am_opt $1"
314 --root)
315 rebase_root=t
317 --force-rebase|--no-ff)
318 force_rebase=t
320 --rerere-autoupdate|--no-rerere-autoupdate)
321 allow_rerere_autoupdate="$1"
323 --gpg-sign)
324 gpg_sign_opt=-S
326 --gpg-sign=*)
327 gpg_sign_opt="-S${1#--gpg-sign=}"
330 shift
331 break
333 esac
334 shift
335 done
336 test $# -gt 2 && usage
338 if test -n "$cmd" &&
339 test "$interactive_rebase" != explicit
340 then
341 die "$(gettext "The --exec option must be used with the --interactive option")"
344 if test -n "$action"
345 then
346 test -z "$in_progress" && die "$(gettext "No rebase in progress?")"
347 # Only interactive rebase uses detailed reflog messages
348 if test "$type" = interactive && test "$GIT_REFLOG_ACTION" = rebase
349 then
350 GIT_REFLOG_ACTION="rebase -i ($action)"
351 export GIT_REFLOG_ACTION
355 if test "$action" = "edit-todo" && test "$type" != "interactive"
356 then
357 die "$(gettext "The --edit-todo action can only be used during interactive rebase.")"
360 case "$action" in
361 continue)
362 # Sanity check
363 git rev-parse --verify HEAD >/dev/null ||
364 die "$(gettext "Cannot read HEAD")"
365 git update-index --ignore-submodules --refresh &&
366 git diff-files --quiet --ignore-submodules || {
367 echo "$(gettext "You must edit all merge conflicts and then
368 mark them as resolved using git add")"
369 exit 1
371 read_basic_state
372 run_specific_rebase
374 skip)
375 output git reset --hard HEAD || exit $?
376 read_basic_state
377 run_specific_rebase
379 abort)
380 git rerere clear
381 read_basic_state
382 case "$head_name" in
383 refs/*)
384 git symbolic-ref -m "rebase: aborting" HEAD $head_name ||
385 die "$(eval_gettext "Could not move back to \$head_name")"
387 esac
388 output git reset --hard $orig_head
389 finish_rebase
390 exit
392 edit-todo)
393 run_specific_rebase
395 esac
397 # Make sure no rebase is in progress
398 if test -n "$in_progress"
399 then
400 state_dir_base=${state_dir##*/}
401 cmd_live_rebase="git rebase (--continue | --abort | --skip)"
402 cmd_clear_stale_rebase="rm -fr \"$state_dir\""
403 die "
404 $(eval_gettext 'It seems that there is already a $state_dir_base directory, and
405 I wonder if you are in the middle of another rebase. If that is the
406 case, please try
407 $cmd_live_rebase
408 If that is not the case, please
409 $cmd_clear_stale_rebase
410 and run me again. I am stopping in case you still have something
411 valuable there.')"
414 if test -n "$rebase_root" && test -z "$onto"
415 then
416 test -z "$interactive_rebase" && interactive_rebase=implied
419 if test -n "$interactive_rebase"
420 then
421 type=interactive
422 state_dir="$merge_dir"
423 elif test -n "$do_merge"
424 then
425 type=merge
426 state_dir="$merge_dir"
427 else
428 type=am
429 state_dir="$apply_dir"
432 if test -z "$rebase_root"
433 then
434 case "$#" in
436 if ! upstream_name=$(git rev-parse --symbolic-full-name \
437 --verify -q @{upstream} 2>/dev/null)
438 then
439 . git-parse-remote
440 error_on_missing_default_upstream "rebase" "rebase" \
441 "against" "git rebase <branch>"
444 test "$fork_point" = auto && fork_point=t
446 *) upstream_name="$1"
447 if test "$upstream_name" = "-"
448 then
449 upstream_name="@{-1}"
451 shift
453 esac
454 upstream=$(peel_committish "${upstream_name}") ||
455 die "$(eval_gettext "invalid upstream \$upstream_name")"
456 upstream_arg="$upstream_name"
457 else
458 if test -z "$onto"
459 then
460 empty_tree=`git hash-object -t tree /dev/null`
461 onto=`git commit-tree $empty_tree </dev/null`
462 squash_onto="$onto"
464 unset upstream_name
465 unset upstream
466 test $# -gt 1 && usage
467 upstream_arg=--root
470 # Make sure the branch to rebase onto is valid.
471 onto_name=${onto-"$upstream_name"}
472 case "$onto_name" in
473 *...*)
474 if left=${onto_name%...*} right=${onto_name#*...} &&
475 onto=$(git merge-base --all ${left:-HEAD} ${right:-HEAD})
476 then
477 case "$onto" in
478 ?*"$LF"?*)
479 die "$(eval_gettext "\$onto_name: there are more than one merge bases")"
482 die "$(eval_gettext "\$onto_name: there is no merge base")"
484 esac
485 else
486 die "$(eval_gettext "\$onto_name: there is no merge base")"
490 onto=$(peel_committish "$onto_name") ||
491 die "$(eval_gettext "Does not point to a valid commit: \$onto_name")"
493 esac
495 # If the branch to rebase is given, that is the branch we will rebase
496 # $branch_name -- branch being rebased, or HEAD (already detached)
497 # $orig_head -- commit object name of tip of the branch before rebasing
498 # $head_name -- refs/heads/<that-branch> or "detached HEAD"
499 switch_to=
500 case "$#" in
502 # Is it "rebase other $branchname" or "rebase other $commit"?
503 branch_name="$1"
504 switch_to="$1"
506 if git show-ref --verify --quiet -- "refs/heads/$1" &&
507 orig_head=$(git rev-parse -q --verify "refs/heads/$1")
508 then
509 head_name="refs/heads/$1"
510 elif orig_head=$(git rev-parse -q --verify "$1")
511 then
512 head_name="detached HEAD"
513 else
514 die "$(eval_gettext "fatal: no such branch: \$branch_name")"
518 # Do not need to switch branches, we are already on it.
519 if branch_name=`git symbolic-ref -q HEAD`
520 then
521 head_name=$branch_name
522 branch_name=`expr "z$branch_name" : 'zrefs/heads/\(.*\)'`
523 else
524 head_name="detached HEAD"
525 branch_name=HEAD ;# detached
527 orig_head=$(git rev-parse --verify HEAD) || exit
530 die "BUG: unexpected number of arguments left to parse"
532 esac
534 if test "$fork_point" = t
535 then
536 new_upstream=$(git merge-base --fork-point "$upstream_name" \
537 "${switch_to:-HEAD}")
538 if test -n "$new_upstream"
539 then
540 upstream=$new_upstream
544 if test "$autostash" = true && ! (require_clean_work_tree) 2>/dev/null
545 then
546 stash_sha1=$(git stash create "autostash") ||
547 die "$(gettext 'Cannot autostash')"
549 mkdir -p "$state_dir" &&
550 echo $stash_sha1 >"$state_dir/autostash" &&
551 stash_abbrev=$(git rev-parse --short $stash_sha1) &&
552 echo "$(eval_gettext 'Created autostash: $stash_abbrev')" &&
553 git reset --hard
556 require_clean_work_tree "rebase" "$(gettext "Please commit or stash them.")"
558 # Now we are rebasing commits $upstream..$orig_head (or with --root,
559 # everything leading up to $orig_head) on top of $onto
561 # Check if we are already based on $onto with linear history,
562 # but this should be done only when upstream and onto are the same
563 # and if this is not an interactive rebase.
564 mb=$(git merge-base "$onto" "$orig_head")
565 if test "$type" != interactive && test "$upstream" = "$onto" &&
566 test "$mb" = "$onto" &&
567 # linear history?
568 ! (git rev-list --parents "$onto".."$orig_head" | sane_grep " .* ") > /dev/null
569 then
570 if test -z "$force_rebase"
571 then
572 # Lazily switch to the target branch if needed...
573 test -z "$switch_to" ||
574 GIT_REFLOG_ACTION="$GIT_REFLOG_ACTION: checkout $switch_to" \
575 git checkout "$switch_to" --
576 say "$(eval_gettext "Current branch \$branch_name is up to date.")"
577 finish_rebase
578 exit 0
579 else
580 say "$(eval_gettext "Current branch \$branch_name is up to date, rebase forced.")"
584 # If a hook exists, give it a chance to interrupt
585 run_pre_rebase_hook "$upstream_arg" "$@"
587 if test -n "$diffstat"
588 then
589 if test -n "$verbose"
590 then
591 echo "$(eval_gettext "Changes from \$mb to \$onto:")"
593 # We want color (if set), but no pager
594 GIT_PAGER='' git diff --stat --summary "$mb" "$onto"
597 test "$type" = interactive && run_specific_rebase
599 # Detach HEAD and reset the tree
600 say "$(gettext "First, rewinding head to replay your work on top of it...")"
602 GIT_REFLOG_ACTION="$GIT_REFLOG_ACTION: checkout $onto_name" \
603 git checkout -q "$onto^0" || die "could not detach HEAD"
604 git update-ref ORIG_HEAD $orig_head
606 # If the $onto is a proper descendant of the tip of the branch, then
607 # we just fast-forwarded.
608 if test "$mb" = "$orig_head"
609 then
610 say "$(eval_gettext "Fast-forwarded \$branch_name to \$onto_name.")"
611 move_to_original_branch
612 finish_rebase
613 exit 0
616 if test -n "$rebase_root"
617 then
618 revisions="$onto..$orig_head"
619 else
620 revisions="$upstream..$orig_head"
623 run_specific_rebase