Documentation: push.default applies to all remotes
[git] / 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 [<branch>]
17         finish bisection search and go back to branch.
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 require_work_tree
32
33 _x40='[0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f]'
34 _x40="$_x40$_x40$_x40$_x40$_x40$_x40$_x40$_x40"
35
36 sq() {
37         @@PERL@@ -e '
38                 for (@ARGV) {
39                         s/'\''/'\'\\\\\'\''/g;
40                         print " '\''$_'\''";
41                 }
42                 print "\n";
43         ' "$@"
44 }
45
46 bisect_autostart() {
47         test -s "$GIT_DIR/BISECT_START" || {
48                 echo >&2 'You need to start by "git bisect start"'
49                 if test -t 0
50                 then
51                         echo >&2 -n 'Do you want me to do it for you [Y/n]? '
52                         read yesno
53                         case "$yesno" in
54                         [Nn]*)
55                                 exit ;;
56                         esac
57                         bisect_start
58                 else
59                         exit 1
60                 fi
61         }
62 }
63
64 bisect_start() {
65         #
66         # Verify HEAD.
67         #
68         head=$(GIT_DIR="$GIT_DIR" git symbolic-ref -q HEAD) ||
69         head=$(GIT_DIR="$GIT_DIR" git rev-parse --verify HEAD) ||
70         die "Bad HEAD - I need a HEAD"
71
72         #
73         # Check if we are bisecting.
74         #
75         start_head=''
76         if test -s "$GIT_DIR/BISECT_START"
77         then
78                 # Reset to the rev from where we started.
79                 start_head=$(cat "$GIT_DIR/BISECT_START")
80                 git checkout "$start_head" || exit
81         else
82                 # Get rev from where we start.
83                 case "$head" in
84                 refs/heads/*|$_x40)
85                         # This error message should only be triggered by
86                         # cogito usage, and cogito users should understand
87                         # it relates to cg-seek.
88                         [ -s "$GIT_DIR/head-name" ] &&
89                                 die "won't bisect on seeked tree"
90                         start_head="${head#refs/heads/}"
91                         ;;
92                 *)
93                         die "Bad HEAD - strange symbolic ref"
94                         ;;
95                 esac
96         fi
97
98         #
99         # Get rid of any old bisect state.
100         #
101         bisect_clean_state || exit
102
103         #
104         # Check for one bad and then some good revisions.
105         #
106         has_double_dash=0
107         for arg; do
108             case "$arg" in --) has_double_dash=1; break ;; esac
109         done
110         orig_args=$(sq "$@")
111         bad_seen=0
112         eval=''
113         while [ $# -gt 0 ]; do
114             arg="$1"
115             case "$arg" in
116             --)
117                 shift
118                 break
119                 ;;
120             *)
121                 rev=$(git rev-parse -q --verify "$arg^{commit}") || {
122                     test $has_double_dash -eq 1 &&
123                         die "'$arg' does not appear to be a valid revision"
124                     break
125                 }
126                 case $bad_seen in
127                 0) state='bad' ; bad_seen=1 ;;
128                 *) state='good' ;;
129                 esac
130                 eval="$eval bisect_write '$state' '$rev' 'nolog'; "
131                 shift
132                 ;;
133             esac
134         done
135
136         #
137         # Change state.
138         # In case of mistaken revs or checkout error, or signals received,
139         # "bisect_auto_next" below may exit or misbehave.
140         # We have to trap this to be able to clean up using
141         # "bisect_clean_state".
142         #
143         trap 'bisect_clean_state' 0
144         trap 'exit 255' 1 2 3 15
145
146         #
147         # Write new start state.
148         #
149         echo "$start_head" >"$GIT_DIR/BISECT_START" &&
150         sq "$@" >"$GIT_DIR/BISECT_NAMES" &&
151         eval "$eval" &&
152         echo "git bisect start$orig_args" >>"$GIT_DIR/BISECT_LOG" || exit
153         #
154         # Check if we can proceed to the next bisect state.
155         #
156         bisect_auto_next
157
158         trap '-' 0
159 }
160
161 bisect_write() {
162         state="$1"
163         rev="$2"
164         nolog="$3"
165         case "$state" in
166                 bad)            tag="$state" ;;
167                 good|skip)      tag="$state"-"$rev" ;;
168                 *)              die "Bad bisect_write argument: $state" ;;
169         esac
170         git update-ref "refs/bisect/$tag" "$rev" || exit
171         echo "# $state: $(git show-branch $rev)" >>"$GIT_DIR/BISECT_LOG"
172         test -n "$nolog" || echo "git bisect $state $rev" >>"$GIT_DIR/BISECT_LOG"
173 }
174
175 is_expected_rev() {
176         test -f "$GIT_DIR/BISECT_EXPECTED_REV" &&
177         test "$1" = $(cat "$GIT_DIR/BISECT_EXPECTED_REV")
178 }
179
180 mark_expected_rev() {
181         echo "$1" > "$GIT_DIR/BISECT_EXPECTED_REV"
182 }
183
184 check_expected_revs() {
185         for _rev in "$@"; do
186                 if ! is_expected_rev "$_rev"; then
187                         rm -f "$GIT_DIR/BISECT_ANCESTORS_OK"
188                         rm -f "$GIT_DIR/BISECT_EXPECTED_REV"
189                         return
190                 fi
191         done
192 }
193
194 bisect_skip() {
195         all=''
196         for arg in "$@"
197         do
198             case "$arg" in
199             *..*)
200                 revs=$(git rev-list "$arg") || die "Bad rev input: $arg" ;;
201             *)
202                 revs=$(sq "$arg") ;;
203             esac
204             all="$all $revs"
205         done
206         eval bisect_state 'skip' $all
207 }
208
209 bisect_state() {
210         bisect_autostart
211         state=$1
212         case "$#,$state" in
213         0,*)
214                 die "Please call 'bisect_state' with at least one argument." ;;
215         1,bad|1,good|1,skip)
216                 rev=$(git rev-parse --verify HEAD) ||
217                         die "Bad rev input: HEAD"
218                 bisect_write "$state" "$rev"
219                 check_expected_revs "$rev" ;;
220         2,bad|*,good|*,skip)
221                 shift
222                 eval=''
223                 for rev in "$@"
224                 do
225                         sha=$(git rev-parse --verify "$rev^{commit}") ||
226                                 die "Bad rev input: $rev"
227                         eval="$eval bisect_write '$state' '$sha'; "
228                 done
229                 eval "$eval"
230                 check_expected_revs "$@" ;;
231         *,bad)
232                 die "'git bisect bad' can take only one argument." ;;
233         *)
234                 usage ;;
235         esac
236         bisect_auto_next
237 }
238
239 bisect_next_check() {
240         missing_good= missing_bad=
241         git show-ref -q --verify refs/bisect/bad || missing_bad=t
242         test -n "$(git for-each-ref "refs/bisect/good-*")" || missing_good=t
243
244         case "$missing_good,$missing_bad,$1" in
245         ,,*)
246                 : have both good and bad - ok
247                 ;;
248         *,)
249                 # do not have both but not asked to fail - just report.
250                 false
251                 ;;
252         t,,good)
253                 # have bad but not good.  we could bisect although
254                 # this is less optimum.
255                 echo >&2 'Warning: bisecting only with a bad commit.'
256                 if test -t 0
257                 then
258                         printf >&2 'Are you sure [Y/n]? '
259                         read yesno
260                         case "$yesno" in [Nn]*) exit 1 ;; esac
261                 fi
262                 : bisect without good...
263                 ;;
264         *)
265                 THEN=''
266                 test -s "$GIT_DIR/BISECT_START" || {
267                         echo >&2 'You need to start by "git bisect start".'
268                         THEN='then '
269                 }
270                 echo >&2 'You '$THEN'need to give me at least one good' \
271                         'and one bad revisions.'
272                 echo >&2 '(You can use "git bisect bad" and' \
273                         '"git bisect good" for that.)'
274                 exit 1 ;;
275         esac
276 }
277
278 bisect_auto_next() {
279         bisect_next_check && bisect_next || :
280 }
281
282 filter_skipped() {
283         _eval="$1"
284         _skip="$2"
285
286         if [ -z "$_skip" ]; then
287                 eval "$_eval" | {
288                         while read line
289                         do
290                                 echo "$line &&"
291                         done
292                         echo ':'
293                 }
294                 return
295         fi
296
297         # Let's parse the output of:
298         # "git rev-list --bisect-vars --bisect-all ..."
299         eval "$_eval" | {
300                 VARS= FOUND= TRIED=
301                 while read hash line
302                 do
303                         case "$VARS,$FOUND,$TRIED,$hash" in
304                         1,*,*,*)
305                                 # "bisect_foo=bar" read from rev-list output.
306                                 echo "$hash &&"
307                                 ;;
308                         ,*,*,---*)
309                                 # Separator
310                                 ;;
311                         ,,,bisect_rev*)
312                                 # We had nothing to search.
313                                 echo "bisect_rev= &&"
314                                 VARS=1
315                                 ;;
316                         ,,*,bisect_rev*)
317                                 # We did not find a good bisect rev.
318                                 # This should happen only if the "bad"
319                                 # commit is also a "skip" commit.
320                                 echo "bisect_rev='$TRIED' &&"
321                                 VARS=1
322                                 ;;
323                         ,,*,*)
324                                 # We are searching.
325                                 TRIED="${TRIED:+$TRIED|}$hash"
326                                 case "$_skip" in
327                                 *$hash*) ;;
328                                 *)
329                                         echo "bisect_rev=$hash &&"
330                                         echo "bisect_tried='$TRIED' &&"
331                                         FOUND=1
332                                         ;;
333                                 esac
334                                 ;;
335                         ,1,*,bisect_rev*)
336                                 # We have already found a rev to be tested.
337                                 VARS=1
338                                 ;;
339                         ,1,*,*)
340                                 ;;
341                         *)
342                                 # Unexpected input
343                                 echo "die 'filter_skipped error'"
344                                 die "filter_skipped error " \
345                                     "VARS: '$VARS' " \
346                                     "FOUND: '$FOUND' " \
347                                     "TRIED: '$TRIED' " \
348                                     "hash: '$hash' " \
349                                     "line: '$line'"
350                                 ;;
351                         esac
352                 done
353                 echo ':'
354         }
355 }
356
357 exit_if_skipped_commits () {
358         _tried=$1
359         if expr "$_tried" : ".*[|].*" > /dev/null ; then
360                 echo "There are only 'skip'ped commit left to test."
361                 echo "The first bad commit could be any of:"
362                 echo "$_tried" | tr '[|]' '[\012]'
363                 echo "We cannot bisect more!"
364                 exit 2
365         fi
366 }
367
368 bisect_checkout() {
369         _rev="$1"
370         _msg="$2"
371         echo "Bisecting: $_msg"
372         mark_expected_rev "$_rev"
373         git checkout -q "$_rev" || exit
374         git show-branch "$_rev"
375 }
376
377 is_among() {
378         _rev="$1"
379         _list="$2"
380         case "$_list" in *$_rev*) return 0 ;; esac
381         return 1
382 }
383
384 handle_bad_merge_base() {
385         _badmb="$1"
386         _good="$2"
387         if is_expected_rev "$_badmb"; then
388                 cat >&2 <<EOF
389 The merge base $_badmb is bad.
390 This means the bug has been fixed between $_badmb and [$_good].
391 EOF
392                 exit 3
393         else
394                 cat >&2 <<EOF
395 Some good revs are not ancestor of the bad rev.
396 git bisect cannot work properly in this case.
397 Maybe you mistake good and bad revs?
398 EOF
399                 exit 1
400         fi
401 }
402
403 handle_skipped_merge_base() {
404         _mb="$1"
405         _bad="$2"
406         _good="$3"
407         cat >&2 <<EOF
408 Warning: the merge base between $_bad and [$_good] must be skipped.
409 So we cannot be sure the first bad commit is between $_mb and $_bad.
410 We continue anyway.
411 EOF
412 }
413
414 #
415 # "check_merge_bases" checks that merge bases are not "bad".
416 #
417 # - If one is "good", that's good, we have nothing to do.
418 # - If one is "bad", it means the user assumed something wrong
419 # and we must exit.
420 # - If one is "skipped", we can't know but we should warn.
421 # - If we don't know, we should check it out and ask the user to test.
422 #
423 # In the last case we will return 1, and otherwise 0.
424 #
425 check_merge_bases() {
426         _bad="$1"
427         _good="$2"
428         _skip="$3"
429         for _mb in $(git merge-base --all $_bad $_good)
430         do
431                 if is_among "$_mb" "$_good"; then
432                         continue
433                 elif test "$_mb" = "$_bad"; then
434                         handle_bad_merge_base "$_bad" "$_good"
435                 elif is_among "$_mb" "$_skip"; then
436                         handle_skipped_merge_base "$_mb" "$_bad" "$_good"
437                 else
438                         bisect_checkout "$_mb" "a merge base must be tested"
439                         return 1
440                 fi
441         done
442         return 0
443 }
444
445 #
446 # "check_good_are_ancestors_of_bad" checks that all "good" revs are
447 # ancestor of the "bad" rev.
448 #
449 # If that's not the case, we need to check the merge bases.
450 # If a merge base must be tested by the user we return 1 and
451 # otherwise 0.
452 #
453 check_good_are_ancestors_of_bad() {
454         test -f "$GIT_DIR/BISECT_ANCESTORS_OK" &&
455                 return
456
457         _bad="$1"
458         _good=$(echo $2 | sed -e 's/\^//g')
459         _skip="$3"
460
461         # Bisecting with no good rev is ok
462         test -z "$_good" && return
463
464         _side=$(git rev-list $_good ^$_bad)
465         if test -n "$_side"; then
466                 # Return if a checkout was done
467                 check_merge_bases "$_bad" "$_good" "$_skip" || return
468         fi
469
470         : > "$GIT_DIR/BISECT_ANCESTORS_OK"
471
472         return 0
473 }
474
475 bisect_next() {
476         case "$#" in 0) ;; *) usage ;; esac
477         bisect_autostart
478         bisect_next_check good
479
480         # Get bad, good and skipped revs
481         bad=$(git rev-parse --verify refs/bisect/bad) &&
482         good=$(git for-each-ref --format='^%(objectname)' \
483                 "refs/bisect/good-*" | tr '\012' ' ') &&
484         skip=$(git for-each-ref --format='%(objectname)' \
485                 "refs/bisect/skip-*" | tr '\012' ' ') || exit
486
487         # Maybe some merge bases must be tested first
488         check_good_are_ancestors_of_bad "$bad" "$good" "$skip"
489         # Return now if a checkout has already been done
490         test "$?" -eq "1" && return
491
492         # Get bisection information
493         BISECT_OPT=''
494         test -n "$skip" && BISECT_OPT='--bisect-all'
495         eval="git rev-list --bisect-vars $BISECT_OPT $good $bad --" &&
496         eval="$eval $(cat "$GIT_DIR/BISECT_NAMES")" &&
497         eval=$(filter_skipped "$eval" "$skip") &&
498         eval "$eval" || exit
499
500         if [ -z "$bisect_rev" ]; then
501                 echo "$bad was both good and bad"
502                 exit 1
503         fi
504         if [ "$bisect_rev" = "$bad" ]; then
505                 exit_if_skipped_commits "$bisect_tried"
506                 echo "$bisect_rev is first bad commit"
507                 git diff-tree --pretty $bisect_rev
508                 exit 0
509         fi
510
511         # We should exit here only if the "bad"
512         # commit is also a "skip" commit (see above).
513         exit_if_skipped_commits "$bisect_rev"
514
515         bisect_checkout "$bisect_rev" "$bisect_nr revisions left to test after this (roughly $bisect_steps steps)"
516 }
517
518 bisect_visualize() {
519         bisect_next_check fail
520
521         if test $# = 0
522         then
523                 case "${DISPLAY+set}${SESSIONNAME+set}${MSYSTEM+set}${SECURITYSESSIONID+set}" in
524                 '')     set git log ;;
525                 set*)   set gitk ;;
526                 esac
527         else
528                 case "$1" in
529                 git*|tig) ;;
530                 -*)     set git log "$@" ;;
531                 *)      set git "$@" ;;
532                 esac
533         fi
534
535         not=$(git for-each-ref --format='%(refname)' "refs/bisect/good-*")
536         eval '"$@"' refs/bisect/bad --not $not -- $(cat "$GIT_DIR/BISECT_NAMES")
537 }
538
539 bisect_reset() {
540         test -s "$GIT_DIR/BISECT_START" || {
541                 echo "We are not bisecting."
542                 return
543         }
544         case "$#" in
545         0) branch=$(cat "$GIT_DIR/BISECT_START") ;;
546         1) git show-ref --verify --quiet -- "refs/heads/$1" ||
547                die "$1 does not seem to be a valid branch"
548            branch="$1" ;;
549         *)
550             usage ;;
551         esac
552         git checkout "$branch" && bisect_clean_state
553 }
554
555 bisect_clean_state() {
556         # There may be some refs packed during bisection.
557         git for-each-ref --format='%(refname) %(objectname)' refs/bisect/\* |
558         while read ref hash
559         do
560                 git update-ref -d $ref $hash || exit
561         done
562         rm -f "$GIT_DIR/BISECT_EXPECTED_REV" &&
563         rm -f "$GIT_DIR/BISECT_ANCESTORS_OK" &&
564         rm -f "$GIT_DIR/BISECT_LOG" &&
565         rm -f "$GIT_DIR/BISECT_NAMES" &&
566         rm -f "$GIT_DIR/BISECT_RUN" &&
567         # Cleanup head-name if it got left by an old version of git-bisect
568         rm -f "$GIT_DIR/head-name" &&
569
570         rm -f "$GIT_DIR/BISECT_START"
571 }
572
573 bisect_replay () {
574         test -r "$1" || die "cannot read $1 for replaying"
575         bisect_reset
576         while read git bisect command rev
577         do
578                 test "$git $bisect" = "git bisect" -o "$git" = "git-bisect" || continue
579                 if test "$git" = "git-bisect"; then
580                         rev="$command"
581                         command="$bisect"
582                 fi
583                 case "$command" in
584                 start)
585                         cmd="bisect_start $rev"
586                         eval "$cmd" ;;
587                 good|bad|skip)
588                         bisect_write "$command" "$rev" ;;
589                 *)
590                         die "?? what are you talking about?" ;;
591                 esac
592         done <"$1"
593         bisect_auto_next
594 }
595
596 bisect_run () {
597     bisect_next_check fail
598
599     while true
600     do
601       echo "running $@"
602       "$@"
603       res=$?
604
605       # Check for really bad run error.
606       if [ $res -lt 0 -o $res -ge 128 ]; then
607           echo >&2 "bisect run failed:"
608           echo >&2 "exit code $res from '$@' is < 0 or >= 128"
609           exit $res
610       fi
611
612       # Find current state depending on run success or failure.
613       # A special exit code of 125 means cannot test.
614       if [ $res -eq 125 ]; then
615           state='skip'
616       elif [ $res -gt 0 ]; then
617           state='bad'
618       else
619           state='good'
620       fi
621
622       # We have to use a subshell because "bisect_state" can exit.
623       ( bisect_state $state > "$GIT_DIR/BISECT_RUN" )
624       res=$?
625
626       cat "$GIT_DIR/BISECT_RUN"
627
628       if grep "first bad commit could be any of" "$GIT_DIR/BISECT_RUN" \
629                 > /dev/null; then
630           echo >&2 "bisect run cannot continue any more"
631           exit $res
632       fi
633
634       if [ $res -ne 0 ]; then
635           echo >&2 "bisect run failed:"
636           echo >&2 "'bisect_state $state' exited with error code $res"
637           exit $res
638       fi
639
640       if grep "is first bad commit" "$GIT_DIR/BISECT_RUN" > /dev/null; then
641           echo "bisect run success"
642           exit 0;
643       fi
644
645     done
646 }
647
648
649 case "$#" in
650 0)
651     usage ;;
652 *)
653     cmd="$1"
654     shift
655     case "$cmd" in
656     help)
657         git bisect -h ;;
658     start)
659         bisect_start "$@" ;;
660     bad|good)
661         bisect_state "$cmd" "$@" ;;
662     skip)
663         bisect_skip "$@" ;;
664     next)
665         # Not sure we want "next" at the UI level anymore.
666         bisect_next "$@" ;;
667     visualize|view)
668         bisect_visualize "$@" ;;
669     reset)
670         bisect_reset "$@" ;;
671     replay)
672         bisect_replay "$@" ;;
673     log)
674         cat "$GIT_DIR/BISECT_LOG" ;;
675     run)
676         bisect_run "$@" ;;
677     *)
678         usage ;;
679     esac
680 esac