Track eliminated ids instead of remaining ids

This allows the recursive strategy to minimise the number of examples it runs,
as in the doubly-recursive case (i.e. where both LHS and RHS are implicated in
the failure) the recursion on the RHS can take advantage of examples
eliminated in the recursion on the LHS.

This has meant more reliance on object-level state, which I'll attempt to
minimise separately.

Author: urbanautomaton

lib/rspec/core/bisect/example_minimizer.rb

@@ -6,7 +6,7 @@ module Bisect
       # repeatedly running different subsets of the suite.
       class ExampleMinimizer
         attr_reader :runner, :reporter, :all_example_ids, :failed_example_ids
-        attr_accessor :remaining_ids
+        attr_accessor :eliminated_ids
 
         def initialize(runner, reporter)
           @runner   = runner
@@ -16,7 +16,7 @@ def initialize(runner, reporter)
         def find_minimal_repro
           prep
 
-          self.remaining_ids, duration = track_duration do
+          _, duration = track_duration do
             bisect_over(non_failing_example_ids)
           end
 
@@ -28,15 +28,19 @@ def find_minimal_repro
         end
 
         def bisect_over(candidate_ids)
-          return [] if get_expected_failures_for?([])
+          if get_expected_failures_for?([])
+            self.eliminated_ids = non_failing_example_ids
+            return
+          end
 
-          bisect_over_recursive(candidate_ids, [])
+          bisect_over_recursive(candidate_ids)
         end
 
-        def bisect_over_recursive(candidate_ids, fixed)
-          return candidate_ids if candidate_ids.length == 1
+        def bisect_over_recursive(candidate_ids)
+          return if candidate_ids.one?
+
           slice_size = (candidate_ids.length / 2.0).ceil
-          slices = candidate_ids.each_slice(slice_size).to_a
+          lhs, rhs = candidate_ids.each_slice(slice_size).to_a
 
           notify(
             :bisect_round_started,
@@ -45,31 +49,34 @@ def bisect_over_recursive(candidate_ids, fixed)
             :remaining_count => candidate_ids.size
           )
 
-          ids_to_ignore = slices.find do |ids|
-            get_expected_failures_for?(candidate_ids - ids + fixed)
+          ids_to_ignore = [lhs, rhs].find do |ids|
+            get_expected_failures_for?(remaining_ids - ids)
           end
 
           if ids_to_ignore
-            self.remaining_ids = candidate_ids - ids_to_ignore
+            self.eliminated_ids += ids_to_ignore
             notify(
               :bisect_ignoring_ids,
               :ids_to_ignore => ids_to_ignore,
               :remaining_ids => remaining_ids
             )
-            bisect_over_recursive(remaining_ids, fixed)
+            bisect_over_recursive(candidate_ids - ids_to_ignore)
           else
-            slices.permutation(2).map do |slice, other_slice|
-              bisect_over_recursive(slice, fixed + other_slice)
-            end.flatten(1)
+            bisect_over_recursive(lhs)
+            bisect_over_recursive(rhs)
           end
         end
 
+        def remaining_ids
+          non_failing_example_ids - eliminated_ids
+        end
+
         def currently_needed_ids
           remaining_ids + failed_example_ids
         end
 
         def repro_command_for_currently_needed_ids
-          return runner.repro_command_from(currently_needed_ids) if remaining_ids
+          return runner.repro_command_from(currently_needed_ids) if eliminated_ids
           "(Not yet enough information to provide any repro command)"
         end
 
@@ -82,6 +89,7 @@ def prep
             original_results    = runner.original_results
             @all_example_ids    = original_results.all_example_ids
             @failed_example_ids = original_results.failed_example_ids
+            @eliminated_ids     = []
           end
 
           if @failed_example_ids.empty?
@@ -100,7 +108,11 @@ def non_failing_example_ids
 
         def get_expected_failures_for?(ids)
           ids_to_run = ids + failed_example_ids
-          notify(:bisect_individual_run_start, :command => runner.repro_command_from(ids_to_run))
+          notify(
+            :bisect_individual_run_start,
+            :command => runner.repro_command_from(ids_to_run),
+            :ids_to_run => ids_to_run
+          )
 
           results, duration = track_duration { runner.run(ids_to_run) }
           notify(:bisect_individual_run_complete, :duration => duration, :results => results)