stash: teach 'push' (and 'create_stash') to honor pathspec
[git.git] / git-rebase.sh
blob04f6e44bc8c779d7f4c60c19066820533279324a
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 set_reflog_action rebase
49 require_work_tree_exists
50 cd_to_toplevel
52 LF='
54 ok_to_skip_pre_rebase=
55 resolvemsg="
56 $(gettext 'When you have resolved this problem, run "git rebase --continue".
57 If you prefer to skip this patch, run "git rebase --skip" instead.
58 To check out the original branch and stop rebasing, run "git rebase --abort".')
60 unset onto
61 unset restrict_revision
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 case "$(git config --bool commit.gpgsign)" in
90 true) gpg_sign_opt=-S ;;
91 *) gpg_sign_opt= ;;
92 esac
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 "$(eval_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 || true; } &&
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}"
253 test -z "$interactive_rebase" && interactive_rebase=implied
255 --interactive)
256 interactive_rebase=explicit
258 --keep-empty)
259 keep_empty=yes
261 --preserve-merges)
262 preserve_merges=t
263 test -z "$interactive_rebase" && interactive_rebase=implied
265 --autosquash)
266 autosquash=t
268 --no-autosquash)
269 autosquash=
271 --fork-point)
272 fork_point=t
274 --no-fork-point)
275 fork_point=
277 --merge)
278 do_merge=t
280 --strategy-option=*)
281 strategy_opts="$strategy_opts $(git rev-parse --sq-quote "--${1#--strategy-option=}")"
282 do_merge=t
283 test -z "$strategy" && strategy=recursive
285 --strategy=*)
286 strategy="${1#--strategy=}"
287 do_merge=t
289 --no-stat)
290 diffstat=
292 --stat)
293 diffstat=t
295 --autostash)
296 autostash=true
298 --no-autostash)
299 autostash=false
301 --verbose)
302 verbose=t
303 diffstat=t
304 GIT_QUIET=
306 --quiet)
307 GIT_QUIET=t
308 git_am_opt="$git_am_opt -q"
309 verbose=
310 diffstat=
312 --whitespace=*)
313 git_am_opt="$git_am_opt --whitespace=${1#--whitespace=}"
314 case "${1#--whitespace=}" in
315 fix|strip)
316 force_rebase=t
318 esac
320 --ignore-whitespace)
321 git_am_opt="$git_am_opt $1"
323 --committer-date-is-author-date|--ignore-date)
324 git_am_opt="$git_am_opt $1"
325 force_rebase=t
327 -C*)
328 git_am_opt="$git_am_opt $1"
330 --root)
331 rebase_root=t
333 --force-rebase|--no-ff)
334 force_rebase=t
336 --rerere-autoupdate|--no-rerere-autoupdate)
337 allow_rerere_autoupdate="$1"
339 --gpg-sign)
340 gpg_sign_opt=-S
342 --gpg-sign=*)
343 gpg_sign_opt="-S${1#--gpg-sign=}"
346 shift
347 break
349 esac
350 shift
351 done
352 test $# -gt 2 && usage
354 if test -n "$action"
355 then
356 test -z "$in_progress" && die "$(gettext "No rebase in progress?")"
357 # Only interactive rebase uses detailed reflog messages
358 if test "$type" = interactive && test "$GIT_REFLOG_ACTION" = rebase
359 then
360 GIT_REFLOG_ACTION="rebase -i ($action)"
361 export GIT_REFLOG_ACTION
365 if test "$action" = "edit-todo" && test "$type" != "interactive"
366 then
367 die "$(gettext "The --edit-todo action can only be used during interactive rebase.")"
370 case "$action" in
371 continue)
372 # Sanity check
373 git rev-parse --verify HEAD >/dev/null ||
374 die "$(gettext "Cannot read HEAD")"
375 git update-index --ignore-submodules --refresh &&
376 git diff-files --quiet --ignore-submodules || {
377 echo "$(gettext "You must edit all merge conflicts and then
378 mark them as resolved using git add")"
379 exit 1
381 read_basic_state
382 run_specific_rebase
384 skip)
385 output git reset --hard HEAD || exit $?
386 read_basic_state
387 run_specific_rebase
389 abort)
390 git rerere clear
391 read_basic_state
392 case "$head_name" in
393 refs/*)
394 git symbolic-ref -m "rebase: aborting" HEAD $head_name ||
395 die "$(eval_gettext "Could not move back to \$head_name")"
397 esac
398 output git reset --hard $orig_head
399 finish_rebase
400 exit
402 edit-todo)
403 run_specific_rebase
405 esac
407 # Make sure no rebase is in progress
408 if test -n "$in_progress"
409 then
410 state_dir_base=${state_dir##*/}
411 cmd_live_rebase="git rebase (--continue | --abort | --skip)"
412 cmd_clear_stale_rebase="rm -fr \"$state_dir\""
413 die "
414 $(eval_gettext 'It seems that there is already a $state_dir_base directory, and
415 I wonder if you are in the middle of another rebase. If that is the
416 case, please try
417 $cmd_live_rebase
418 If that is not the case, please
419 $cmd_clear_stale_rebase
420 and run me again. I am stopping in case you still have something
421 valuable there.')"
424 if test -n "$rebase_root" && test -z "$onto"
425 then
426 test -z "$interactive_rebase" && interactive_rebase=implied
429 if test -n "$interactive_rebase"
430 then
431 type=interactive
432 state_dir="$merge_dir"
433 elif test -n "$do_merge"
434 then
435 type=merge
436 state_dir="$merge_dir"
437 else
438 type=am
439 state_dir="$apply_dir"
442 if test -z "$rebase_root"
443 then
444 case "$#" in
446 if ! upstream_name=$(git rev-parse --symbolic-full-name \
447 --verify -q @{upstream} 2>/dev/null)
448 then
449 . git-parse-remote
450 error_on_missing_default_upstream "rebase" "rebase" \
451 "against" "git rebase $(gettext '<branch>')"
454 test "$fork_point" = auto && fork_point=t
456 *) upstream_name="$1"
457 if test "$upstream_name" = "-"
458 then
459 upstream_name="@{-1}"
461 shift
463 esac
464 upstream=$(peel_committish "${upstream_name}") ||
465 die "$(eval_gettext "invalid upstream \$upstream_name")"
466 upstream_arg="$upstream_name"
467 else
468 if test -z "$onto"
469 then
470 empty_tree=$(git hash-object -t tree /dev/null)
471 onto=$(git commit-tree $empty_tree </dev/null)
472 squash_onto="$onto"
474 unset upstream_name
475 unset upstream
476 test $# -gt 1 && usage
477 upstream_arg=--root
480 # Make sure the branch to rebase onto is valid.
481 onto_name=${onto-"$upstream_name"}
482 case "$onto_name" in
483 *...*)
484 if left=${onto_name%...*} right=${onto_name#*...} &&
485 onto=$(git merge-base --all ${left:-HEAD} ${right:-HEAD})
486 then
487 case "$onto" in
488 ?*"$LF"?*)
489 die "$(eval_gettext "\$onto_name: there are more than one merge bases")"
492 die "$(eval_gettext "\$onto_name: there is no merge base")"
494 esac
495 else
496 die "$(eval_gettext "\$onto_name: there is no merge base")"
500 onto=$(peel_committish "$onto_name") ||
501 die "$(eval_gettext "Does not point to a valid commit: \$onto_name")"
503 esac
505 # If the branch to rebase is given, that is the branch we will rebase
506 # $branch_name -- branch being rebased, or HEAD (already detached)
507 # $orig_head -- commit object name of tip of the branch before rebasing
508 # $head_name -- refs/heads/<that-branch> or "detached HEAD"
509 switch_to=
510 case "$#" in
512 # Is it "rebase other $branchname" or "rebase other $commit"?
513 branch_name="$1"
514 switch_to="$1"
516 if git show-ref --verify --quiet -- "refs/heads/$1" &&
517 orig_head=$(git rev-parse -q --verify "refs/heads/$1")
518 then
519 head_name="refs/heads/$1"
520 elif orig_head=$(git rev-parse -q --verify "$1")
521 then
522 head_name="detached HEAD"
523 else
524 die "$(eval_gettext "fatal: no such branch: \$branch_name")"
528 # Do not need to switch branches, we are already on it.
529 if branch_name=$(git symbolic-ref -q HEAD)
530 then
531 head_name=$branch_name
532 branch_name=$(expr "z$branch_name" : 'zrefs/heads/\(.*\)')
533 else
534 head_name="detached HEAD"
535 branch_name=HEAD ;# detached
537 orig_head=$(git rev-parse --verify HEAD) || exit
540 die "BUG: unexpected number of arguments left to parse"
542 esac
544 if test "$fork_point" = t
545 then
546 new_upstream=$(git merge-base --fork-point "$upstream_name" \
547 "${switch_to:-HEAD}")
548 if test -n "$new_upstream"
549 then
550 restrict_revision=$new_upstream
554 if test "$autostash" = true && ! (require_clean_work_tree) 2>/dev/null
555 then
556 stash_sha1=$(git stash create "autostash") ||
557 die "$(gettext 'Cannot autostash')"
559 mkdir -p "$state_dir" &&
560 echo $stash_sha1 >"$state_dir/autostash" &&
561 stash_abbrev=$(git rev-parse --short $stash_sha1) &&
562 echo "$(eval_gettext 'Created autostash: $stash_abbrev')" &&
563 git reset --hard
566 require_clean_work_tree "rebase" "$(gettext "Please commit or stash them.")"
568 # Now we are rebasing commits $upstream..$orig_head (or with --root,
569 # everything leading up to $orig_head) on top of $onto
571 # Check if we are already based on $onto with linear history,
572 # but this should be done only when upstream and onto are the same
573 # and if this is not an interactive rebase.
574 mb=$(git merge-base "$onto" "$orig_head")
575 if test "$type" != interactive && test "$upstream" = "$onto" &&
576 test "$mb" = "$onto" && test -z "$restrict_revision" &&
577 # linear history?
578 ! (git rev-list --parents "$onto".."$orig_head" | sane_grep " .* ") > /dev/null
579 then
580 if test -z "$force_rebase"
581 then
582 # Lazily switch to the target branch if needed...
583 test -z "$switch_to" ||
584 GIT_REFLOG_ACTION="$GIT_REFLOG_ACTION: checkout $switch_to" \
585 git checkout -q "$switch_to" --
586 say "$(eval_gettext "Current branch \$branch_name is up to date.")"
587 finish_rebase
588 exit 0
589 else
590 say "$(eval_gettext "Current branch \$branch_name is up to date, rebase forced.")"
594 # If a hook exists, give it a chance to interrupt
595 run_pre_rebase_hook "$upstream_arg" "$@"
597 if test -n "$diffstat"
598 then
599 if test -n "$verbose"
600 then
601 echo "$(eval_gettext "Changes from \$mb to \$onto:")"
603 # We want color (if set), but no pager
604 GIT_PAGER='' git diff --stat --summary "$mb" "$onto"
607 test "$type" = interactive && run_specific_rebase
609 # Detach HEAD and reset the tree
610 say "$(gettext "First, rewinding head to replay your work on top of it...")"
612 GIT_REFLOG_ACTION="$GIT_REFLOG_ACTION: checkout $onto_name" \
613 git checkout -q "$onto^0" || die "could not detach HEAD"
614 git update-ref ORIG_HEAD $orig_head
616 # If the $onto is a proper descendant of the tip of the branch, then
617 # we just fast-forwarded.
618 if test "$mb" = "$orig_head"
619 then
620 say "$(eval_gettext "Fast-forwarded \$branch_name to \$onto_name.")"
621 move_to_original_branch
622 finish_rebase
623 exit 0
626 if test -n "$rebase_root"
627 then
628 revisions="$onto..$orig_head"
629 else
630 revisions="${restrict_revision-$upstream}..$orig_head"
633 run_specific_rebase