Use recursive strategy for bisection

To speed up bisection of complex dependent failures, a recursive bisection
strategy is introduced in place of permutation searching. The strategy works
as follows:

1. Split the candidate set into two slices
2. Test each slice with the expected failure(s)
3. If either slice can be ignored:
  - recurse on the other slice
4. If neither slice can be ignored, for each slice:
  - recurse on slice, retaining other slice for test runs

Graphically, this looks somewhat like:

F = expected failure
P = unexpected pass
X = culprit
- = innocent
[ ] = current bisection scope

 1 2 3 4 5 6 7 8  9

[- - X - - X - -] F # Initial run
[        - X - -] F # RHS0 implicated
[- - X -        ] F # LHS0 implicated

=> (1) recurse on LHS0, fixing RHS0

[    X -]- X - -  F # RHS1 implicated
[- -    ]- X - -  P # LHS1 can be ignored

=> (2) recurse on RHS, retaining fixed set

    [  -]- X - -  P # LHS2 implicated
    [X  ]- X - -  F # RHS2 can be ignored

=> (3) recurse on LHS2
=> terminate as candidates.length == 1

=> (1) recurse on RHS0, fixing LHS0
 - - X -[    - -] P # LHS3 implicated
 - - X -[- X    ] F # RHS3 can be ignored

=> (4) recurse on LHS3

 - - X -[  X]     F # LHS4 can be ignored
 - - X -[-  ]     P # RHS4 implicated

=> (5) recurse on RHS5
=> terminate as candidates.length == 1

=> return LHS2 + RHS5 = [3, 6]

Author: urbanautomaton

lib/rspec/core/bisect/example_minimizer.rb

@@ -1,5 +1,3 @@
-RSpec::Support.require_rspec_core "bisect/subset_enumerator"
-
 module RSpec
   module Core
     module Bisect
@@ -18,20 +16,46 @@ def initialize(runner, reporter)
         def find_minimal_repro
           prep
 
-          self.remaining_ids = non_failing_example_ids
+          self.remaining_ids, duration = track_duration do
+            bisect_over(non_failing_example_ids, [])
+          end
 
-          each_bisect_round do |subsets|
-            ids_to_ignore = subsets.find do |ids|
-              get_expected_failures_for?(remaining_ids - ids)
-            end
+          notify(:bisect_complete, :round => 10, :duration => duration,
+                                   :original_non_failing_count => non_failing_example_ids.size,
+                                   :remaining_count => remaining_ids.size)
 
-            next :done unless ids_to_ignore
+          remaining_ids + failed_example_ids
+        end
 
-            self.remaining_ids -= ids_to_ignore
-            notify(:bisect_ignoring_ids, :ids_to_ignore => ids_to_ignore, :remaining_ids => remaining_ids)
+        def bisect_over(candidate_ids, fixed)
+          return candidate_ids if candidate_ids.length == 1
+          slice_size = (candidate_ids.length / 2.0).ceil
+          slices = candidate_ids.each_slice(slice_size).to_a
+
+          notify(
+            :bisect_round_started,
+            :round => 10,
+            :subset_size => slice_size,
+            :remaining_count => candidate_ids.size
+          )
+
+          ids_to_ignore = slices.find do |ids|
+            get_expected_failures_for?(candidate_ids - ids + fixed)
           end
 
-          currently_needed_ids
+          if ids_to_ignore
+            self.remaining_ids = candidate_ids - ids_to_ignore
+            notify(
+              :bisect_ignoring_ids,
+              :ids_to_ignore => ids_to_ignore,
+              :remaining_ids => remaining_ids
+            )
+            bisect_over(remaining_ids, fixed)
+          else
+            slices.permutation(2).map do |slice, other_slice|
+              bisect_over(slice, fixed + other_slice)
+            end.flatten(1)
+          end
         end
 
         def currently_needed_ids
@@ -79,34 +103,6 @@ def get_expected_failures_for?(ids)
           (failed_example_ids & results.failed_example_ids) == failed_example_ids
         end
 
-        INFINITY = (1.0 / 0) # 1.8.7 doesn't define Float::INFINITY so we define our own...
-
-        def each_bisect_round(&block)
-          last_round, duration = track_duration do
-            1.upto(INFINITY) do |round|
-              break if :done == bisect_round(round, &block)
-            end
-          end
-
-          notify(:bisect_complete, :round => last_round, :duration => duration,
-                                   :original_non_failing_count => non_failing_example_ids.size,
-                                   :remaining_count => remaining_ids.size)
-        end
-
-        def bisect_round(round)
-          value, duration = track_duration do
-            subsets = SubsetEnumerator.new(remaining_ids)
-            notify(:bisect_round_started, :round => round,
-                                          :subset_size => subsets.subset_size,
-                                          :remaining_count => remaining_ids.size)
-
-            yield subsets
-          end
-
-          notify(:bisect_round_finished, :duration => duration, :round => round)
-          value
-        end
-
         def track_duration
           start = ::RSpec::Core::Time.now
           [yield, ::RSpec::Core::Time.now - start]