93289c050a49c0d5074659fc770683fd01bfbcba
1#!/bin/sh
2#
3# Copyright (c) 2006 Johannes E. Schindelin
4# SHORT DESCRIPTION
6#
7# This script makes it easy to fix up commits in the middle of a series,
8# and rearrange commits.
9#
10# The original idea comes from Eric W. Biederman, in
11# http://article.gmane.org/gmane.comp.version-control.git/22407
12USAGE='(--continue | --abort | --skip | [--preserve-merges] [--verbose]
14 [--onto <branch>] <upstream> [<branch>])'
15. git-sh-setup
17require_work_tree
18DOTEST="$GIT_DIR/.dotest-merge"
20TODO="$DOTEST"/todo
21DONE="$DOTEST"/done
22MSG="$DOTEST"/message
23SQUASH_MSG="$DOTEST"/message-squash
24REWRITTEN="$DOTEST"/rewritten
25PRESERVE_MERGES=
26STRATEGY=
27VERBOSE=
28test -d "$REWRITTEN" && PRESERVE_MERGES=t
29test -f "$DOTEST"/strategy && STRATEGY="$(cat "$DOTEST"/strategy)"
30test -f "$DOTEST"/verbose && VERBOSE=t
31warn () {
33 echo "$*" >&2
34}
35output () {
37 case "$VERBOSE" in
38 '')
39 "$@" > "$DOTEST"/output 2>&1
40 status=$?
41 test $status != 0 &&
42 cat "$DOTEST"/output
43 return $status
44 ;;
45 *)
46 "$@"
47 esac
48}
49require_clean_work_tree () {
51 # test if working tree is dirty
52 git rev-parse --verify HEAD > /dev/null &&
53 git update-index --refresh &&
54 git diff-files --quiet &&
55 git diff-index --cached --quiet HEAD ||
56 die "Working tree is dirty"
57}
58ORIG_REFLOG_ACTION="$GIT_REFLOG_ACTION"
60comment_for_reflog () {
62 case "$ORIG_REFLOG_ACTION" in
63 ''|rebase*)
64 GIT_REFLOG_ACTION="rebase -i ($1)"
65 export GIT_REFLOG_ACTION
66 esac
67}
68mark_action_done () {
70 sed -e 1q < "$TODO" >> "$DONE"
71 sed -e 1d < "$TODO" >> "$TODO".new
72 mv -f "$TODO".new "$TODO"
73 count=$(($(wc -l < "$DONE")))
74 total=$(($count+$(wc -l < "$TODO")))
75 printf "Rebasing (%d/%d)\r" $count $total
76 test -z "$VERBOSE" || echo
77}
78make_patch () {
80 parent_sha1=$(git rev-parse --verify "$1"^ 2> /dev/null)
81 git diff "$parent_sha1".."$1" > "$DOTEST"/patch
82}
83die_with_patch () {
85 test -f "$DOTEST"/message ||
86 git cat-file commit $sha1 | sed "1,/^$/d" > "$DOTEST"/message
87 test -f "$DOTEST"/author-script ||
88 get_author_ident_from_commit $sha1 > "$DOTEST"/author-script
89 make_patch "$1"
90 die "$2"
91}
92die_abort () {
94 rm -rf "$DOTEST"
95 die "$1"
96}
97pick_one () {
99 case "$1" in -n) sha1=$2 ;; *) sha1=$1 ;; esac
100 output git rev-parse --verify $sha1 || die "Invalid commit name: $sha1"
101 test -d "$REWRITTEN" &&
102 pick_one_preserving_merges "$@" && return
103 parent_sha1=$(git rev-parse --verify $sha1^ 2>/dev/null)
104 current_sha1=$(git rev-parse --verify HEAD)
105 if test $current_sha1 = $parent_sha1; then
106 output git reset --hard $sha1
107 test "a$1" = a-n && output git reset --soft $current_sha1
108 sha1=$(git rev-parse --short $sha1)
109 output warn Fast forward to $sha1
110 else
111 output git cherry-pick $STRATEGY "$@"
112 fi
113}
114pick_one_preserving_merges () {
116 case "$1" in -n) sha1=$2 ;; *) sha1=$1 ;; esac
117 sha1=$(git rev-parse $sha1)
118 if test -f "$DOTEST"/current-commit
120 then
121 current_commit=$(cat "$DOTEST"/current-commit) &&
122 git rev-parse HEAD > "$REWRITTEN"/$current_commit &&
123 rm "$DOTEST"/current-commit ||
124 die "Cannot write current commit's replacement sha1"
125 fi
126 # rewrite parents; if none were rewritten, we can fast-forward.
128 fast_forward=t
129 preserve=t
130 new_parents=
131 for p in $(git rev-list --parents -1 $sha1 | cut -d\ -f2-)
132 do
133 if test -f "$REWRITTEN"/$p
134 then
135 preserve=f
136 new_p=$(cat "$REWRITTEN"/$p)
137 test $p != $new_p && fast_forward=f
138 case "$new_parents" in
139 *$new_p*)
140 ;; # do nothing; that parent is already there
141 *)
142 new_parents="$new_parents $new_p"
143 esac
144 fi
145 done
146 case $fast_forward in
147 t)
148 output warn "Fast forward to $sha1"
149 test $preserve=f && echo $sha1 > "$REWRITTEN"/$sha1
150 ;;
151 f)
152 test "a$1" = a-n && die "Refusing to squash a merge: $sha1"
153 first_parent=$(expr "$new_parents" : " \([^ ]*\)")
155 # detach HEAD to current parent
156 output git checkout $first_parent 2> /dev/null ||
157 die "Cannot move HEAD to $first_parent"
158 echo $sha1 > "$DOTEST"/current-commit
160 case "$new_parents" in
161 \ *\ *)
162 # redo merge
163 author_script=$(get_author_ident_from_commit $sha1)
164 eval "$author_script"
165 msg="$(git cat-file commit $sha1 | \
166 sed -e '1,/^$/d' -e "s/[\"\\]/\\\\&/g")"
167 # NEEDSWORK: give rerere a chance
168 if ! output git merge $STRATEGY -m "$msg" $new_parents
169 then
170 echo "$msg" > "$GIT_DIR"/MERGE_MSG
171 die Error redoing merge $sha1
172 fi
173 ;;
174 *)
175 output git cherry-pick $STRATEGY "$@" ||
176 die_with_patch $sha1 "Could not pick $sha1"
177 esac
178 esac
179}
180nth_string () {
182 case "$1" in
183 *1[0-9]|*[04-9]) echo "$1"th;;
184 *1) echo "$1"st;;
185 *2) echo "$1"nd;;
186 *3) echo "$1"rd;;
187 esac
188}
189make_squash_message () {
191 if test -f "$SQUASH_MSG"; then
192 COUNT=$(($(sed -n "s/^# This is [^0-9]*\([0-9]\+\).*/\1/p" \
193 < "$SQUASH_MSG" | tail -n 1)+1))
194 echo "# This is a combination of $COUNT commits."
195 sed -n "2,\$p" < "$SQUASH_MSG"
196 else
197 COUNT=2
198 echo "# This is a combination of two commits."
199 echo "# The first commit's message is:"
200 echo
201 git cat-file commit HEAD | sed -e '1,/^$/d'
202 echo
203 fi
204 echo "# This is the $(nth_string $COUNT) commit message:"
205 echo
206 git cat-file commit $1 | sed -e '1,/^$/d'
207}
208peek_next_command () {
210 sed -n "1s/ .*$//p" < "$TODO"
211}
212do_next () {
214 test -f "$DOTEST"/message && rm "$DOTEST"/message
215 test -f "$DOTEST"/author-script && rm "$DOTEST"/author-script
216 read command sha1 rest < "$TODO"
217 case "$command" in
218 \#|'')
219 mark_action_done
220 ;;
221 pick)
222 comment_for_reflog pick
223 mark_action_done
225 pick_one $sha1 ||
226 die_with_patch $sha1 "Could not apply $sha1... $rest"
227 ;;
228 edit)
229 comment_for_reflog edit
230 mark_action_done
232 pick_one $sha1 ||
233 die_with_patch $sha1 "Could not apply $sha1... $rest"
234 make_patch $sha1
235 warn
236 warn "You can amend the commit now, with"
237 warn
238 warn " git commit --amend"
239 warn
240 exit 0
241 ;;
242 squash)
243 comment_for_reflog squash
244 test -z "$(grep -ve '^$' -e '^#' < $DONE)" &&
246 die "Cannot 'squash' without a previous commit"
247 mark_action_done
249 make_squash_message $sha1 > "$MSG"
250 case "$(peek_next_command)" in
251 squash)
252 EDIT_COMMIT=
253 cp "$MSG" "$SQUASH_MSG"
254 ;;
255 *)
256 EDIT_COMMIT=-e
257 test -f "$SQUASH_MSG" && rm "$SQUASH_MSG"
258 esac
259 failed=f
261 pick_one -n $sha1 || failed=t
262 output git reset --soft HEAD^
263 author_script=$(get_author_ident_from_commit $sha1)
264 echo "$author_script" > "$DOTEST"/author-script
265 case $failed in
266 f)
267 # This is like --amend, but with a different message
268 eval "$author_script"
269 export GIT_AUTHOR_NAME GIT_AUTHOR_EMAIL GIT_AUTHOR_DATE
270 output git commit -F "$MSG" $EDIT_COMMIT
271 ;;
272 t)
273 cp "$MSG" "$GIT_DIR"/MERGE_MSG
274 warn
275 warn "Could not apply $sha1... $rest"
276 die_with_patch $sha1 ""
277 esac
278 ;;
279 *)
280 warn "Unknown command: $command $sha1 $rest"
281 die_with_patch $sha1 "Please fix this in the file $TODO."
282 esac
283 test -s "$TODO" && return
284 comment_for_reflog finish &&
286 HEADNAME=$(cat "$DOTEST"/head-name) &&
287 OLDHEAD=$(cat "$DOTEST"/head) &&
288 SHORTONTO=$(git rev-parse --short $(cat "$DOTEST"/onto)) &&
289 if test -d "$REWRITTEN"
290 then
291 test -f "$DOTEST"/current-commit &&
292 current_commit=$(cat "$DOTEST"/current-commit) &&
293 git rev-parse HEAD > "$REWRITTEN"/$current_commit
294 NEWHEAD=$(cat "$REWRITTEN"/$OLDHEAD)
295 else
296 NEWHEAD=$(git rev-parse HEAD)
297 fi &&
298 message="$GIT_REFLOG_ACTION: $HEADNAME onto $SHORTONTO)" &&
299 git update-ref -m "$message" $HEADNAME $NEWHEAD $OLDHEAD &&
300 git symbolic-ref HEAD $HEADNAME && {
301 test ! -f "$DOTEST"/verbose ||
302 git diff --stat $(cat "$DOTEST"/head)..HEAD
303 } &&
304 rm -rf "$DOTEST" &&
305 warn "Successfully rebased and updated $HEADNAME."
306 exit
308}
309do_rest () {
311 while :
312 do
313 do_next
314 done
315}
316while case $# in 0) break ;; esac
318do
319 case "$1" in
320 --continue)
321 comment_for_reflog continue
322 test -d "$DOTEST" || die "No interactive rebase running"
324 # commit if necessary
326 git rev-parse --verify HEAD > /dev/null &&
327 git update-index --refresh &&
328 git diff-files --quiet &&
329 ! git diff-index --cached --quiet HEAD &&
330 . "$DOTEST"/author-script &&
331 export GIT_AUTHOR_NAME GIT_AUTHOR_NAME GIT_AUTHOR_DATE &&
332 git commit -F "$DOTEST"/message -e
333 require_clean_work_tree
335 do_rest
336 ;;
337 --abort)
338 comment_for_reflog abort
339 test -d "$DOTEST" || die "No interactive rebase running"
341 HEADNAME=$(cat "$DOTEST"/head-name)
343 HEAD=$(cat "$DOTEST"/head)
344 git symbolic-ref HEAD $HEADNAME &&
345 output git reset --hard $HEAD &&
346 rm -rf "$DOTEST"
347 exit
348 ;;
349 --skip)
350 comment_for_reflog skip
351 test -d "$DOTEST" || die "No interactive rebase running"
353 output git reset --hard && do_rest
355 ;;
356 -s|--strategy)
357 shift
358 case "$#,$1" in
359 *,*=*)
360 STRATEGY="-s `expr "z$1" : 'z-[^=]*=\(.*\)'`" ;;
361 1,*)
362 usage ;;
363 *)
364 STRATEGY="-s $2"
365 shift ;;
366 esac
367 ;;
368 --merge)
369 # we use merge anyway
370 ;;
371 -C*)
372 die "Interactive rebase uses merge, so $1 does not make sense"
373 ;;
374 -v|--verbose)
375 VERBOSE=t
376 ;;
377 -p|--preserve-merges)
378 PRESERVE_MERGES=t
379 ;;
380 -i|--interactive)
381 # yeah, we know
382 ;;
383 ''|-h)
384 usage
385 ;;
386 *)
387 test -d "$DOTEST" &&
388 die "Interactive rebase already started"
389 git var GIT_COMMITTER_IDENT >/dev/null ||
391 die "You need to set your committer info first"
392 comment_for_reflog start
394 ONTO=
396 case "$1" in
397 --onto)
398 ONTO=$(git rev-parse --verify "$2") ||
399 die "Does not point to a valid commit: $2"
400 shift; shift
401 ;;
402 esac
403 require_clean_work_tree
405 if test ! -z "$2"
407 then
408 output git show-ref --verify --quiet "refs/heads/$2" ||
409 die "Invalid branchname: $2"
410 output git checkout "$2" ||
411 die "Could not checkout $2"
412 fi
413 HEAD=$(git rev-parse --verify HEAD) || die "No HEAD?"
415 UPSTREAM=$(git rev-parse --verify "$1") || die "Invalid base"
416 test -z "$ONTO" && ONTO=$UPSTREAM
418 mkdir "$DOTEST" || die "Could not create temporary $DOTEST"
420 : > "$DOTEST"/interactive || die "Could not mark as interactive"
421 git symbolic-ref HEAD > "$DOTEST"/head-name ||
422 die "Could not get HEAD"
423 echo $HEAD > "$DOTEST"/head
425 echo $UPSTREAM > "$DOTEST"/upstream
426 echo $ONTO > "$DOTEST"/onto
427 test -z "$STRATEGY" || echo "$STRATEGY" > "$DOTEST"/strategy
428 test t = "$VERBOSE" && : > "$DOTEST"/verbose
429 if test t = "$PRESERVE_MERGES"
430 then
431 # $REWRITTEN contains files for each commit that is
432 # reachable by at least one merge base of $HEAD and
433 # $UPSTREAM. They are not necessarily rewritten, but
434 # their children might be.
435 # This ensures that commits on merged, but otherwise
436 # unrelated side branches are left alone. (Think "X"
437 # in the man page's example.)
438 mkdir "$REWRITTEN" &&
439 for c in $(git merge-base --all $HEAD $UPSTREAM)
440 do
441 echo $ONTO > "$REWRITTEN"/$c ||
442 die "Could not init rewritten commits"
443 done
444 MERGES_OPTION=
445 else
446 MERGES_OPTION=--no-merges
447 fi
448 SHORTUPSTREAM=$(git rev-parse --short $UPSTREAM)
450 SHORTHEAD=$(git rev-parse --short $HEAD)
451 SHORTONTO=$(git rev-parse --short $ONTO)
452 cat > "$TODO" << EOF
453# Rebasing $SHORTUPSTREAM..$SHORTHEAD onto $SHORTONTO
454#
455# Commands:
456# pick = use commit
457# edit = use commit, but stop for amending
458# squash = use commit, but meld into previous commit
459#
460# If you remove a line here THAT COMMIT WILL BE LOST.
461#
462EOF
463 git rev-list $MERGES_OPTION --pretty=oneline --abbrev-commit \
464 --abbrev=7 --reverse $UPSTREAM..$HEAD | \
465 sed "s/^/pick /" >> "$TODO"
466 test -z "$(grep -ve '^$' -e '^#' < $TODO)" &&
468 die_abort "Nothing to do"
469 cp "$TODO" "$TODO".backup
471 git_editor "$TODO" ||
472 die "Could not execute editor"
473 test -z "$(grep -ve '^$' -e '^#' < $TODO)" &&
475 die_abort "Nothing to do"
476 output git checkout $ONTO && do_rest
478 esac
479 shift
480done