Merge branch 'jk/maint-config-multi-order'
[git] / git-rebase.sh
1 #!/bin/sh
2 #
3 # Copyright (c) 2005 Junio C Hamano.
4 #
5
6 SUBDIRECTORY_OK=Yes
7 OPTIONS_KEEPDASHDASH=
8 OPTIONS_SPEC="\
9 git rebase [-i] [options] [--exec <cmd>] [--onto <newbase>] [<upstream>] [<branch>]
10 git rebase [-i] [options] [--exec <cmd>] [--onto <newbase>] --root [<branch>]
11 git-rebase --continue | --abort | --skip | --edit-todo
12 --
13  Available options are
14 v,verbose!         display a diffstat of what changed upstream
15 q,quiet!           be quiet. implies --no-stat
16 autostash!         automatically stash/stash pop before and after
17 onto=!             rebase onto given branch instead of upstream
18 p,preserve-merges! try to recreate merges instead of ignoring them
19 s,strategy=!       use the given merge strategy
20 no-ff!             cherry-pick all commits, even if unchanged
21 m,merge!           use merging strategies to rebase
22 i,interactive!     let the user edit the list of commits to rebase
23 x,exec=!           add exec lines after each commit of the editable list
24 k,keep-empty       preserve empty commits during rebase
25 f,force-rebase!    force rebase even if branch is up to date
26 X,strategy-option=! pass the argument through to the merge strategy
27 stat!              display a diffstat of what changed upstream
28 n,no-stat!         do not show diffstat of what changed upstream
29 verify             allow pre-rebase hook to run
30 rerere-autoupdate  allow rerere to update index with resolved conflicts
31 root!              rebase all reachable commits up to the root(s)
32 autosquash         move commits that begin with squash!/fixup! under -i
33 committer-date-is-author-date! passed to 'git am'
34 ignore-date!       passed to 'git am'
35 whitespace=!       passed to 'git apply'
36 ignore-whitespace! passed to 'git apply'
37 C=!                passed to 'git apply'
38  Actions:
39 continue!          continue
40 abort!             abort and check out the original branch
41 skip!              skip current patch and continue
42 edit-todo!         edit the todo list during an interactive rebase
43 "
44 . git-sh-setup
45 . git-sh-i18n
46 set_reflog_action rebase
47 require_work_tree_exists
48 cd_to_toplevel
49
50 LF='
51 '
52 ok_to_skip_pre_rebase=
53 resolvemsg="
54 $(gettext 'When you have resolved this problem, run "git rebase --continue".
55 If you prefer to skip this patch, run "git rebase --skip" instead.
56 To check out the original branch and stop rebasing, run "git rebase --abort".')
57 "
58 unset onto
59 cmd=
60 strategy=
61 strategy_opts=
62 do_merge=
63 merge_dir="$GIT_DIR"/rebase-merge
64 apply_dir="$GIT_DIR"/rebase-apply
65 verbose=
66 diffstat=
67 test "$(git config --bool rebase.stat)" = true && diffstat=t
68 autostash="$(git config --bool rebase.autostash || echo false)"
69 git_am_opt=
70 rebase_root=
71 force_rebase=
72 allow_rerere_autoupdate=
73 # Non-empty if a rebase was in progress when 'git rebase' was invoked
74 in_progress=
75 # One of {am, merge, interactive}
76 type=
77 # One of {"$GIT_DIR"/rebase-apply, "$GIT_DIR"/rebase-merge}
78 state_dir=
79 # One of {'', continue, skip, abort}, as parsed from command line
80 action=
81 preserve_merges=
82 autosquash=
83 keep_empty=
84 test "$(git config --bool rebase.autosquash)" = "true" && autosquash=t
85
86 read_basic_state () {
87         test -f "$state_dir/head-name" &&
88         test -f "$state_dir/onto" &&
89         head_name=$(cat "$state_dir"/head-name) &&
90         onto=$(cat "$state_dir"/onto) &&
91         # We always write to orig-head, but interactive rebase used to write to
92         # head. Fall back to reading from head to cover for the case that the
93         # user upgraded git with an ongoing interactive rebase.
94         if test -f "$state_dir"/orig-head
95         then
96                 orig_head=$(cat "$state_dir"/orig-head)
97         else
98                 orig_head=$(cat "$state_dir"/head)
99         fi &&
100         GIT_QUIET=$(cat "$state_dir"/quiet) &&
101         test -f "$state_dir"/verbose && verbose=t
102         test -f "$state_dir"/strategy && strategy="$(cat "$state_dir"/strategy)"
103         test -f "$state_dir"/strategy_opts &&
104                 strategy_opts="$(cat "$state_dir"/strategy_opts)"
105         test -f "$state_dir"/allow_rerere_autoupdate &&
106                 allow_rerere_autoupdate="$(cat "$state_dir"/allow_rerere_autoupdate)"
107 }
108
109 write_basic_state () {
110         echo "$head_name" > "$state_dir"/head-name &&
111         echo "$onto" > "$state_dir"/onto &&
112         echo "$orig_head" > "$state_dir"/orig-head &&
113         echo "$GIT_QUIET" > "$state_dir"/quiet &&
114         test t = "$verbose" && : > "$state_dir"/verbose
115         test -n "$strategy" && echo "$strategy" > "$state_dir"/strategy
116         test -n "$strategy_opts" && echo "$strategy_opts" > \
117                 "$state_dir"/strategy_opts
118         test -n "$allow_rerere_autoupdate" && echo "$allow_rerere_autoupdate" > \
119                 "$state_dir"/allow_rerere_autoupdate
120 }
121
122 output () {
123         case "$verbose" in
124         '')
125                 output=$("$@" 2>&1 )
126                 status=$?
127                 test $status != 0 && printf "%s\n" "$output"
128                 return $status
129                 ;;
130         *)
131                 "$@"
132                 ;;
133         esac
134 }
135
136 move_to_original_branch () {
137         case "$head_name" in
138         refs/*)
139                 message="rebase finished: $head_name onto $onto"
140                 git update-ref -m "$message" \
141                         $head_name $(git rev-parse HEAD) $orig_head &&
142                 git symbolic-ref \
143                         -m "rebase finished: returning to $head_name" \
144                         HEAD $head_name ||
145                 die "$(gettext "Could not move back to $head_name")"
146                 ;;
147         esac
148 }
149
150 finish_rebase () {
151         if test -f "$state_dir/autostash"
152         then
153                 stash_sha1=$(cat "$state_dir/autostash")
154                 if git stash apply $stash_sha1 2>&1 >/dev/null
155                 then
156                         echo "$(gettext 'Applied autostash.')"
157                 else
158                         git stash store -m "autostash" -q $stash_sha1 ||
159                         die "$(eval_gettext "Cannot store \$stash_sha1")"
160                         gettext 'Applying autostash resulted in conflicts.
161 Your changes are safe in the stash.
162 You can run "git stash pop" or "git stash drop" it at any time.
163 '
164                 fi
165         fi
166         git gc --auto &&
167         rm -rf "$state_dir"
168 }
169
170 run_specific_rebase () {
171         if [ "$interactive_rebase" = implied ]; then
172                 GIT_EDITOR=:
173                 export GIT_EDITOR
174                 autosquash=
175         fi
176         . git-rebase--$type
177         ret=$?
178         if test $ret -eq 0
179         then
180                 finish_rebase
181         fi
182         exit $ret
183 }
184
185 run_pre_rebase_hook () {
186         if test -z "$ok_to_skip_pre_rebase" &&
187            test -x "$GIT_DIR/hooks/pre-rebase"
188         then
189                 "$GIT_DIR/hooks/pre-rebase" ${1+"$@"} ||
190                 die "$(gettext "The pre-rebase hook refused to rebase.")"
191         fi
192 }
193
194 test -f "$apply_dir"/applying &&
195         die "$(gettext "It looks like git-am is in progress. Cannot rebase.")"
196
197 if test -d "$apply_dir"
198 then
199         type=am
200         state_dir="$apply_dir"
201 elif test -d "$merge_dir"
202 then
203         if test -f "$merge_dir"/interactive
204         then
205                 type=interactive
206                 interactive_rebase=explicit
207         else
208                 type=merge
209         fi
210         state_dir="$merge_dir"
211 fi
212 test -n "$type" && in_progress=t
213
214 total_argc=$#
215 while test $# != 0
216 do
217         case "$1" in
218         --no-verify)
219                 ok_to_skip_pre_rebase=yes
220                 ;;
221         --verify)
222                 ok_to_skip_pre_rebase=
223                 ;;
224         --continue|--skip|--abort|--edit-todo)
225                 test $total_argc -eq 2 || usage
226                 action=${1##--}
227                 ;;
228         --onto)
229                 test 2 -le "$#" || usage
230                 onto="$2"
231                 shift
232                 ;;
233         -x)
234                 test 2 -le "$#" || usage
235                 cmd="${cmd}exec $2${LF}"
236                 shift
237                 ;;
238         -i)
239                 interactive_rebase=explicit
240                 ;;
241         -k)
242                 keep_empty=yes
243                 ;;
244         -p)
245                 preserve_merges=t
246                 test -z "$interactive_rebase" && interactive_rebase=implied
247                 ;;
248         --autosquash)
249                 autosquash=t
250                 ;;
251         --no-autosquash)
252                 autosquash=
253                 ;;
254         -M|-m)
255                 do_merge=t
256                 ;;
257         -X)
258                 shift
259                 strategy_opts="$strategy_opts $(git rev-parse --sq-quote "--$1")"
260                 do_merge=t
261                 test -z "$strategy" && strategy=recursive
262                 ;;
263         -s)
264                 shift
265                 strategy="$1"
266                 do_merge=t
267                 ;;
268         -n)
269                 diffstat=
270                 ;;
271         --stat)
272                 diffstat=t
273                 ;;
274         --autostash)
275                 autostash=true
276                 ;;
277         -v)
278                 verbose=t
279                 diffstat=t
280                 GIT_QUIET=
281                 ;;
282         -q)
283                 GIT_QUIET=t
284                 git_am_opt="$git_am_opt -q"
285                 verbose=
286                 diffstat=
287                 ;;
288         --whitespace)
289                 shift
290                 git_am_opt="$git_am_opt --whitespace=$1"
291                 case "$1" in
292                 fix|strip)
293                         force_rebase=t
294                         ;;
295                 esac
296                 ;;
297         --ignore-whitespace)
298                 git_am_opt="$git_am_opt $1"
299                 ;;
300         --committer-date-is-author-date|--ignore-date)
301                 git_am_opt="$git_am_opt $1"
302                 force_rebase=t
303                 ;;
304         -C)
305                 shift
306                 git_am_opt="$git_am_opt -C$1"
307                 ;;
308         --root)
309                 rebase_root=t
310                 ;;
311         -f|--no-ff)
312                 force_rebase=t
313                 ;;
314         --rerere-autoupdate|--no-rerere-autoupdate)
315                 allow_rerere_autoupdate="$1"
316                 ;;
317         --)
318                 shift
319                 break
320                 ;;
321         esac
322         shift
323 done
324 test $# -gt 2 && usage
325
326 if test -n "$cmd" &&
327    test "$interactive_rebase" != explicit
328 then
329         die "$(gettext "The --exec option must be used with the --interactive option")"
330 fi
331
332 if test -n "$action"
333 then
334         test -z "$in_progress" && die "$(gettext "No rebase in progress?")"
335         # Only interactive rebase uses detailed reflog messages
336         if test "$type" = interactive && test "$GIT_REFLOG_ACTION" = rebase
337         then
338                 GIT_REFLOG_ACTION="rebase -i ($action)"
339                 export GIT_REFLOG_ACTION
340         fi
341 fi
342
343 if test "$action" = "edit-todo" && test "$type" != "interactive"
344 then
345         die "$(gettext "The --edit-todo action can only be used during interactive rebase.")"
346 fi
347
348 case "$action" in
349 continue)
350         # Sanity check
351         git rev-parse --verify HEAD >/dev/null ||
352                 die "$(gettext "Cannot read HEAD")"
353         git update-index --ignore-submodules --refresh &&
354         git diff-files --quiet --ignore-submodules || {
355                 echo "$(gettext "You must edit all merge conflicts and then
356 mark them as resolved using git add")"
357                 exit 1
358         }
359         read_basic_state
360         run_specific_rebase
361         ;;
362 skip)
363         output git reset --hard HEAD || exit $?
364         read_basic_state
365         run_specific_rebase
366         ;;
367 abort)
368         git rerere clear
369         read_basic_state
370         case "$head_name" in
371         refs/*)
372                 git symbolic-ref -m "rebase: aborting" HEAD $head_name ||
373                 die "$(eval_gettext "Could not move back to \$head_name")"
374                 ;;
375         esac
376         output git reset --hard $orig_head
377         finish_rebase
378         exit
379         ;;
380 edit-todo)
381         run_specific_rebase
382         ;;
383 esac
384
385 # Make sure no rebase is in progress
386 if test -n "$in_progress"
387 then
388         state_dir_base=${state_dir##*/}
389         cmd_live_rebase="git rebase (--continue | --abort | --skip)"
390         cmd_clear_stale_rebase="rm -fr \"$state_dir\""
391         die "
392 $(eval_gettext 'It seems that there is already a $state_dir_base directory, and
393 I wonder if you are in the middle of another rebase.  If that is the
394 case, please try
395         $cmd_live_rebase
396 If that is not the case, please
397         $cmd_clear_stale_rebase
398 and run me again.  I am stopping in case you still have something
399 valuable there.')"
400 fi
401
402 if test -n "$rebase_root" && test -z "$onto"
403 then
404         test -z "$interactive_rebase" && interactive_rebase=implied
405 fi
406
407 if test -n "$interactive_rebase"
408 then
409         type=interactive
410         state_dir="$merge_dir"
411 elif test -n "$do_merge"
412 then
413         type=merge
414         state_dir="$merge_dir"
415 else
416         type=am
417         state_dir="$apply_dir"
418 fi
419
420 if test -z "$rebase_root"
421 then
422         case "$#" in
423         0)
424                 if ! upstream_name=$(git rev-parse --symbolic-full-name \
425                         --verify -q @{upstream} 2>/dev/null)
426                 then
427                         . git-parse-remote
428                         error_on_missing_default_upstream "rebase" "rebase" \
429                                 "against" "git rebase <branch>"
430                 fi
431                 ;;
432         *)      upstream_name="$1"
433                 shift
434                 ;;
435         esac
436         upstream=$(peel_committish "${upstream_name}") ||
437         die "$(eval_gettext "invalid upstream \$upstream_name")"
438         upstream_arg="$upstream_name"
439 else
440         if test -z "$onto"
441         then
442                 empty_tree=`git hash-object -t tree /dev/null`
443                 onto=`git commit-tree $empty_tree </dev/null`
444                 squash_onto="$onto"
445         fi
446         unset upstream_name
447         unset upstream
448         test $# -gt 1 && usage
449         upstream_arg=--root
450 fi
451
452 # Make sure the branch to rebase onto is valid.
453 onto_name=${onto-"$upstream_name"}
454 case "$onto_name" in
455 *...*)
456         if      left=${onto_name%...*} right=${onto_name#*...} &&
457                 onto=$(git merge-base --all ${left:-HEAD} ${right:-HEAD})
458         then
459                 case "$onto" in
460                 ?*"$LF"?*)
461                         die "$(eval_gettext "\$onto_name: there are more than one merge bases")"
462                         ;;
463                 '')
464                         die "$(eval_gettext "\$onto_name: there is no merge base")"
465                         ;;
466                 esac
467         else
468                 die "$(eval_gettext "\$onto_name: there is no merge base")"
469         fi
470         ;;
471 *)
472         onto=$(peel_committish "$onto_name") ||
473         die "$(eval_gettext "Does not point to a valid commit: \$onto_name")"
474         ;;
475 esac
476
477 # If the branch to rebase is given, that is the branch we will rebase
478 # $branch_name -- branch being rebased, or HEAD (already detached)
479 # $orig_head -- commit object name of tip of the branch before rebasing
480 # $head_name -- refs/heads/<that-branch> or "detached HEAD"
481 switch_to=
482 case "$#" in
483 1)
484         # Is it "rebase other $branchname" or "rebase other $commit"?
485         branch_name="$1"
486         switch_to="$1"
487
488         if git show-ref --verify --quiet -- "refs/heads/$1" &&
489            orig_head=$(git rev-parse -q --verify "refs/heads/$1")
490         then
491                 head_name="refs/heads/$1"
492         elif orig_head=$(git rev-parse -q --verify "$1")
493         then
494                 head_name="detached HEAD"
495         else
496                 die "$(eval_gettext "fatal: no such branch: \$branch_name")"
497         fi
498         ;;
499 0)
500         # Do not need to switch branches, we are already on it.
501         if branch_name=`git symbolic-ref -q HEAD`
502         then
503                 head_name=$branch_name
504                 branch_name=`expr "z$branch_name" : 'zrefs/heads/\(.*\)'`
505         else
506                 head_name="detached HEAD"
507                 branch_name=HEAD ;# detached
508         fi
509         orig_head=$(git rev-parse --verify HEAD) || exit
510         ;;
511 *)
512         die "BUG: unexpected number of arguments left to parse"
513         ;;
514 esac
515
516 if test "$autostash" = true && ! (require_clean_work_tree) 2>/dev/null
517 then
518         stash_sha1=$(git stash create "autostash") ||
519         die "$(gettext 'Cannot autostash')"
520
521         mkdir -p "$state_dir" &&
522         echo $stash_sha1 >"$state_dir/autostash" &&
523         stash_abbrev=$(git rev-parse --short $stash_sha1) &&
524         echo "$(eval_gettext 'Created autostash: $stash_abbrev')" &&
525         git reset --hard
526 fi
527
528 require_clean_work_tree "rebase" "$(gettext "Please commit or stash them.")"
529
530 # Now we are rebasing commits $upstream..$orig_head (or with --root,
531 # everything leading up to $orig_head) on top of $onto
532
533 # Check if we are already based on $onto with linear history,
534 # but this should be done only when upstream and onto are the same
535 # and if this is not an interactive rebase.
536 mb=$(git merge-base "$onto" "$orig_head")
537 if test "$type" != interactive && test "$upstream" = "$onto" &&
538         test "$mb" = "$onto" &&
539         # linear history?
540         ! (git rev-list --parents "$onto".."$orig_head" | sane_grep " .* ") > /dev/null
541 then
542         if test -z "$force_rebase"
543         then
544                 # Lazily switch to the target branch if needed...
545                 test -z "$switch_to" || git checkout "$switch_to" --
546                 say "$(eval_gettext "Current branch \$branch_name is up to date.")"
547                 finish_rebase
548                 exit 0
549         else
550                 say "$(eval_gettext "Current branch \$branch_name is up to date, rebase forced.")"
551         fi
552 fi
553
554 # If a hook exists, give it a chance to interrupt
555 run_pre_rebase_hook "$upstream_arg" "$@"
556
557 if test -n "$diffstat"
558 then
559         if test -n "$verbose"
560         then
561                 echo "$(eval_gettext "Changes from \$mb to \$onto:")"
562         fi
563         # We want color (if set), but no pager
564         GIT_PAGER='' git diff --stat --summary "$mb" "$onto"
565 fi
566
567 test "$type" = interactive && run_specific_rebase
568
569 # Detach HEAD and reset the tree
570 say "$(gettext "First, rewinding head to replay your work on top of it...")"
571 git checkout -q "$onto^0" || die "could not detach HEAD"
572 git update-ref ORIG_HEAD $orig_head
573
574 # If the $onto is a proper descendant of the tip of the branch, then
575 # we just fast-forwarded.
576 if test "$mb" = "$orig_head"
577 then
578         say "$(eval_gettext "Fast-forwarded \$branch_name to \$onto_name.")"
579         move_to_original_branch
580         finish_rebase
581         exit 0
582 fi
583
584 if test -n "$rebase_root"
585 then
586         revisions="$onto..$orig_head"
587 else
588         revisions="$upstream..$orig_head"
589 fi
590
591 run_specific_rebase