Merge branch 'cw/rebase-i-root'
[git/mjg.git] / git-rebase.sh
blob1cd0633b80a8daf00dbc50657ccba228bd578a73
1 #!/bin/sh
3 # Copyright (c) 2005 Junio C Hamano.
6 USAGE='[--interactive | -i] [--exec | -x <cmd>] [-v] [--force-rebase | -f]
7 [--no-ff] [--onto <newbase>] [<upstream>|--root] [<branch>] [--quiet | -q]'
8 LONG_USAGE='git-rebase replaces <branch> with a new branch of the
9 same name. When the --onto option is provided the new branch starts
10 out with a HEAD equal to <newbase>, otherwise it is equal to <upstream>
11 It then attempts to create a new commit for each commit from the original
12 <branch> that does not exist in the <upstream> branch.
14 It is possible that a merge failure will prevent this process from being
15 completely automatic. You will have to resolve any such merge failure
16 and run git rebase --continue. Another option is to bypass the commit
17 that caused the merge failure with git rebase --skip. To check out the
18 original <branch> and remove the .git/rebase-apply working files, use the
19 command git rebase --abort instead.
21 Note that if <branch> is not specified on the command line, the
22 currently checked out branch is used.
24 Example: git-rebase master~1 topic
26 A---B---C topic A'\''--B'\''--C'\'' topic
27 / --> /
28 D---E---F---G master D---E---F---G master
31 SUBDIRECTORY_OK=Yes
32 OPTIONS_KEEPDASHDASH=
33 OPTIONS_SPEC="\
34 git rebase [-i] [options] [--exec <cmd>] [--onto <newbase>] [<upstream>] [<branch>]
35 git rebase [-i] [options] [--exec <cmd>] [--onto <newbase>] --root [<branch>]
36 git-rebase [-i] --continue | --abort | --skip
38 Available options are
39 v,verbose! display a diffstat of what changed upstream
40 q,quiet! be quiet. implies --no-stat
41 onto=! rebase onto given branch instead of upstream
42 p,preserve-merges! try to recreate merges instead of ignoring them
43 s,strategy=! use the given merge strategy
44 no-ff! cherry-pick all commits, even if unchanged
45 m,merge! use merging strategies to rebase
46 i,interactive! let the user edit the list of commits to rebase
47 x,exec=! add exec lines after each commit of the editable list
48 k,keep-empty preserve empty commits during rebase
49 f,force-rebase! force rebase even if branch is up to date
50 X,strategy-option=! pass the argument through to the merge strategy
51 stat! display a diffstat of what changed upstream
52 n,no-stat! do not show diffstat of what changed upstream
53 verify allow pre-rebase hook to run
54 rerere-autoupdate allow rerere to update index with resolved conflicts
55 root! rebase all reachable commits up to the root(s)
56 autosquash move commits that begin with squash!/fixup! under -i
57 committer-date-is-author-date! passed to 'git am'
58 ignore-date! passed to 'git am'
59 whitespace=! passed to 'git apply'
60 ignore-whitespace! passed to 'git apply'
61 C=! passed to 'git apply'
62 Actions:
63 continue! continue
64 abort! abort and check out the original branch
65 skip! skip current patch and continue
67 . git-sh-setup
68 set_reflog_action rebase
69 require_work_tree_exists
70 cd_to_toplevel
72 LF='
74 ok_to_skip_pre_rebase=
75 resolvemsg="
76 When you have resolved this problem run \"git rebase --continue\".
77 If you would prefer to skip this patch, instead run \"git rebase --skip\".
78 To check out the original branch and stop rebasing run \"git rebase --abort\".
80 unset onto
81 cmd=
82 strategy=
83 strategy_opts=
84 do_merge=
85 merge_dir="$GIT_DIR"/rebase-merge
86 apply_dir="$GIT_DIR"/rebase-apply
87 verbose=
88 diffstat=
89 test "$(git config --bool rebase.stat)" = true && diffstat=t
90 git_am_opt=
91 rebase_root=
92 force_rebase=
93 allow_rerere_autoupdate=
94 # Non-empty if a rebase was in progress when 'git rebase' was invoked
95 in_progress=
96 # One of {am, merge, interactive}
97 type=
98 # One of {"$GIT_DIR"/rebase-apply, "$GIT_DIR"/rebase-merge}
99 state_dir=
100 # One of {'', continue, skip, abort}, as parsed from command line
101 action=
102 preserve_merges=
103 autosquash=
104 keep_empty=
105 test "$(git config --bool rebase.autosquash)" = "true" && autosquash=t
107 read_basic_state () {
108 head_name=$(cat "$state_dir"/head-name) &&
109 onto=$(cat "$state_dir"/onto) &&
110 # We always write to orig-head, but interactive rebase used to write to
111 # head. Fall back to reading from head to cover for the case that the
112 # user upgraded git with an ongoing interactive rebase.
113 if test -f "$state_dir"/orig-head
114 then
115 orig_head=$(cat "$state_dir"/orig-head)
116 else
117 orig_head=$(cat "$state_dir"/head)
118 fi &&
119 GIT_QUIET=$(cat "$state_dir"/quiet) &&
120 test -f "$state_dir"/verbose && verbose=t
121 test -f "$state_dir"/strategy && strategy="$(cat "$state_dir"/strategy)"
122 test -f "$state_dir"/strategy_opts &&
123 strategy_opts="$(cat "$state_dir"/strategy_opts)"
124 test -f "$state_dir"/allow_rerere_autoupdate &&
125 allow_rerere_autoupdate="$(cat "$state_dir"/allow_rerere_autoupdate)"
128 write_basic_state () {
129 echo "$head_name" > "$state_dir"/head-name &&
130 echo "$onto" > "$state_dir"/onto &&
131 echo "$orig_head" > "$state_dir"/orig-head &&
132 echo "$GIT_QUIET" > "$state_dir"/quiet &&
133 test t = "$verbose" && : > "$state_dir"/verbose
134 test -n "$strategy" && echo "$strategy" > "$state_dir"/strategy
135 test -n "$strategy_opts" && echo "$strategy_opts" > \
136 "$state_dir"/strategy_opts
137 test -n "$allow_rerere_autoupdate" && echo "$allow_rerere_autoupdate" > \
138 "$state_dir"/allow_rerere_autoupdate
141 output () {
142 case "$verbose" in
144 output=$("$@" 2>&1 )
145 status=$?
146 test $status != 0 && printf "%s\n" "$output"
147 return $status
150 "$@"
152 esac
155 move_to_original_branch () {
156 case "$head_name" in
157 refs/*)
158 message="rebase finished: $head_name onto $onto"
159 git update-ref -m "$message" \
160 $head_name $(git rev-parse HEAD) $orig_head &&
161 git symbolic-ref \
162 -m "rebase finished: returning to $head_name" \
163 HEAD $head_name ||
164 die "Could not move back to $head_name"
166 esac
169 run_specific_rebase () {
170 if [ "$interactive_rebase" = implied ]; then
171 GIT_EDITOR=:
172 export GIT_EDITOR
173 autosquash=
175 . git-rebase--$type
178 run_pre_rebase_hook () {
179 if test -z "$ok_to_skip_pre_rebase" &&
180 test -x "$GIT_DIR/hooks/pre-rebase"
181 then
182 "$GIT_DIR/hooks/pre-rebase" ${1+"$@"} ||
183 die "The pre-rebase hook refused to rebase."
187 test -f "$apply_dir"/applying &&
188 die 'It looks like git-am is in progress. Cannot rebase.'
190 if test -d "$apply_dir"
191 then
192 type=am
193 state_dir="$apply_dir"
194 elif test -d "$merge_dir"
195 then
196 if test -f "$merge_dir"/interactive
197 then
198 type=interactive
199 interactive_rebase=explicit
200 else
201 type=merge
203 state_dir="$merge_dir"
205 test -n "$type" && in_progress=t
207 total_argc=$#
208 while test $# != 0
210 case "$1" in
211 --no-verify)
212 ok_to_skip_pre_rebase=yes
214 --verify)
215 ok_to_skip_pre_rebase=
217 --continue|--skip|--abort)
218 test $total_argc -eq 2 || usage
219 action=${1##--}
221 --onto)
222 test 2 -le "$#" || usage
223 onto="$2"
224 shift
227 test 2 -le "$#" || usage
228 cmd="${cmd}exec $2${LF}"
229 shift
232 interactive_rebase=explicit
235 keep_empty=yes
238 preserve_merges=t
239 test -z "$interactive_rebase" && interactive_rebase=implied
241 --autosquash)
242 autosquash=t
244 --no-autosquash)
245 autosquash=
247 -M|-m)
248 do_merge=t
251 shift
252 strategy_opts="$strategy_opts $(git rev-parse --sq-quote "--$1")"
253 do_merge=t
254 test -z "$strategy" && strategy=recursive
257 shift
258 strategy="$1"
259 do_merge=t
262 diffstat=
264 --stat)
265 diffstat=t
268 verbose=t
269 diffstat=t
270 GIT_QUIET=
273 GIT_QUIET=t
274 git_am_opt="$git_am_opt -q"
275 verbose=
276 diffstat=
278 --whitespace)
279 shift
280 git_am_opt="$git_am_opt --whitespace=$1"
281 case "$1" in
282 fix|strip)
283 force_rebase=t
285 esac
287 --ignore-whitespace)
288 git_am_opt="$git_am_opt $1"
290 --committer-date-is-author-date|--ignore-date)
291 git_am_opt="$git_am_opt $1"
292 force_rebase=t
295 shift
296 git_am_opt="$git_am_opt -C$1"
298 --root)
299 rebase_root=t
301 -f|--no-ff)
302 force_rebase=t
304 --rerere-autoupdate|--no-rerere-autoupdate)
305 allow_rerere_autoupdate="$1"
308 shift
309 break
311 esac
312 shift
313 done
314 test $# -gt 2 && usage
316 if test -n "$cmd" &&
317 test "$interactive_rebase" != explicit
318 then
319 die "--exec option must be used with --interactive option"
322 if test -n "$action"
323 then
324 test -z "$in_progress" && die "No rebase in progress?"
325 # Only interactive rebase uses detailed reflog messages
326 if test "$type" = interactive && test "$GIT_REFLOG_ACTION" = rebase
327 then
328 GIT_REFLOG_ACTION="rebase -i ($action)"
329 export GIT_REFLOG_ACTION
333 case "$action" in
334 continue)
335 # Sanity check
336 git rev-parse --verify HEAD >/dev/null ||
337 die "Cannot read HEAD"
338 git update-index --ignore-submodules --refresh &&
339 git diff-files --quiet --ignore-submodules || {
340 echo "You must edit all merge conflicts and then"
341 echo "mark them as resolved using git add"
342 exit 1
344 read_basic_state
345 run_specific_rebase
347 skip)
348 output git reset --hard HEAD || exit $?
349 read_basic_state
350 run_specific_rebase
352 abort)
353 git rerere clear
354 read_basic_state
355 case "$head_name" in
356 refs/*)
357 git symbolic-ref -m "rebase: aborting" HEAD $head_name ||
358 die "Could not move back to $head_name"
360 esac
361 output git reset --hard $orig_head
362 rm -r "$state_dir"
363 exit
365 esac
367 # Make sure no rebase is in progress
368 if test -n "$in_progress"
369 then
370 die '
371 It seems that there is already a '"${state_dir##*/}"' directory, and
372 I wonder if you are in the middle of another rebase. If that is the
373 case, please try
374 git rebase (--continue | --abort | --skip)
375 If that is not the case, please
376 rm -fr '"$state_dir"'
377 and run me again. I am stopping in case you still have something
378 valuable there.'
381 if test -n "$rebase_root" && test -z "$onto"
382 then
383 test -z "$interactive_rebase" && interactive_rebase=implied
386 if test -n "$interactive_rebase"
387 then
388 type=interactive
389 state_dir="$merge_dir"
390 elif test -n "$do_merge"
391 then
392 type=merge
393 state_dir="$merge_dir"
394 else
395 type=am
396 state_dir="$apply_dir"
399 if test -z "$rebase_root"
400 then
401 case "$#" in
403 if ! upstream_name=$(git rev-parse --symbolic-full-name \
404 --verify -q @{upstream} 2>/dev/null)
405 then
406 . git-parse-remote
407 error_on_missing_default_upstream "rebase" "rebase" \
408 "against" "git rebase <branch>"
411 *) upstream_name="$1"
412 shift
414 esac
415 upstream=`git rev-parse --verify "${upstream_name}^0"` ||
416 die "invalid upstream $upstream_name"
417 upstream_arg="$upstream_name"
418 else
419 if test -z "$onto"
420 then
421 empty_tree=`git hash-object -t tree /dev/null`
422 onto=`git commit-tree $empty_tree </dev/null`
423 squash_onto="$onto"
425 unset upstream_name
426 unset upstream
427 test $# -gt 1 && usage
428 upstream_arg=--root
431 # Make sure the branch to rebase onto is valid.
432 onto_name=${onto-"$upstream_name"}
433 case "$onto_name" in
434 *...*)
435 if left=${onto_name%...*} right=${onto_name#*...} &&
436 onto=$(git merge-base --all ${left:-HEAD} ${right:-HEAD})
437 then
438 case "$onto" in
439 ?*"$LF"?*)
440 die "$onto_name: there are more than one merge bases"
443 die "$onto_name: there is no merge base"
445 esac
446 else
447 die "$onto_name: there is no merge base"
451 onto=$(git rev-parse --verify "${onto_name}^0") ||
452 die "Does not point to a valid commit: $onto_name"
454 esac
456 # If the branch to rebase is given, that is the branch we will rebase
457 # $branch_name -- branch being rebased, or HEAD (already detached)
458 # $orig_head -- commit object name of tip of the branch before rebasing
459 # $head_name -- refs/heads/<that-branch> or "detached HEAD"
460 switch_to=
461 case "$#" in
463 # Is it "rebase other $branchname" or "rebase other $commit"?
464 branch_name="$1"
465 switch_to="$1"
467 if git show-ref --verify --quiet -- "refs/heads/$1" &&
468 orig_head=$(git rev-parse -q --verify "refs/heads/$1")
469 then
470 head_name="refs/heads/$1"
471 elif orig_head=$(git rev-parse -q --verify "$1")
472 then
473 head_name="detached HEAD"
474 else
475 die "fatal: no such branch: $1"
479 # Do not need to switch branches, we are already on it.
480 if branch_name=`git symbolic-ref -q HEAD`
481 then
482 head_name=$branch_name
483 branch_name=`expr "z$branch_name" : 'zrefs/heads/\(.*\)'`
484 else
485 head_name="detached HEAD"
486 branch_name=HEAD ;# detached
488 orig_head=$(git rev-parse --verify "${branch_name}^0") || exit
491 die "BUG: unexpected number of arguments left to parse"
493 esac
495 require_clean_work_tree "rebase" "Please commit or stash them."
497 # Now we are rebasing commits $upstream..$orig_head (or with --root,
498 # everything leading up to $orig_head) on top of $onto
500 # Check if we are already based on $onto with linear history,
501 # but this should be done only when upstream and onto are the same
502 # and if this is not an interactive rebase.
503 mb=$(git merge-base "$onto" "$orig_head")
504 if test "$type" != interactive && test "$upstream" = "$onto" &&
505 test "$mb" = "$onto" &&
506 # linear history?
507 ! (git rev-list --parents "$onto".."$orig_head" | sane_grep " .* ") > /dev/null
508 then
509 if test -z "$force_rebase"
510 then
511 # Lazily switch to the target branch if needed...
512 test -z "$switch_to" || git checkout "$switch_to" --
513 say "Current branch $branch_name is up to date."
514 exit 0
515 else
516 say "Current branch $branch_name is up to date, rebase forced."
520 # If a hook exists, give it a chance to interrupt
521 run_pre_rebase_hook "$upstream_arg" "$@"
523 if test -n "$diffstat"
524 then
525 if test -n "$verbose"
526 then
527 echo "Changes from $mb to $onto:"
529 # We want color (if set), but no pager
530 GIT_PAGER='' git diff --stat --summary "$mb" "$onto"
533 test "$type" = interactive && run_specific_rebase
535 # Detach HEAD and reset the tree
536 say "First, rewinding head to replay your work on top of it..."
537 git checkout -q "$onto^0" || die "could not detach HEAD"
538 git update-ref ORIG_HEAD $orig_head
540 # If the $onto is a proper descendant of the tip of the branch, then
541 # we just fast-forwarded.
542 if test "$mb" = "$orig_head"
543 then
544 say "Fast-forwarded $branch_name to $onto_name."
545 move_to_original_branch
546 exit 0
549 if test -n "$rebase_root"
550 then
551 revisions="$onto..$orig_head"
552 else
553 revisions="$upstream..$orig_head"
556 run_specific_rebase