Merge branch 'js/remote-improvements'
[git] / git-rebase.sh
1 #!/bin/sh
2 #
3 # Copyright (c) 2005 Junio C Hamano.
4 #
5
6 USAGE='[--interactive | -i] [-v] [--force-rebase | -f] [--onto <newbase>] [<upstream>|--root] [<branch>]'
7 LONG_USAGE='git-rebase replaces <branch> with a new branch of the
8 same name.  When the --onto option is provided the new branch starts
9 out with a HEAD equal to <newbase>, otherwise it is equal to <upstream>
10 It then attempts to create a new commit for each commit from the original
11 <branch> that does not exist in the <upstream> branch.
12
13 It is possible that a merge failure will prevent this process from being
14 completely automatic.  You will have to resolve any such merge failure
15 and run git rebase --continue.  Another option is to bypass the commit
16 that caused the merge failure with git rebase --skip.  To restore the
17 original <branch> and remove the .git/rebase-apply working files, use the
18 command git rebase --abort instead.
19
20 Note that if <branch> is not specified on the command line, the
21 currently checked out branch is used.
22
23 Example:       git-rebase master~1 topic
24
25         A---B---C topic                   A'\''--B'\''--C'\'' topic
26        /                   -->           /
27   D---E---F---G master          D---E---F---G master
28 '
29
30 SUBDIRECTORY_OK=Yes
31 OPTIONS_SPEC=
32 . git-sh-setup
33 set_reflog_action rebase
34 require_work_tree
35 cd_to_toplevel
36
37 OK_TO_SKIP_PRE_REBASE=
38 RESOLVEMSG="
39 When you have resolved this problem run \"git rebase --continue\".
40 If you would prefer to skip this patch, instead run \"git rebase --skip\".
41 To restore the original branch and stop rebasing run \"git rebase --abort\".
42 "
43 unset newbase
44 strategy=recursive
45 do_merge=
46 dotest="$GIT_DIR"/rebase-merge
47 prec=4
48 verbose=
49 diffstat=$(git config --bool rebase.stat)
50 git_am_opt=
51 rebase_root=
52 force_rebase=
53
54 continue_merge () {
55         test -n "$prev_head" || die "prev_head must be defined"
56         test -d "$dotest" || die "$dotest directory does not exist"
57
58         unmerged=$(git ls-files -u)
59         if test -n "$unmerged"
60         then
61                 echo "You still have unmerged paths in your index"
62                 echo "did you forget to use git add?"
63                 die "$RESOLVEMSG"
64         fi
65
66         cmt=`cat "$dotest/current"`
67         if ! git diff-index --quiet --ignore-submodules HEAD --
68         then
69                 if ! git commit --no-verify -C "$cmt"
70                 then
71                         echo "Commit failed, please do not call \"git commit\""
72                         echo "directly, but instead do one of the following: "
73                         die "$RESOLVEMSG"
74                 fi
75                 printf "Committed: %0${prec}d " $msgnum
76         else
77                 printf "Already applied: %0${prec}d " $msgnum
78         fi
79         git rev-list --pretty=oneline -1 "$cmt" | sed -e 's/^[^ ]* //'
80
81         prev_head=`git rev-parse HEAD^0`
82         # save the resulting commit so we can read-tree on it later
83         echo "$prev_head" > "$dotest/prev_head"
84
85         # onto the next patch:
86         msgnum=$(($msgnum + 1))
87         echo "$msgnum" >"$dotest/msgnum"
88 }
89
90 call_merge () {
91         cmt="$(cat "$dotest/cmt.$1")"
92         echo "$cmt" > "$dotest/current"
93         hd=$(git rev-parse --verify HEAD)
94         cmt_name=$(git symbolic-ref HEAD 2> /dev/null || echo HEAD)
95         msgnum=$(cat "$dotest/msgnum")
96         end=$(cat "$dotest/end")
97         eval GITHEAD_$cmt='"${cmt_name##refs/heads/}~$(($end - $msgnum))"'
98         eval GITHEAD_$hd='$(cat "$dotest/onto_name")'
99         export GITHEAD_$cmt GITHEAD_$hd
100         git-merge-$strategy "$cmt^" -- "$hd" "$cmt"
101         rv=$?
102         case "$rv" in
103         0)
104                 unset GITHEAD_$cmt GITHEAD_$hd
105                 return
106                 ;;
107         1)
108                 git rerere
109                 die "$RESOLVEMSG"
110                 ;;
111         2)
112                 echo "Strategy: $rv $strategy failed, try another" 1>&2
113                 die "$RESOLVEMSG"
114                 ;;
115         *)
116                 die "Unknown exit code ($rv) from command:" \
117                         "git-merge-$strategy $cmt^ -- HEAD $cmt"
118                 ;;
119         esac
120 }
121
122 move_to_original_branch () {
123         test -z "$head_name" &&
124                 head_name="$(cat "$dotest"/head-name)" &&
125                 onto="$(cat "$dotest"/onto)" &&
126                 orig_head="$(cat "$dotest"/orig-head)"
127         case "$head_name" in
128         refs/*)
129                 message="rebase finished: $head_name onto $onto"
130                 git update-ref -m "$message" \
131                         $head_name $(git rev-parse HEAD) $orig_head &&
132                 git symbolic-ref HEAD $head_name ||
133                 die "Could not move back to $head_name"
134                 ;;
135         esac
136 }
137
138 finish_rb_merge () {
139         move_to_original_branch
140         rm -r "$dotest"
141         echo "All done."
142 }
143
144 is_interactive () {
145         while test $# != 0
146         do
147                 case "$1" in
148                         -i|--interactive)
149                                 interactive_rebase=explicit
150                                 break
151                         ;;
152                         -p|--preserve-merges)
153                                 interactive_rebase=implied
154                         ;;
155                 esac
156                 shift
157         done
158
159         if [ "$interactive_rebase" = implied ]; then
160                 GIT_EDITOR=:
161                 export GIT_EDITOR
162         fi
163
164         test -n "$interactive_rebase" || test -f "$dotest"/interactive
165 }
166
167 run_pre_rebase_hook () {
168         if test -z "$OK_TO_SKIP_PRE_REBASE" &&
169            test -x "$GIT_DIR/hooks/pre-rebase"
170         then
171                 "$GIT_DIR/hooks/pre-rebase" ${1+"$@"} || {
172                         echo >&2 "The pre-rebase hook refused to rebase."
173                         exit 1
174                 }
175         fi
176 }
177
178 test -f "$GIT_DIR"/rebase-apply/applying &&
179         die 'It looks like git-am is in progress. Cannot rebase.'
180
181 is_interactive "$@" && exec git-rebase--interactive "$@"
182
183 if test $# -eq 0
184 then
185         test -d "$dotest" -o -d "$GIT_DIR"/rebase-apply || usage
186         test -d "$dotest" -o -f "$GIT_DIR"/rebase-apply/rebasing &&
187                 die 'A rebase is in progress, try --continue, --skip or --abort.'
188         die "No arguments given and $GIT_DIR/rebase-apply already exists."
189 fi
190
191 while test $# != 0
192 do
193         case "$1" in
194         --no-verify)
195                 OK_TO_SKIP_PRE_REBASE=yes
196                 ;;
197         --continue)
198                 test -d "$dotest" -o -d "$GIT_DIR"/rebase-apply ||
199                         die "No rebase in progress?"
200
201                 git diff-files --quiet --ignore-submodules || {
202                         echo "You must edit all merge conflicts and then"
203                         echo "mark them as resolved using git add"
204                         exit 1
205                 }
206                 if test -d "$dotest"
207                 then
208                         prev_head=$(cat "$dotest/prev_head")
209                         end=$(cat "$dotest/end")
210                         msgnum=$(cat "$dotest/msgnum")
211                         onto=$(cat "$dotest/onto")
212                         continue_merge
213                         while test "$msgnum" -le "$end"
214                         do
215                                 call_merge "$msgnum"
216                                 continue_merge
217                         done
218                         finish_rb_merge
219                         exit
220                 fi
221                 head_name=$(cat "$GIT_DIR"/rebase-apply/head-name) &&
222                 onto=$(cat "$GIT_DIR"/rebase-apply/onto) &&
223                 orig_head=$(cat "$GIT_DIR"/rebase-apply/orig-head) &&
224                 git am --resolved --3way --resolvemsg="$RESOLVEMSG" &&
225                 move_to_original_branch
226                 exit
227                 ;;
228         --skip)
229                 test -d "$dotest" -o -d "$GIT_DIR"/rebase-apply ||
230                         die "No rebase in progress?"
231
232                 git reset --hard HEAD || exit $?
233                 if test -d "$dotest"
234                 then
235                         git rerere clear
236                         prev_head=$(cat "$dotest/prev_head")
237                         end=$(cat "$dotest/end")
238                         msgnum=$(cat "$dotest/msgnum")
239                         msgnum=$(($msgnum + 1))
240                         onto=$(cat "$dotest/onto")
241                         while test "$msgnum" -le "$end"
242                         do
243                                 call_merge "$msgnum"
244                                 continue_merge
245                         done
246                         finish_rb_merge
247                         exit
248                 fi
249                 head_name=$(cat "$GIT_DIR"/rebase-apply/head-name) &&
250                 onto=$(cat "$GIT_DIR"/rebase-apply/onto) &&
251                 orig_head=$(cat "$GIT_DIR"/rebase-apply/orig-head) &&
252                 git am -3 --skip --resolvemsg="$RESOLVEMSG" &&
253                 move_to_original_branch
254                 exit
255                 ;;
256         --abort)
257                 test -d "$dotest" -o -d "$GIT_DIR"/rebase-apply ||
258                         die "No rebase in progress?"
259
260                 git rerere clear
261                 if test -d "$dotest"
262                 then
263                         move_to_original_branch
264                 else
265                         dotest="$GIT_DIR"/rebase-apply
266                         move_to_original_branch
267                 fi
268                 git reset --hard $(cat "$dotest/orig-head")
269                 rm -r "$dotest"
270                 exit
271                 ;;
272         --onto)
273                 test 2 -le "$#" || usage
274                 newbase="$2"
275                 shift
276                 ;;
277         -M|-m|--m|--me|--mer|--merg|--merge)
278                 do_merge=t
279                 ;;
280         -s=*|--s=*|--st=*|--str=*|--stra=*|--strat=*|--strate=*|\
281                 --strateg=*|--strategy=*|\
282         -s|--s|--st|--str|--stra|--strat|--strate|--strateg|--strategy)
283                 case "$#,$1" in
284                 *,*=*)
285                         strategy=`expr "z$1" : 'z-[^=]*=\(.*\)'` ;;
286                 1,*)
287                         usage ;;
288                 *)
289                         strategy="$2"
290                         shift ;;
291                 esac
292                 do_merge=t
293                 ;;
294         -n|--no-stat)
295                 diffstat=
296                 ;;
297         --stat)
298                 diffstat=t
299                 ;;
300         -v|--verbose)
301                 verbose=t
302                 diffstat=t
303                 ;;
304         --whitespace=*)
305                 git_am_opt="$git_am_opt $1"
306                 case "$1" in
307                 --whitespace=fix|--whitespace=strip)
308                         force_rebase=t
309                         ;;
310                 esac
311                 ;;
312         -C*)
313                 git_am_opt="$git_am_opt $1"
314                 ;;
315         --root)
316                 rebase_root=t
317                 ;;
318         -f|--f|--fo|--for|--forc|force|--force-r|--force-re|--force-reb|--force-reba|--force_rebas|--force-rebase)
319                 force_rebase=t
320                 ;;
321         -*)
322                 usage
323                 ;;
324         *)
325                 break
326                 ;;
327         esac
328         shift
329 done
330 test $# -gt 2 && usage
331
332 # Make sure we do not have $GIT_DIR/rebase-apply
333 if test -z "$do_merge"
334 then
335         if mkdir "$GIT_DIR"/rebase-apply 2>/dev/null
336         then
337                 rmdir "$GIT_DIR"/rebase-apply
338         else
339                 echo >&2 '
340 It seems that I cannot create a rebase-apply directory, and
341 I wonder if you are in the middle of patch application or another
342 rebase.  If that is not the case, please
343         rm -fr '"$GIT_DIR"'/rebase-apply
344 and run me again.  I am stopping in case you still have something
345 valuable there.'
346                 exit 1
347         fi
348 else
349         if test -d "$dotest"
350         then
351                 die "previous rebase directory $dotest still exists." \
352                         'Try git rebase (--continue | --abort | --skip)'
353         fi
354 fi
355
356 # The tree must be really really clean.
357 if ! git update-index --ignore-submodules --refresh; then
358         echo >&2 "cannot rebase: you have unstaged changes"
359         exit 1
360 fi
361 diff=$(git diff-index --cached --name-status -r --ignore-submodules HEAD --)
362 case "$diff" in
363 ?*)     echo >&2 "cannot rebase: your index contains uncommitted changes"
364         echo >&2 "$diff"
365         exit 1
366         ;;
367 esac
368
369 if test -z "$rebase_root"
370 then
371         # The upstream head must be given.  Make sure it is valid.
372         upstream_name="$1"
373         shift
374         upstream=`git rev-parse --verify "${upstream_name}^0"` ||
375         die "invalid upstream $upstream_name"
376         unset root_flag
377         upstream_arg="$upstream_name"
378 else
379         test -z "$newbase" && die "--root must be used with --onto"
380         unset upstream_name
381         unset upstream
382         root_flag="--root"
383         upstream_arg="$root_flag"
384 fi
385
386 # Make sure the branch to rebase onto is valid.
387 onto_name=${newbase-"$upstream_name"}
388 onto=$(git rev-parse --verify "${onto_name}^0") || exit
389
390 # If a hook exists, give it a chance to interrupt
391 run_pre_rebase_hook "$upstream_arg" "$@"
392
393 # If the branch to rebase is given, that is the branch we will rebase
394 # $branch_name -- branch being rebased, or HEAD (already detached)
395 # $orig_head -- commit object name of tip of the branch before rebasing
396 # $head_name -- refs/heads/<that-branch> or "detached HEAD"
397 switch_to=
398 case "$#" in
399 1)
400         # Is it "rebase other $branchname" or "rebase other $commit"?
401         branch_name="$1"
402         switch_to="$1"
403
404         if git show-ref --verify --quiet -- "refs/heads/$1" &&
405            branch=$(git rev-parse -q --verify "refs/heads/$1")
406         then
407                 head_name="refs/heads/$1"
408         elif branch=$(git rev-parse -q --verify "$1")
409         then
410                 head_name="detached HEAD"
411         else
412                 usage
413         fi
414         ;;
415 *)
416         # Do not need to switch branches, we are already on it.
417         if branch_name=`git symbolic-ref -q HEAD`
418         then
419                 head_name=$branch_name
420                 branch_name=`expr "z$branch_name" : 'zrefs/heads/\(.*\)'`
421         else
422                 head_name="detached HEAD"
423                 branch_name=HEAD ;# detached
424         fi
425         branch=$(git rev-parse --verify "${branch_name}^0") || exit
426         ;;
427 esac
428 orig_head=$branch
429
430 # Now we are rebasing commits $upstream..$branch (or with --root,
431 # everything leading up to $branch) on top of $onto
432
433 # Check if we are already based on $onto with linear history,
434 # but this should be done only when upstream and onto are the same.
435 mb=$(git merge-base "$onto" "$branch")
436 if test "$upstream" = "$onto" && test "$mb" = "$onto" &&
437         # linear history?
438         ! (git rev-list --parents "$onto".."$branch" | grep " .* ") > /dev/null
439 then
440         if test -z "$force_rebase"
441         then
442                 # Lazily switch to the target branch if needed...
443                 test -z "$switch_to" || git checkout "$switch_to"
444                 echo >&2 "Current branch $branch_name is up to date."
445                 exit 0
446         else
447                 echo "Current branch $branch_name is up to date, rebase forced."
448         fi
449 fi
450
451 # Detach HEAD and reset the tree
452 echo "First, rewinding head to replay your work on top of it..."
453 git checkout -q "$onto^0" || die "could not detach HEAD"
454 git update-ref ORIG_HEAD $branch
455
456 if test -n "$diffstat"
457 then
458         if test -n "$verbose"
459         then
460                 echo "Changes from $mb to $onto:"
461         fi
462         # We want color (if set), but no pager
463         GIT_PAGER='' git diff --stat --summary "$mb" "$onto"
464 fi
465
466 # If the $onto is a proper descendant of the tip of the branch, then
467 # we just fast forwarded.
468 if test "$mb" = "$branch"
469 then
470         echo >&2 "Fast-forwarded $branch_name to $onto_name."
471         move_to_original_branch
472         exit 0
473 fi
474
475 if test -n "$rebase_root"
476 then
477         revisions="$onto..$orig_head"
478 else
479         revisions="$upstream..$orig_head"
480 fi
481
482 if test -z "$do_merge"
483 then
484         git format-patch -k --stdout --full-index --ignore-if-in-upstream \
485                 $root_flag "$revisions" |
486         git am $git_am_opt --rebasing --resolvemsg="$RESOLVEMSG" &&
487         move_to_original_branch
488         ret=$?
489         test 0 != $ret -a -d "$GIT_DIR"/rebase-apply &&
490                 echo $head_name > "$GIT_DIR"/rebase-apply/head-name &&
491                 echo $onto > "$GIT_DIR"/rebase-apply/onto &&
492                 echo $orig_head > "$GIT_DIR"/rebase-apply/orig-head
493         exit $ret
494 fi
495
496 # start doing a rebase with git-merge
497 # this is rename-aware if the recursive (default) strategy is used
498
499 mkdir -p "$dotest"
500 echo "$onto" > "$dotest/onto"
501 echo "$onto_name" > "$dotest/onto_name"
502 prev_head=$orig_head
503 echo "$prev_head" > "$dotest/prev_head"
504 echo "$orig_head" > "$dotest/orig-head"
505 echo "$head_name" > "$dotest/head-name"
506
507 msgnum=0
508 for cmt in `git rev-list --reverse --no-merges "$revisions"`
509 do
510         msgnum=$(($msgnum + 1))
511         echo "$cmt" > "$dotest/cmt.$msgnum"
512 done
513
514 echo 1 >"$dotest/msgnum"
515 echo $msgnum >"$dotest/end"
516
517 end=$msgnum
518 msgnum=1
519
520 while test "$msgnum" -le "$end"
521 do
522         call_merge "$msgnum"
523         continue_merge
524 done
525
526 finish_rb_merge