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