rebase: warn if state directory cannot be removed
[gitweb.git] / git-bisect.sh
index 54cbfecc5ab0531513ff9e069be55d74339ad427..efee12b8b1e6d53d3cd5275683ebb0a4198b4b95 100755 (executable)
@@ -71,122 +71,7 @@ bisect_autostart() {
 }
 
 bisect_start() {
-       #
-       # Check for one bad and then some good revisions.
-       #
-       has_double_dash=0
-       for arg; do
-               case "$arg" in --) has_double_dash=1; break ;; esac
-       done
-       orig_args=$(git rev-parse --sq-quote "$@")
-       bad_seen=0
-       eval=''
-       must_write_terms=0
-       revs=''
-       if test "z$(git rev-parse --is-bare-repository)" != zfalse
-       then
-               mode=--no-checkout
-       else
-               mode=''
-       fi
-       while [ $# -gt 0 ]; do
-               arg="$1"
-               case "$arg" in
-               --)
-                       shift
-                       break
-               ;;
-               --no-checkout)
-                       mode=--no-checkout
-                       shift ;;
-               --term-good|--term-old)
-                       shift
-                       must_write_terms=1
-                       TERM_GOOD=$1
-                       shift ;;
-               --term-good=*|--term-old=*)
-                       must_write_terms=1
-                       TERM_GOOD=${1#*=}
-                       shift ;;
-               --term-bad|--term-new)
-                       shift
-                       must_write_terms=1
-                       TERM_BAD=$1
-                       shift ;;
-               --term-bad=*|--term-new=*)
-                       must_write_terms=1
-                       TERM_BAD=${1#*=}
-                       shift ;;
-               --*)
-                       die "$(eval_gettext "unrecognised option: '\$arg'")" ;;
-               *)
-                       rev=$(git rev-parse -q --verify "$arg^{commit}") || {
-                               test $has_double_dash -eq 1 &&
-                               die "$(eval_gettext "'\$arg' does not appear to be a valid revision")"
-                               break
-                       }
-                       revs="$revs $rev"
-                       shift
-                       ;;
-               esac
-       done
-
-       for rev in $revs
-       do
-               # The user ran "git bisect start <sha1>
-               # <sha1>", hence did not explicitly specify
-               # the terms, but we are already starting to
-               # set references named with the default terms,
-               # and won't be able to change afterwards.
-               must_write_terms=1
-
-               case $bad_seen in
-               0) state=$TERM_BAD ; bad_seen=1 ;;
-               *) state=$TERM_GOOD ;;
-               esac
-               eval="$eval bisect_write '$state' '$rev' 'nolog' &&"
-       done
-       #
-       # Verify HEAD.
-       #
-       head=$(GIT_DIR="$GIT_DIR" git symbolic-ref -q HEAD) ||
-       head=$(GIT_DIR="$GIT_DIR" git rev-parse --verify HEAD) ||
-       die "$(gettext "Bad HEAD - I need a HEAD")"
-
-       #
-       # Check if we are bisecting.
-       #
-       start_head=''
-       if test -s "$GIT_DIR/BISECT_START"
-       then
-               # Reset to the rev from where we started.
-               start_head=$(cat "$GIT_DIR/BISECT_START")
-               if test "z$mode" != "z--no-checkout"
-               then
-                       git checkout "$start_head" -- ||
-                       die "$(eval_gettext "Checking out '\$start_head' failed. Try 'git bisect reset <valid-branch>'.")"
-               fi
-       else
-               # Get rev from where we start.
-               case "$head" in
-               refs/heads/*|$_x40)
-                       # This error message should only be triggered by
-                       # cogito usage, and cogito users should understand
-                       # it relates to cg-seek.
-                       [ -s "$GIT_DIR/head-name" ] &&
-                               die "$(gettext "won't bisect on cg-seek'ed tree")"
-                       start_head="${head#refs/heads/}"
-                       ;;
-               *)
-                       die "$(gettext "Bad HEAD - strange symbolic ref")"
-                       ;;
-               esac
-       fi
-
-       #
-       # Get rid of any old bisect state.
-       #
-       git bisect--helper --bisect-clean-state || exit
+       git bisect--helper --bisect-start $@ || exit
 
        #
        # Change state.
@@ -198,45 +83,15 @@ bisect_start() {
        trap 'git bisect--helper --bisect-clean-state' 0
        trap 'exit 255' 1 2 3 15
 
-       #
-       # Write new start state.
-       #
-       echo "$start_head" >"$GIT_DIR/BISECT_START" && {
-               test "z$mode" != "z--no-checkout" ||
-               git update-ref --no-deref BISECT_HEAD "$start_head"
-       } &&
-       git rev-parse --sq-quote "$@" >"$GIT_DIR/BISECT_NAMES" &&
-       eval "$eval true" &&
-       if test $must_write_terms -eq 1
-       then
-               git bisect--helper --write-terms "$TERM_BAD" "$TERM_GOOD" || exit
-       fi &&
-       echo "git bisect start$orig_args" >>"$GIT_DIR/BISECT_LOG" || exit
        #
        # Check if we can proceed to the next bisect state.
        #
+       get_terms
        bisect_auto_next
 
        trap '-' 0
 }
 
-bisect_write() {
-       state="$1"
-       rev="$2"
-       nolog="$3"
-       case "$state" in
-               "$TERM_BAD")
-                       tag="$state" ;;
-               "$TERM_GOOD"|skip)
-                       tag="$state"-"$rev" ;;
-               *)
-                       die "$(eval_gettext "Bad bisect_write argument: \$state")" ;;
-       esac
-       git update-ref "refs/bisect/$tag" "$rev" || exit
-       echo "# $state: $(git show-branch $rev)" >>"$GIT_DIR/BISECT_LOG"
-       test -n "$nolog" || echo "git bisect $state $rev" >>"$GIT_DIR/BISECT_LOG"
-}
-
 bisect_skip() {
        all=''
        for arg in "$@"
@@ -255,7 +110,8 @@ bisect_skip() {
 bisect_state() {
        bisect_autostart
        state=$1
-       check_and_set_terms $state
+       git bisect--helper --check-and-set-terms $state $TERM_GOOD $TERM_BAD || exit
+       get_terms
        case "$#,$state" in
        0,*)
                die "Please call 'bisect_state' with at least one argument." ;;
@@ -263,7 +119,7 @@ bisect_state() {
                bisected_head=$(bisect_head)
                rev=$(git rev-parse --verify "$bisected_head") ||
                        die "$(eval_gettext "Bad rev input: \$bisected_head")"
-               bisect_write "$state" "$rev"
+               git bisect--helper --bisect-write "$state" "$rev" "$TERM_GOOD" "$TERM_BAD" || exit
                git bisect--helper --check-expected-revs "$rev" ;;
        2,"$TERM_BAD"|*,"$TERM_GOOD"|*,skip)
                shift
@@ -276,7 +132,7 @@ bisect_state() {
                done
                for rev in $hash_list
                do
-                       bisect_write "$state" "$rev"
+                       git bisect--helper --bisect-write "$state" "$rev" "$TERM_GOOD" "$TERM_BAD" || exit
                done
                git bisect--helper --check-expected-revs $hash_list ;;
        *,"$TERM_BAD")
@@ -287,59 +143,14 @@ bisect_state() {
        bisect_auto_next
 }
 
-bisect_next_check() {
-       missing_good= missing_bad=
-       git show-ref -q --verify refs/bisect/$TERM_BAD || missing_bad=t
-       test -n "$(git for-each-ref "refs/bisect/$TERM_GOOD-*")" || missing_good=t
-
-       case "$missing_good,$missing_bad,$1" in
-       ,,*)
-               : have both $TERM_GOOD and $TERM_BAD - ok
-               ;;
-       *,)
-               # do not have both but not asked to fail - just report.
-               false
-               ;;
-       t,,"$TERM_GOOD")
-               # have bad (or new) but not good (or old).  we could bisect although
-               # this is less optimum.
-               eval_gettextln "Warning: bisecting only with a \$TERM_BAD commit." >&2
-               if test -t 0
-               then
-                       # TRANSLATORS: Make sure to include [Y] and [n] in your
-                       # translation. The program will only accept English input
-                       # at this point.
-                       gettext "Are you sure [Y/n]? " >&2
-                       read yesno
-                       case "$yesno" in [Nn]*) exit 1 ;; esac
-               fi
-               : bisect without $TERM_GOOD...
-               ;;
-       *)
-               bad_syn=$(bisect_voc bad)
-               good_syn=$(bisect_voc good)
-               if test -s "$GIT_DIR/BISECT_START"
-               then
-
-                       eval_gettextln "You need to give me at least one \$bad_syn and one \$good_syn revision.
-(You can use \"git bisect \$bad_syn\" and \"git bisect \$good_syn\" for that.)" >&2
-               else
-                       eval_gettextln "You need to start by \"git bisect start\".
-You then need to give me at least one \$good_syn and one \$bad_syn revision.
-(You can use \"git bisect \$bad_syn\" and \"git bisect \$good_syn\" for that.)" >&2
-               fi
-               exit 1 ;;
-       esac
-}
-
 bisect_auto_next() {
-       bisect_next_check && bisect_next || :
+       git bisect--helper --bisect-next-check $TERM_GOOD $TERM_BAD && bisect_next || :
 }
 
 bisect_next() {
        case "$#" in 0) ;; *) usage ;; esac
        bisect_autostart
-       bisect_next_check $TERM_GOOD
+       git bisect--helper --bisect-next-check $TERM_GOOD $TERM_BAD $TERM_GOOD|| exit
 
        # Perform all bisection computation, display and checkout
        git bisect--helper --next-all $(test -f "$GIT_DIR/BISECT_HEAD" && echo --no-checkout)
@@ -371,7 +182,7 @@ bisect_next() {
 }
 
 bisect_visualize() {
-       bisect_next_check fail
+       git bisect--helper --bisect-next-check $TERM_GOOD $TERM_BAD fail || exit
 
        if test $# = 0
        then
@@ -393,35 +204,11 @@ bisect_visualize() {
        eval '"$@"' --bisect -- $(cat "$GIT_DIR/BISECT_NAMES")
 }
 
-bisect_reset() {
-       test -s "$GIT_DIR/BISECT_START" || {
-               gettextln "We are not bisecting."
-               return
-       }
-       case "$#" in
-       0) branch=$(cat "$GIT_DIR/BISECT_START") ;;
-       1) git rev-parse --quiet --verify "$1^{commit}" >/dev/null || {
-                       invalid="$1"
-                       die "$(eval_gettext "'\$invalid' is not a valid commit")"
-               }
-               branch="$1" ;;
-       *)
-               usage ;;
-       esac
-
-       if ! test -f "$GIT_DIR/BISECT_HEAD" && ! git checkout "$branch" --
-       then
-               die "$(eval_gettext "Could not check out original HEAD '\$branch'.
-Try 'git bisect reset <commit>'.")"
-       fi
-       git bisect--helper --bisect-clean-state || exit
-}
-
 bisect_replay () {
        file="$1"
        test "$#" -eq 1 || die "$(gettext "No logfile given")"
        test -r "$file" || die "$(eval_gettext "cannot read \$file for replaying")"
-       bisect_reset
+       git bisect--helper --bisect-reset || exit
        while read git bisect command rev
        do
                test "$git $bisect" = "git bisect" || test "$git" = "git-bisect" || continue
@@ -431,15 +218,16 @@ bisect_replay () {
                        command="$bisect"
                fi
                get_terms
-               check_and_set_terms "$command"
+               git bisect--helper --check-and-set-terms "$command" "$TERM_GOOD" "$TERM_BAD" || exit
+               get_terms
                case "$command" in
                start)
                        cmd="bisect_start $rev"
                        eval "$cmd" ;;
                "$TERM_GOOD"|"$TERM_BAD"|skip)
-                       bisect_write "$command" "$rev" ;;
+                       git bisect--helper --bisect-write "$command" "$rev" "$TERM_GOOD" "$TERM_BAD" || exit;;
                terms)
-                       bisect_terms $rev ;;
+                       git bisect--helper --bisect-terms $rev || exit;;
                *)
                        die "$(gettext "?? what are you talking about?")" ;;
                esac
@@ -448,7 +236,7 @@ bisect_replay () {
 }
 
 bisect_run () {
-       bisect_next_check fail
+       git bisect--helper --bisect-next-check $TERM_GOOD $TERM_BAD fail || exit
 
        test -n "$*" || die "$(gettext "bisect run failed: no command provided.")"
 
@@ -523,74 +311,6 @@ get_terms () {
        fi
 }
 
-check_and_set_terms () {
-       cmd="$1"
-       case "$cmd" in
-       skip|start|terms) ;;
-       *)
-               if test -s "$GIT_DIR/BISECT_TERMS" && test "$cmd" != "$TERM_BAD" && test "$cmd" != "$TERM_GOOD"
-               then
-                       die "$(eval_gettext "Invalid command: you're currently in a \$TERM_BAD/\$TERM_GOOD bisect.")"
-               fi
-               case "$cmd" in
-               bad|good)
-                       if ! test -s "$GIT_DIR/BISECT_TERMS"
-                       then
-                               TERM_BAD=bad
-                               TERM_GOOD=good
-                               git bisect--helper --write-terms "$TERM_BAD" "$TERM_GOOD" || exit
-                       fi
-                       ;;
-               new|old)
-                       if ! test -s "$GIT_DIR/BISECT_TERMS"
-                       then
-                               TERM_BAD=new
-                               TERM_GOOD=old
-                               git bisect--helper --write-terms "$TERM_BAD" "$TERM_GOOD" || exit
-                       fi
-                       ;;
-               esac ;;
-       esac
-}
-
-bisect_voc () {
-       case "$1" in
-       bad) echo "bad|new" ;;
-       good) echo "good|old" ;;
-       esac
-}
-
-bisect_terms () {
-       get_terms
-       if ! test -s "$GIT_DIR/BISECT_TERMS"
-       then
-               die "$(gettext "no terms defined")"
-       fi
-       case "$#" in
-       0)
-               gettextln "Your current terms are $TERM_GOOD for the old state
-and $TERM_BAD for the new state."
-               ;;
-       1)
-               arg=$1
-               case "$arg" in
-                       --term-good|--term-old)
-                               printf '%s\n' "$TERM_GOOD"
-                               ;;
-                       --term-bad|--term-new)
-                               printf '%s\n' "$TERM_BAD"
-                               ;;
-                       *)
-                               die "$(eval_gettext "invalid argument \$arg for 'git bisect terms'.
-Supported options are: --term-good|--term-old and --term-bad|--term-new.")"
-                               ;;
-               esac
-               ;;
-       *)
-               usage ;;
-       esac
-}
-
 case "$#" in
 0)
        usage ;;
@@ -613,7 +333,7 @@ case "$#" in
        visualize|view)
                bisect_visualize "$@" ;;
        reset)
-               bisect_reset "$@" ;;
+               git bisect--helper --bisect-reset "$@" ;;
        replay)
                bisect_replay "$@" ;;
        log)
@@ -621,7 +341,7 @@ case "$#" in
        run)
                bisect_run "$@" ;;
        terms)
-               bisect_terms "$@" ;;
+               git bisect--helper --bisect-terms "$@" || exit;;
        *)
                usage ;;
        esac