git-bisect.sh

   1 #!/bin/sh
   2
   3 USAGE='[help|start|bad|good|skip|next|reset|visualize|replay|log|run]'
   4 LONG_USAGE='git bisect help
   5         print this long help message.
   6 git bisect start [--no-checkout] [<bad> [<good>...]] [--] [<pathspec>...]
   7         reset bisect state and start bisection.
   8 git bisect bad [<rev>]
   9         mark <rev> a known-bad revision.
  10 git bisect good [<rev>...]
  11         mark <rev>... known-good revisions.
  12 git bisect skip [(<rev>|<range>)...]
  13         mark <rev>... untestable revisions.
  14 git bisect next
  15         find next bisection to test and check it out.
  16 git bisect reset [<commit>]
  17         finish bisection search and go back to commit.
  18 git bisect visualize
  19         show bisect status in gitk.
  20 git bisect replay <logfile>
  21         replay bisection log.
  22 git bisect log
  23         show bisect log.
  24 git bisect run <cmd>...
  25         use <cmd>... to automatically bisect.
  26
  27 Please use "git help bisect" to get the full man page.'
  28
  29 OPTIONS_SPEC=
  30 . git-sh-setup
  31 . git-sh-i18n
  32 require_work_tree
  33
  34 _x40='[0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f]'
  35 _x40="$_x40$_x40$_x40$_x40$_x40$_x40$_x40$_x40"
  36
  37 bisect_head()
  38 {
  39         if test -f "$GIT_DIR/BISECT_HEAD"
  40         then
  41                 echo BISECT_HEAD
  42         else
  43                 echo HEAD
  44         fi
  45 }
  46
  47 bisect_autostart() {
  48         test -s "$GIT_DIR/BISECT_START" || {
  49                 (
  50                         gettext "You need to start by \"git bisect start\"" &&
  51                         echo
  52                 ) >&2
  53                 if test -t 0
  54                 then
  55                         # TRANSLATORS: Make sure to include [Y] and [n] in your
  56                         # translation. The program will only accept English input
  57                         # at this point.
  58             gettext "Do you want me to do it for you [Y/n]? " >&2
  59                         read yesno
  60                         case "$yesno" in
  61                         [Nn]*)
  62                                 exit ;;
  63                         esac
  64                         bisect_start
  65                 else
  66                         exit 1
  67                 fi
  68         }
  69 }
  70
  71 bisect_start() {
  72         #
  73         # Check for one bad and then some good revisions.
  74         #
  75         has_double_dash=0
  76         for arg; do
  77             case "$arg" in --) has_double_dash=1; break ;; esac
  78         done
  79         orig_args=$(git rev-parse --sq-quote "$@")
  80         bad_seen=0
  81         eval=''
  82         mode=''
  83         while [ $# -gt 0 ]; do
  84             arg="$1"
  85             case "$arg" in
  86             --)
  87                 shift
  88                 break
  89                 ;;
  90             --no-checkout)
  91                 mode=--no-checkout
  92                 shift ;;
  93             --*)
  94                 die "$(eval_gettext "unrecognised option: '\$arg'")" ;;
  95             *)
  96                 rev=$(git rev-parse -q --verify "$arg^{commit}") || {
  97                     test $has_double_dash -eq 1 &&
  98                         die "$(eval_gettext "'\$arg' does not appear to be a valid revision")"
  99                     break
 100                 }
 101                 case $bad_seen in
 102                 0) state='bad' ; bad_seen=1 ;;
 103                 *) state='good' ;;
 104                 esac
 105                 eval="$eval bisect_write '$state' '$rev' 'nolog' &&"
 106                 shift
 107                 ;;
 108             esac
 109         done
 110
 111         #
 112         # Verify HEAD.
 113         #
 114         head=$(GIT_DIR="$GIT_DIR" git symbolic-ref -q HEAD) ||
 115         head=$(GIT_DIR="$GIT_DIR" git rev-parse --verify HEAD) ||
 116         die "$(gettext "Bad HEAD - I need a HEAD")"
 117
 118         #
 119         # Check if we are bisecting.
 120         #
 121         start_head=''
 122         if test -s "$GIT_DIR/BISECT_START"
 123         then
 124                 # Reset to the rev from where we started.
 125                 start_head=$(cat "$GIT_DIR/BISECT_START")
 126                 if test "z$mode" != "z--no-checkout"
 127                 then
 128                     git checkout "$start_head" --
 129                 fi
 130         else
 131                 # Get rev from where we start.
 132                 case "$head" in
 133                 refs/heads/*|$_x40)
 134                         # This error message should only be triggered by
 135                         # cogito usage, and cogito users should understand
 136                         # it relates to cg-seek.
 137                         [ -s "$GIT_DIR/head-name" ] &&
 138                                 die "$(gettext "won't bisect on seeked tree")"
 139                         start_head="${head#refs/heads/}"
 140                         ;;
 141                 *)
 142                         die "$(gettext "Bad HEAD - strange symbolic ref")"
 143                         ;;
 144                 esac
 145         fi
 146
 147         #
 148         # Get rid of any old bisect state.
 149         #
 150         bisect_clean_state || exit
 151
 152         #
 153         # Change state.
 154         # In case of mistaken revs or checkout error, or signals received,
 155         # "bisect_auto_next" below may exit or misbehave.
 156         # We have to trap this to be able to clean up using
 157         # "bisect_clean_state".
 158         #
 159         trap 'bisect_clean_state' 0
 160         trap 'exit 255' 1 2 3 15
 161
 162         #
 163         # Write new start state.
 164         #
 165         echo "$start_head" >"$GIT_DIR/BISECT_START" && {
 166                 test "z$mode" != "z--no-checkout" ||
 167                 git update-ref --no-deref BISECT_HEAD "$start_head"
 168         } &&
 169         git rev-parse --sq-quote "$@" >"$GIT_DIR/BISECT_NAMES" &&
 170         eval "$eval true" &&
 171         echo "git bisect start$orig_args" >>"$GIT_DIR/BISECT_LOG" || exit
 172         #
 173         # Check if we can proceed to the next bisect state.
 174         #
 175         bisect_auto_next
 176
 177         trap '-' 0
 178 }
 179
 180 bisect_write() {
 181         state="$1"
 182         rev="$2"
 183         nolog="$3"
 184         case "$state" in
 185                 bad)            tag="$state" ;;
 186                 good|skip)      tag="$state"-"$rev" ;;
 187                 *)              die "$(eval_gettext "Bad bisect_write argument: \$state")" ;;
 188         esac
 189         git update-ref "refs/bisect/$tag" "$rev" || exit
 190         echo "# $state: $(git show-branch $rev)" >>"$GIT_DIR/BISECT_LOG"
 191         test -n "$nolog" || echo "git bisect $state $rev" >>"$GIT_DIR/BISECT_LOG"
 192 }
 193
 194 is_expected_rev() {
 195         test -f "$GIT_DIR/BISECT_EXPECTED_REV" &&
 196         test "$1" = $(cat "$GIT_DIR/BISECT_EXPECTED_REV")
 197 }
 198
 199 check_expected_revs() {
 200         for _rev in "$@"; do
 201                 if ! is_expected_rev "$_rev"; then
 202                         rm -f "$GIT_DIR/BISECT_ANCESTORS_OK"
 203                         rm -f "$GIT_DIR/BISECT_EXPECTED_REV"
 204                         return
 205                 fi
 206         done
 207 }
 208
 209 bisect_skip() {
 210         all=''
 211         for arg in "$@"
 212         do
 213             case "$arg" in
 214             *..*)
 215                 revs=$(git rev-list "$arg") || die "$(eval_gettext "Bad rev input: \$arg")" ;;
 216             *)
 217                 revs=$(git rev-parse --sq-quote "$arg") ;;
 218             esac
 219             all="$all $revs"
 220         done
 221         eval bisect_state 'skip' $all
 222 }
 223
 224 bisect_state() {
 225         bisect_autostart
 226         state=$1
 227         case "$#,$state" in
 228         0,*)
 229                 die "$(gettext "Please call 'bisect_state' with at least one argument.")" ;;
 230         1,bad|1,good|1,skip)
 231                 rev=$(git rev-parse --verify $(bisect_head)) ||
 232                         die "$(gettext "Bad rev input: $(bisect_head)")"
 233                 bisect_write "$state" "$rev"
 234                 check_expected_revs "$rev" ;;
 235         2,bad|*,good|*,skip)
 236                 shift
 237                 eval=''
 238                 for rev in "$@"
 239                 do
 240                         sha=$(git rev-parse --verify "$rev^{commit}") ||
 241                                 die "$(eval_gettext "Bad rev input: \$rev")"
 242                         eval="$eval bisect_write '$state' '$sha'; "
 243                 done
 244                 eval "$eval"
 245                 check_expected_revs "$@" ;;
 246         *,bad)
 247                 die "$(gettext "'git bisect bad' can take only one argument.")" ;;
 248         *)
 249                 usage ;;
 250         esac
 251         bisect_auto_next
 252 }
 253
 254 bisect_next_check() {
 255         missing_good= missing_bad=
 256         git show-ref -q --verify refs/bisect/bad || missing_bad=t
 257         test -n "$(git for-each-ref "refs/bisect/good-*")" || missing_good=t
 258
 259         case "$missing_good,$missing_bad,$1" in
 260         ,,*)
 261                 : have both good and bad - ok
 262                 ;;
 263         *,)
 264                 # do not have both but not asked to fail - just report.
 265                 false
 266                 ;;
 267         t,,good)
 268                 # have bad but not good.  we could bisect although
 269                 # this is less optimum.
 270                 (
 271                         gettext "Warning: bisecting only with a bad commit." &&
 272                         echo
 273                 ) >&2
 274                 if test -t 0
 275                 then
 276                         # TRANSLATORS: Make sure to include [Y] and [n] in your
 277                         # translation. The program will only accept English input
 278                         # at this point.
 279                         gettext "Are you sure [Y/n]? " >&2
 280                         read yesno
 281                         case "$yesno" in [Nn]*) exit 1 ;; esac
 282                 fi
 283                 : bisect without good...
 284                 ;;
 285         *)
 286
 287                 if test -s "$GIT_DIR/BISECT_START"
 288                 then
 289                         (
 290                                 gettext "You need to give me at least one good and one bad revisions.
 291 (You can use \"git bisect bad\" and \"git bisect good\" for that.)" &&
 292                                 echo
 293                         ) >&2
 294                 else
 295                         (
 296                                 gettext "You need to start by \"git bisect start\".
 297 You then need to give me at least one good and one bad revisions.
 298 (You can use \"git bisect bad\" and \"git bisect good\" for that.)" &&
 299                                 echo
 300                         ) >&2
 301                 fi
 302                 exit 1 ;;
 303         esac
 304 }
 305
 306 bisect_auto_next() {
 307         bisect_next_check && bisect_next || :
 308 }
 309
 310 bisect_next() {
 311         case "$#" in 0) ;; *) usage ;; esac
 312         bisect_autostart
 313         bisect_next_check good
 314
 315         # Perform all bisection computation, display and checkout
 316         git bisect--helper --next-all $(test -f "$GIT_DIR/BISECT_HEAD" && echo --no-checkout)
 317         res=$?
 318
 319         # Check if we should exit because bisection is finished
 320         test $res -eq 10 && exit 0
 321
 322         # Check for an error in the bisection process
 323         test $res -ne 0 && exit $res
 324
 325         return 0
 326 }
 327
 328 bisect_visualize() {
 329         bisect_next_check fail
 330
 331         if test $# = 0
 332         then
 333                 if test -n "${DISPLAY+set}${SESSIONNAME+set}${MSYSTEM+set}${SECURITYSESSIONID+set}" &&
 334                    type gitk >/dev/null 2>&1; then
 335                         set gitk
 336                 else
 337                         set git log
 338                 fi
 339         else
 340                 case "$1" in
 341                 git*|tig) ;;
 342                 -*)     set git log "$@" ;;
 343                 *)      set git "$@" ;;
 344                 esac
 345         fi
 346
 347         eval '"$@"' --bisect -- $(cat "$GIT_DIR/BISECT_NAMES")
 348 }
 349
 350 bisect_reset() {
 351         test -s "$GIT_DIR/BISECT_START" || {
 352                 gettext "We are not bisecting."; echo
 353                 return
 354         }
 355         case "$#" in
 356         0) branch=$(cat "$GIT_DIR/BISECT_START") ;;
 357         1) git rev-parse --quiet --verify "$1^{commit}" > /dev/null || {
 358                invalid="$1"
 359                die "$(eval_gettext "'\$invalid' is not a valid commit")"
 360            }
 361            branch="$1" ;;
 362         *)
 363             usage ;;
 364         esac
 365         if ! test -f "$GIT_DIR/BISECT_HEAD"
 366         then
 367                 if ! git checkout "$branch" --
 368                 then
 369                         die "$(eval_gettext "Could not check out original HEAD '\$branch'.
 370 Try 'git bisect reset <commit>'.")"
 371                 fi
 372         fi
 373         bisect_clean_state
 374 }
 375
 376 bisect_clean_state() {
 377         # There may be some refs packed during bisection.
 378         git for-each-ref --format='%(refname) %(objectname)' refs/bisect/\* |
 379         while read ref hash
 380         do
 381                 git update-ref -d $ref $hash || exit
 382         done
 383         rm -f "$GIT_DIR/BISECT_EXPECTED_REV" &&
 384         rm -f "$GIT_DIR/BISECT_ANCESTORS_OK" &&
 385         rm -f "$GIT_DIR/BISECT_LOG" &&
 386         rm -f "$GIT_DIR/BISECT_NAMES" &&
 387         rm -f "$GIT_DIR/BISECT_RUN" &&
 388         # Cleanup head-name if it got left by an old version of git-bisect
 389         rm -f "$GIT_DIR/head-name" &&
 390         git update-ref -d --no-deref BISECT_HEAD &&
 391         # clean up BISECT_START last
 392         rm -f "$GIT_DIR/BISECT_START"
 393 }
 394
 395 bisect_replay () {
 396         file="$1"
 397         test "$#" -eq 1 || die "$(gettext "No logfile given")"
 398         test -r "$file" || die "$(eval_gettext "cannot read \$file for replaying")"
 399         bisect_reset
 400         while read git bisect command rev
 401         do
 402                 test "$git $bisect" = "git bisect" -o "$git" = "git-bisect" || continue
 403                 if test "$git" = "git-bisect"; then
 404                         rev="$command"
 405                         command="$bisect"
 406                 fi
 407                 case "$command" in
 408                 start)
 409                         cmd="bisect_start $rev"
 410                         eval "$cmd" ;;
 411                 good|bad|skip)
 412                         bisect_write "$command" "$rev" ;;
 413                 *)
 414                         die "$(gettext "?? what are you talking about?")" ;;
 415                 esac
 416         done <"$file"
 417         bisect_auto_next
 418 }
 419
 420 bisect_run () {
 421     bisect_next_check fail
 422
 423     while true
 424     do
 425       command="$@"
 426       eval_gettext "running \$command"; echo
 427       "$@"
 428       res=$?
 429
 430       # Check for really bad run error.
 431       if [ $res -lt 0 -o $res -ge 128 ]; then
 432           (
 433             eval_gettext "bisect run failed:
 434 exit code \$res from '\$command' is < 0 or >= 128" &&
 435             echo
 436           ) >&2
 437           exit $res
 438       fi
 439
 440       # Find current state depending on run success or failure.
 441       # A special exit code of 125 means cannot test.
 442       if [ $res -eq 125 ]; then
 443           state='skip'
 444       elif [ $res -gt 0 ]; then
 445           state='bad'
 446       else
 447           state='good'
 448       fi
 449
 450       # We have to use a subshell because "bisect_state" can exit.
 451       ( bisect_state $state > "$GIT_DIR/BISECT_RUN" )
 452       res=$?
 453
 454       cat "$GIT_DIR/BISECT_RUN"
 455
 456       if sane_grep "first bad commit could be any of" "$GIT_DIR/BISECT_RUN" \
 457                 > /dev/null; then
 458           (
 459               gettext "bisect run cannot continue any more" &&
 460               echo
 461           ) >&2
 462           exit $res
 463       fi
 464
 465       if [ $res -ne 0 ]; then
 466           (
 467               eval_gettext "bisect run failed:
 468 'bisect_state \$state' exited with error code \$res" &&
 469               echo
 470           ) >&2
 471           exit $res
 472       fi
 473
 474       if sane_grep "is the first bad commit" "$GIT_DIR/BISECT_RUN" > /dev/null; then
 475           gettext "bisect run success"; echo
 476           exit 0;
 477       fi
 478
 479     done
 480 }
 481
 482 bisect_log () {
 483         test -s "$GIT_DIR/BISECT_LOG" || die "$(gettext "We are not bisecting.")"
 484         cat "$GIT_DIR/BISECT_LOG"
 485 }
 486
 487 case "$#" in
 488 0)
 489     usage ;;
 490 *)
 491     cmd="$1"
 492     shift
 493     case "$cmd" in
 494     help)
 495         git bisect -h ;;
 496     start)
 497         bisect_start "$@" ;;
 498     bad|good)
 499         bisect_state "$cmd" "$@" ;;
 500     skip)
 501         bisect_skip "$@" ;;
 502     next)
 503         # Not sure we want "next" at the UI level anymore.
 504         bisect_next "$@" ;;
 505     visualize|view)
 506         bisect_visualize "$@" ;;
 507     reset)
 508         bisect_reset "$@" ;;
 509     replay)
 510         bisect_replay "$@" ;;
 511     log)
 512         bisect_log ;;
 513     run)
 514         bisect_run "$@" ;;
 515     *)
 516         usage ;;
 517     esac
 518 esac