guilt: replace "echo && return 1" with die
[guilt.git] / guilt
blob809ca1f9af5023cac210fa90e5ebdb249dc1f9a3
1 #!/bin/sh
3 # Copyright (c) Josef "Jeff" Sipek, 2006-2008
6 GUILT_VERSION="0.29"
7 GUILT_NAME="Bleecker Street"
9 # If the first argument is one of the below, display the man page instead of
10 # the rather silly and mostly useless usage string
11 case $1 in
12 -h|--h|--he|--hel|--help)
13 shift
14 exec "guilt-help" "`basename $0`"
15 exit
17 -V|--ver|--versi|--versio|--version)
18 echo "Guilt version $GUILT_VERSION"
19 exit
21 esac
23 # we change directories ourselves
24 SUBDIRECTORY_OK=1
26 . git-sh-setup
29 # Git version check
31 gitver=`git --version | cut -d' ' -f3`
32 case "$gitver" in
33 1.5.*) ;; # git config
34 *) die "Unsupported version of git ($gitver)" ;;
35 esac
38 # Shell library
41 # echo -e is a bashism, fallback to /bin/echo if the builtin does not supports it
42 echo()
44 /bin/echo "$@"
47 noerr()
49 "$@" 2>/dev/null
52 silent()
54 "$@" >/dev/null 2>/dev/null
57 ########
59 guilt_commands()
61 find "`dirname $0`" -maxdepth 1 -name "guilt-*" -type f -perm /111 | sed -e "s/.*\\/`basename $0`-//"
64 if [ "`basename $0`" = "guilt" ]; then
65 # being run as standalone
67 # by default, we shouldn't fail
68 cmd=
70 if [ $# -ne 0 ]; then
71 # take first arg, and try to execute it
73 arg="$1"
74 dir=`dirname $0`
76 if [ -x "$dir/guilt-$arg" ]; then
77 cmd=$arg
78 else
79 # might be a short handed
80 for command in $(guilt_commands); do
81 case $command in
82 $arg*)
83 if [ -x "$dir/guilt-$command" ]; then
84 cmd=$command
87 esac
88 done
90 if [ -n "$cmd" ]; then
91 shift
92 exec "$dir/guilt-$cmd" "$@"
94 # this is not reached because of the exec
95 die "Exec failed! Something is terribly wrong!"
96 else
97 echo "Command $arg not found" >&2
98 echo "" >&2
102 # no args passed or invalid command entered, just output help summary
104 echo "Guilt v$GUILT_VERSION"
105 echo ""
106 echo "Pick a command:"
107 guilt_commands | sort | column | column -t | sed -e 's/^/\t/'
109 echo ""
110 echo "Example:"
111 echo -e "\tguilt-push"
112 echo "or"
113 echo -e "\tguilt push"
115 # now, let's exit
116 exit 1
119 ########
122 # Library goodies
125 # usage: valid_patchname <patchname>
126 valid_patchname()
128 case "$1" in
129 /*|./*|../*|*/./*|*/../*|*/.|*/..|*/|*\ *|*\ *)
130 return 1;;
132 return 0;;
133 esac
136 get_branch()
138 git symbolic-ref HEAD | sed -e 's,^refs/heads/,,'
141 verify_branch()
143 [ ! -d "$GIT_DIR/patches" ] &&
144 die "Patches directory doesn't exist, try guilt-init"
145 [ ! -d "$GIT_DIR/patches/$branch" ] &&
146 die "Branch $branch is not initialized, try guilt-init"
147 [ ! -f "$GIT_DIR/patches/$branch/series" ] &&
148 die "Branch $branch does not have a series file"
149 [ ! -f "$GIT_DIR/patches/$branch/status" ] &&
150 die "Branch $branch does not have a status file"
151 [ -f "$GIT_DIR/patches/$branch/applied" ] &&
152 die "Warning: Branch $branch has 'applied' file - guilt is not compatible with stgit"
155 get_top()
157 tail -1 "$GUILT_DIR/$branch/status"
160 get_prev()
162 if [ `wc -l < "$GUILT_DIR/$branch/status"` -gt 1 ]; then
163 tail -n 2 "$GUILT_DIR/$branch/status" | head -n 1
167 get_series()
169 # ignore all lines matching:
170 # - empty lines
171 # - whitespace only
172 # - optional whitespace followed by '#' followed by more
173 # optional whitespace
174 grep -ve '^[[:space:]]*\(#.*\)*$' "$series"
177 # usage: do_make_header <hash>
178 do_make_header()
180 # we should try to work with commit objects only
181 if [ `git cat-file -t "$1"` != "commit" ]; then
182 echo "Hash $1 is not a commit object" >&2
183 echo "Aborting..." >&2
184 exit 2
187 git cat-file -p "$1" | awk '
188 BEGIN{headers=1; firstline=1}
189 /^author / && headers {
190 sub(/^author +/, "");
191 sub(/ [0-9]* [+-]*[0-9][0-9]*$/, "");
192 author=$0
194 !headers {
195 print
196 if (firstline) {
197 firstline = 0;
198 print "\nFrom: " author;
201 /^$/ && headers { headers = 0 }
205 # usage: do_get_patch patchfile
206 do_get_patch()
208 cat "$1" | awk '
209 BEGIN{}
210 /^(diff |---)/,/END{}/
214 # usage: do_get_header patchfile
215 do_get_header()
217 # The complexity arises from the fact that we want to ignore the
218 # From line and the empty line after it if it exists
220 # 2nd line skips the From line
221 # 3rd line skips the empty line right after a From line
222 # 4th line terminates execution when we encounter the diff
223 cat "$1" | awk '
224 BEGIN{skip=0}
225 /^Subject:/ && (NR==1){print substr($0, 10); next}
226 /^From:/{skip=1; next}
227 /^[ \t\f\n\r\v]*$/ && (skip==1){skip=0; next}
228 /^(diff |---)/{exit}
229 {print $0}
230 END{}
234 # usage: do_get_full_header patchfile
235 do_get_full_header()
237 # 2nd line checks for the begining of a patch
238 # 3rd line outputs the line if it didn't get pruned by the above rules
239 cat "$1" | awk '
240 BEGIN{}
241 /^(diff |---)/{exit}
242 {print $0}
243 END{}
247 # usage: assert_head_check
248 assert_head_check()
250 if ! head_check refs/patches/$branch/`get_top`; then
251 die "aborting..."
255 # usage: head_check <expected hash>
256 head_check()
258 # make sure we're not doing funky things to commits that don't
259 # belong to us
261 case "$1" in
263 # the expected hash is empty
264 return 0 ;;
265 refs/patches/$branch/)
266 # the expected hash is an invalid rev
267 return 0 ;;
268 esac
270 if [ "`git rev-parse refs/heads/$branch`" != "`git rev-parse $1`" ]; then
271 echo "Expected HEAD commit $1" >&2
272 echo " got `git rev-parse refs/heads/$branch`" >&2
273 return 1
275 return 0
278 # usage: series_insert_patch <patchname>
279 series_insert_patch()
281 awk -v top="`get_top`" -v new="$1" \
282 'BEGIN{if (top == "") print new;}
284 print $0;
285 if (top != "" && top == $0) print new;
286 }' "$series" > "$series.tmp"
287 mv "$series.tmp" "$series"
290 # usage: series_remove_patch <patchname>
291 series_remove_patch()
293 grep -v "^$1\$" < "$series" > "$series.tmp"
294 mv "$series.tmp" "$series"
297 # usage: series_rename_patch <oldname> <newname>
298 series_rename_patch()
300 awk -v old="$1" -v new="$2" \
301 '{ if ($0 == old) print new; else print $0 }' \
302 "$series" > "$series.tmp"
304 mv "$series.tmp" "$series"
307 # Beware! This is one of the few (only?) places where we modify the applied
308 # file directly
310 # usage: applied_rename_patch <oldname> <newname>
311 applied_rename_patch()
313 awk -v old="$1" -v new="$2" \
314 'BEGIN{FS=":"}
315 { if ($0 == old)
316 print new;
317 else
318 print;
319 }' "$applied" > "$applied.tmp"
321 mv "$applied.tmp" "$applied"
324 # usage: remove_patch_refs
325 # reads patch names from stdin
326 remove_patch_refs()
328 while read pname; do
329 git update-ref -d "refs/patches/$branch/$pname" `git rev-parse "refs/patches/$branch/$pname"`
330 done
333 # usage: pop_many_patches <commitish> <number of patches>
334 pop_many_patches()
336 assert_head_check
339 cd "$TOP_DIR"
341 # remove the patches refs
342 tail -$2 < "$applied" | remove_patch_refs
344 git reset --hard "$1" > /dev/null
345 head -n "-$2" < "$applied" > "$applied.tmp"
346 mv "$applied.tmp" "$applied"
349 # update references to top, bottom, and base
350 update_stack_tags
353 # usage: pop_all_patches
354 pop_all_patches()
356 pop_many_patches \
357 `git rev-parse refs/patches/$branch/$(head -1 "$applied")^` \
358 `wc -l < "$applied"`
361 # usage: update_stack_tags
362 update_stack_tags()
364 # bail if autotagging is not enabled
365 if [ $autotag -eq 0 ]; then
366 return 0
369 if [ -s "$applied" ]; then
370 # there are patches applied, therefore we must get the top,
371 # bottom and base hashes, and update the tags
373 git update-ref "refs/tags/${branch}_top" `git rev-parse HEAD`
374 git update-ref "refs/tags/${branch}_bottom" `git rev-parse refs/patches/$branch/$(head -1 < $applied)`
375 git update-ref "refs/tags/${branch}_base" `git rev-parse refs/patches/$branch/$(head -1 < $applied)^`
376 else
377 # there are no patches applied, therefore we must remove the
378 # tags to old top, bottom, and base
380 git update-ref -d "refs/tags/${branch}_top" \
381 `git rev-parse "refs/tags/${branch}_top"`
382 git update-ref -d "refs/tags/${branch}_bottom" \
383 `git rev-parse "refs/tags/${branch}_bottom"`
384 git update-ref -d "refs/tags/${branch}_base" \
385 `git rev-parse "refs/tags/${branch}_base"`
389 # usage: push_patch patchname [bail_action]
390 push_patch()
392 __push_patch_bail=0
395 TMP_LOG=`get_tmp_file log`
396 TMP_MSG=`get_tmp_file msg`
398 p="$GUILT_DIR/$branch/$1"
399 pname="$1"
400 bail_action="$2"
401 reject="--reject"
403 assert_head_check
404 cd "$TOP_DIR"
406 # apply the patch if and only if there is something to apply
407 if [ `git apply --numstat "$p" | wc -l` -gt 0 ]; then
408 if [ "$bail_action" = abort ]; then
409 reject=""
411 git apply -C$guilt_push_diff_context --index \
412 $reject "$p" > /dev/null 2> "$TMP_LOG"
413 __push_patch_bail=$?
415 if [ $__push_patch_bail -ne 0 ]; then
416 cat "$TMP_LOG" >&2
417 if [ "$bail_action" = "abort" ]; then
418 rm -f "$TMP_LOG" "$TMP_MSG"
419 return $__push_patch_bail
424 # grab a commit message out of the patch
425 do_get_header "$p" > "$TMP_MSG"
427 # make a default commit message if patch doesn't contain one
428 [ ! -s "$TMP_MSG" ] && echo "patch $pname" > "$TMP_MSG"
430 # extract a From line from the patch header, and set
431 # GIT_AUTHOR_{NAME,EMAIL}
432 author_str=`sed -n -e '/^From:/ { s/^From: //; p; q }; /^(diff |---)/ q' "$p"`
433 if [ ! -z "$author_str" ]; then
434 GIT_AUTHOR_NAME=`echo $author_str | sed -e 's/ *<.*$//'`
435 export GIT_AUTHOR_NAME="${GIT_AUTHOR_NAME:-" "}"
436 export GIT_AUTHOR_EMAIL="`echo $author_str | sed -e 's/[^<]*//'`"
439 # must strip nano-second part otherwise git gets very
440 # confused, and makes up strange timestamps from the past
441 # (chances are it decides to interpret it as a unix
442 # timestamp).
443 export GIT_AUTHOR_DATE="`stat -c %y "$p" | sed -e '
444 s/^\([0-9]\{4\}\)-\([0-9]\{2\}\)-\([0-9]\{2\}\) \([0-9]\{2\}\):\([0-9]\{2\}\):\([0-9]\{2\}\)\.[0-9]* \(.*\)$/\1-\2-\3 \4:\5:\6 \7/'`"
445 export GIT_COMMITTER_DATE="$GIT_AUTHOR_DATE"
447 # commit
448 treeish=`git write-tree`
449 commitish=`git commit-tree $treeish -p HEAD < "$TMP_MSG"`
450 git update-ref HEAD $commitish
452 # mark patch as applied
453 git update-ref "refs/patches/$branch/$pname" $commitish ""
455 echo "$pname" >> $applied
457 rm -f "$TMP_MSG" "$TMP_LOG"
460 # sub-shell funky-ness
461 __push_patch_bail=$?
463 # update references to top, bottom, and base of the stack
464 update_stack_tags
466 return $__push_patch_bail
469 # usage: must_commit_first
470 must_commit_first()
472 [ `git diff-files | wc -l` -eq 0 ]
473 return $?
476 # usage: fold_patch patchname
477 fold_patch()
479 set -- "$1" "`get_top`"
481 assert_head_check
483 push_patch "$1"
485 __refresh_patch "$2" HEAD^^ 2 "" ""
487 series_remove_patch "$1"
490 # usage: refresh_patch patchname gengitdiff incldiffstat
491 refresh_patch()
493 __refresh_patch "$1" HEAD^ 1 "$2" "$3"
496 # usage: __refresh_patch patchname commitish number_of_commits gengitdiff
497 # incldiffstat
498 __refresh_patch()
500 assert_head_check
503 TMP_DIFF=`get_tmp_file diff`
505 cd "$TOP_DIR"
506 p="$GUILT_DIR/$branch/$1"
508 git diff-files --name-only | (while read n; do git update-index "$n" ; done)
510 # get the patch header
511 do_get_full_header "$p" > "$TMP_DIFF"
513 [ ! -z "$4" ] && diffopts="-C -M --find-copies-harder"
515 if [ ! -z "$5" ]; then
517 echo "---"
518 git diff --stat $diffopts "$2"
519 echo ""
520 ) >> "$TMP_DIFF"
523 # get the new patch
524 git diff $diffopts "$2" >> "$TMP_DIFF"
526 # move the new patch in
527 mv "$p" "$p~"
528 mv "$TMP_DIFF" $p
531 # drop the currently applied patch, pop_many_patches does it's own
532 # cd $TOP_DIR
533 pop_many_patches "$2" "$3"
535 # push_patch does it's own cd $TOP_DIR
536 push_patch "$1"
539 # usage: munge_hash_range <hash range>
541 # this means:
542 # <hash> - one commit
543 # <hash>.. - hash until head (excludes hash, includes head)
544 # ..<hash> - until hash (includes hash)
545 # <hash1>..<hash2> - from hash to hash (inclusive)
547 # The output of this function is suitable to be passed to "git rev-list"
548 munge_hash_range()
550 case "$1" in
551 *..*..*|*\ *)
552 # double .. or space is illegal
553 return 1;;
554 ..*)
555 # e.g., "..v0.10"
556 echo ${1#..};;
557 *..)
558 # e.g., "v0.19.."
559 echo ${1%..}..HEAD;;
560 *..*)
561 # e.g., "v0.19-rc1..v0.19"
562 echo ${1%%..*}..${1#*..};;
564 # e.g., "v0.19"
565 echo $1^..$1;;
566 *) # empty
567 return 1;;
568 esac
569 return 0
572 # usage: get_tmp_file <prefix>
574 # Get a unique filename and create the file in a non-racy way
575 get_tmp_file()
577 while true; do
578 mktemp "/tmp/guilt.$1.XXXXXXXXXXXXXXX" && break
579 done
582 # usage: guilt_hook <hook name> <args....>
583 guilt_hook()
585 __hookname="$1"
586 [ ! -x "$GIT_DIR/hooks/guilt/$__hookname" ] && return 0
588 shift
590 "$GIT_DIR/hooks/guilt/$__hookname" "$@"
591 return $?
595 # Some constants
598 # used for: git apply -C <val>
599 guilt_push_diff_context=1
602 # Parse any part of .git/config that belongs to us
605 # autotag?
606 autotag=`git config guilt.autotag`
607 [ -z "$autotag" ] && autotag=1
610 # The following gets run every time this file is source'd
613 TOP_DIR=`git rev-parse --show-cdup`
614 if [ -z "$TOP_DIR" ]; then
615 TOP_DIR="./"
618 GUILT_DIR="$GIT_DIR/patches"
620 branch=`get_branch`
622 # most of the time we want to verify that the repo's branch has been
623 # initialized, but every once in a blue moon (e.g., we want to run guilt-init),
624 # we must avoid the checks
625 if [ -z "$DO_NOT_CHECK_BRANCH_EXISTENCE" ]; then
626 verify_branch
628 # do not check the status file format (guilt-repair needs this,
629 # otherwise nothing can do what's necessary to bring the repo into a
630 # useable state)
631 if [ -z "$DO_NOT_CHECK_STATUS_FILE_FORMAT" ]; then
632 [ -s "$GIT_DIR/patches/$branch/status" ] &&
633 grep "^[0-9a-f]\{40\}:" "$GIT_DIR/patches/$branch/status" > /dev/null &&
634 die "Status file appears to use old format, try guilt-repair --status"
638 # very useful files
639 series="$GUILT_DIR/$branch/series"
640 applied="$GUILT_DIR/$branch/status"
642 # determine an editor to use for anything interactive (fall back to vi)
643 editor="vi"
644 [ ! -z "$EDITOR" ] && editor="$EDITOR"
646 # determine a pager to use for anything interactive (fall back to more)
647 pager="more"
648 [ ! -z "$PAGER" ] && pager="$PAGER"