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