active_mutator 0.7.0 → 0.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cf0b7bed1f6b35d6ab688affd01cb2ccc362944019ae5c18bff2e1205cccb53e
-  data.tar.gz: 9b4d7cac2fc3f8e3a6d737db4aa7f3b8f3f46c00baa275669fecbc5752e50910
+  metadata.gz: 66b813b08ab7b9c3ba792c6472ced651e2f4af2b3b530f5a07c56e938570b21c
+  data.tar.gz: 62bf64d3c76e28648300ccbf437a0334865467890f740b44205c5b417ff3229c
 SHA512:
-  metadata.gz: f2ed986856e22c4881936ae20f66bac4ecdc57b31239b5786942be6c2128516db64542be9185da5f9e8bc06ad1acd893d9e231602e1cf553ad7c74d60af9ef61
-  data.tar.gz: 8f8bd75ed8572b8e1eee883644b412bc9e718eeb0b85f35e22d8f27b6f937113c505bccadca869fd33546895bbf68126a30b9931fc755c3df8d71e33b8168bb0
+  metadata.gz: 0736a4d6182dc5ecbcd14c2243371471f88e96033e459922f7244ce595abe1b17b65a47f3ff9c26fa1d29c8608434cd1c0198b0d5c5c58cefa54d35af9c2ea51
+  data.tar.gz: 5ea60c1a68d289dcd101857b96a4abd4d807e976f741a45ed788eeff86157b383a0ea8095fe9806ff2623aeaf70b986764fa41166656bd864aa189014cfcc03c

data/README.md

@@ -90,6 +90,11 @@ coverage map. The map is cached in `.active_mutator/` and refreshed
 incrementally after that (see
 [`docs/guides/how-it-works.md`](docs/guides/how-it-works.md)).
 Then each mutant runs in its own fork against only its covering examples.
+Top-level groups run the group that last killed a sibling mutant first,
+then the subject's convention spec, then the cheapest remaining groups by
+baseline time. A kill ends the fork sooner. Specs that depend on
+another top-level group having run first can behave differently; see
+[how it works](docs/guides/how-it-works.md).
 
 ### Reading the output
 

data/lib/active_mutator/example_id.rb

@@ -0,0 +1,22 @@
+module ActiveMutator
+  # RSpec example ids look like "./spec/a_spec.rb[1:2:3]": the file, then the
+  # scoped path of the example. The first number is the top-level group, and a
+  # shared example adds a second bracket. Anything else parses to nil, so a bad
+  # id is never mistaken for a group.
+  module ExampleId
+    PATTERN = /\A(?<file>.+?)(?<scope>\[(?<top>\d+)(?::\d+)*\](?:\[\d+(?::\d+)*\])*)\z/
+
+    # [absolute file, top-level group number], or nil. ./spec/a_spec.rb,
+    # spec/a_spec.rb, and its absolute path all name the same file.
+    def self.group_key(id)
+      match = PATTERN.match(id) if id.is_a?(String)
+      [File.expand_path(match[:file]), match[:top]] if match
+    end
+
+    # The id with its file made absolute, for comparing spellings; or nil.
+    def self.normalize(id)
+      match = PATTERN.match(id) if id.is_a?(String)
+      "#{File.expand_path(match[:file])}#{match[:scope]}" if match
+    end
+  end
+end

data/lib/active_mutator/runner.rb

@@ -308,16 +308,29 @@ module ActiveMutator
     end
 
     # Single source of truth for lane/timeout/variable derivation, shared by
-    # phase-1 planning and phase-2 escalation so the two never drift.
+    # phase-1 planning and phase-2 escalation so the two never drift. Lane and
+    # budget come from the whole selection; only the order of the ids changes.
     def build_work_item(mutation, example_ids, map)
       lane = example_ids.any? { |id| serial_example?(id) } ? :serial : :parallel
       variable = map.time_for(example_ids) * @config.timeout_factor
       boot_extra = lane == :serial ? @config.browser_boot_seconds : 0.0
       timeout = variable + @config.timeout_floor + boot_extra
-      WorkItem.new(mutation: mutation, example_ids: example_ids,
+      WorkItem.new(mutation: mutation, example_ids: prioritize(mutation, example_ids, map),
                    timeout: timeout, lane: lane, variable: variable)
     end
 
+    # Run order for the covering set: the subject's convention spec first, then
+    # the cheapest top-level groups (summing only the selected examples), so a
+    # killing spec is found before a slow one. Ties keep sorted-selection order.
+    # Ids inside a group keep their order, and malformed ids stay their own group.
+    def prioritize(mutation, example_ids, map)
+      convention = convention_spec_rels(mutation.subject.file)
+      groups = example_ids.group_by { |id| ExampleId.group_key(id) || id }.values
+      groups.each_with_index.sort_by do |ids, position|
+        [convention.include?(BaselineDelta.spec_file_of(ids.first)) ? 0 : 1, map.time_for(ids), position]
+      end.flat_map(&:first)
+    end
+
     # Spec files that textually match `pattern` (a constant-reference pattern
     # for the subject's file, built via BaselineDelta.constant_reference_pattern
     # so the escaping/word-boundary rules stay shared), minus everything phase 1

data/lib/active_mutator/scheduler.rb

@@ -29,6 +29,7 @@ module ActiveMutator
     def run(items)
       running = {}
       results = []
+      @killers = {} # Subject => [file, top-level group] of its latest killer
       @abort.deferred do
         # Browser-covered mutants each boot Chrome + an app server; running
         # them concurrently melts CPUs and manufactures false timeouts.
@@ -92,6 +93,7 @@ module ActiveMutator
     STDERR_TAIL_LINES = 20
 
     def spawn(item, running)
+      item = prioritized(item)
       calibrator = calibrator_for(item)
       budget = calibrator ? calibrator.budget_for(item) : item.timeout
       log_scale(calibrator, item.lane)
@@ -162,6 +164,29 @@ module ActiveMutator
       end
     end
 
+    # A sibling mutant of the same subject (the plan is built per mutant, so
+    # the covering set is the same or close) most likely dies to the same
+    # spec: run the group that killed the last one first. The set is unchanged.
+    def prioritized(item)
+      key = @killers[item.mutation.subject]
+      return item unless key
+
+      first, rest = item.example_ids.partition { |id| ExampleId.group_key(id) == key }
+      item.with(example_ids: first + rest)
+    end
+
+    # Only a kill that names one of the examples it was given counts. Anything
+    # else (missing, malformed, foreign, or on another status) leaves the last
+    # killer alone.
+    def learn_killer(item, status, killer)
+      return unless status == :killed
+
+      selected = item.example_ids.filter_map { |id| ExampleId.normalize(id) }
+      return unless selected.include?(ExampleId.normalize(killer))
+
+      @killers[item.mutation.subject] = ExampleId.group_key(killer)
+    end
+
     def finish(entry)
       seconds = now - entry[:started]
       report_line, stats_line = entry[:payload].lines.map(&:strip).reject(&:empty?)
@@ -179,6 +204,8 @@ module ActiveMutator
       Result.new(mutation: entry[:item].mutation, status: :error,
                  details: "worker emitted unparseable payload", seconds: seconds)
     else
+      # Learned only once the whole payload (report and stats) has parsed.
+      learn_killer(entry[:item], status, data["killer"]) if reported
       Result.new(mutation: entry[:item].mutation, status: status, details: details,
                  seconds: seconds, peak_rss_kb: peak)
     end

data/lib/active_mutator/version.rb

@@ -1,3 +1,3 @@
 module ActiveMutator
-  VERSION = "0.7.0"
+  VERSION = "0.7.1"
 end

data/lib/active_mutator/work_item.rb

@@ -1,6 +1,8 @@
 module ActiveMutator
   # lane: :parallel (default pool) | :serial (browser-covered, one at a time)
   # timeout:    static total budget (variable + fixed), kept for --debug-plan and compat
+  # example_ids: the covering set in run priority. A worker loads the specs
+  #             sorted but runs top-level groups in this order.
   # variable:   the baseline-estimate-derived part (estimate * timeout_factor) — the
   #             only part the TimeoutCalibrator scales
   WorkItem = Data.define(:mutation, :example_ids, :timeout, :lane, :variable) do

data/lib/active_mutator/worker.rb

@@ -40,9 +40,20 @@ module ActiveMutator
     end
 
     def run
+      # The mutant lands in THIS process, so a mutant of the id parser or of
+      # these methods could rewrite the very code that selects the groups and
+      # reports the verdict, before the specs that kill it have run. Bind the
+      # originals first. A Worker built later (by a spec) sees the mutant.
+      @emit = method(:emit)
+      @covering_groups = method(:covering_groups)
+      @killer = method(:killer)
+      @normalize = ExampleId.method(:normalize)
+      @group_keys = @example_ids.filter_map { |id| ExampleId.group_key(id) }
       require "rspec/core"
       devnull = File.open(File::NULL, "w")
-      runner = RSpec::Core::Runner.new(RSpec::Core::ConfigurationOptions.new(@example_ids))
+      # Sorted so spec files load in the same order whatever the run priority:
+      # load order decides constant definitions and shared setup.
+      runner = RSpec::Core::Runner.new(RSpec::Core::ConfigurationOptions.new(@example_ids.sort))
       if @mutation.subject.reload?
         require @mutation.subject.file # no-op if already loaded; guarantees the constant exists
         insert_mutation                # BEFORE setup: groups bind described_class to the mutated object
@@ -56,15 +67,20 @@ module ActiveMutator
       # is pure waste inside the fork.
       RSpec.configuration.fail_fast = 1
       after_fork_hygiene
-      code = runner.run_specs(covering_groups)
-      emit(code.zero? ? "survived" : "killed")
+      failed_before = failed_examples.dup
+      code = runner.run_specs(@covering_groups.call)
+      if code.zero?
+        @emit.call("survived")
+      else
+        @emit.call("killed", killer: @killer.call(failed_examples - failed_before))
+      end
     rescue ClosureReload::Skip => e
-      emit("skipped", details: e.message)
+      @emit.call("skipped", details: e.message)
     rescue ClosureReload::MutantLoadError => e
       # The mutation made the class unloadable; a real suite would fail on it.
-      emit("killed", details: "mutated class failed to load: #{e.message}")
+      @emit.call("killed", details: "mutated class failed to load: #{e.message}")
     rescue StandardError, ScriptError => e
-      emit("error", details: "#{e.class}: #{e.message}")
+      @emit.call("error", details: "#{e.class}: #{e.message}")
     end
 
     private
@@ -88,8 +104,10 @@ module ActiveMutator
       end
     end
 
-    def emit(status, details: nil)
-      @writer.puts(JSON.generate("status" => status, "details" => details))
+    def emit(status, details: nil, killer: nil)
+      report = { "status" => status, "details" => details }
+      report["killer"] = killer if killer
+      @writer.puts(JSON.generate(report))
       @writer.flush if @writer.respond_to?(:flush)
     end
 
@@ -97,14 +115,28 @@ module ActiveMutator
     # top-level groups evaluated while the PARENT preloaded the spec helper
     # (spec/support files with RSpec.describe at load time are common). Those
     # leak into the fork; running them would report their failures as false
-    # kills. Run only groups that belong to the covering spec files.
+    # kills. Run only groups that belong to the covering spec files, in the
+    # priority order of @example_ids; groups it does not name keep host order.
     def covering_groups
-      covering = @example_ids
-                 .map { |id| File.expand_path(id[/\A(.+?)\[/, 1]) }
-                 .to_set
-      RSpec.world.ordered_example_groups.select do |group|
+      covering = @group_keys.map(&:first).to_set
+      rank = {}
+      @group_keys.each { |key| rank[key] ||= rank.size }
+      groups = RSpec.world.ordered_example_groups.each_with_index.select do |group, _|
         covering.include?(group.metadata[:absolute_file_path])
       end
+      groups.sort_by do |group, host_index|
+        key = [group.metadata[:absolute_file_path], group.metadata[:scoped_id]]
+        [rank.fetch(key, rank.size), host_index]
+      end.map(&:first)
+    end
+
+    def failed_examples = RSpec.configuration.reporter.failed_examples
+
+    # The first fresh failure that is one of the examples this mutant ran
+    # against, spelled as RSpec reports it; nil when there is none.
+    def killer(failures)
+      selected = @example_ids.filter_map { |id| @normalize.call(id) }.to_set
+      failures.map(&:id).find { |id| selected.include?(@normalize.call(id)) }
     end
   end
 end

data/lib/active_mutator.rb

@@ -39,6 +39,7 @@ require_relative "active_mutator/inserter"
 require_relative "active_mutator/closure_reload"
 require_relative "active_mutator/memory_probe"
 require_relative "active_mutator/sampler"
+require_relative "active_mutator/example_id"
 require_relative "active_mutator/worker"
 require_relative "active_mutator/result"
 require_relative "active_mutator/work_item"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: active_mutator
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.7.1
 platform: ruby
 authors:
 - Daniel John
@@ -89,6 +89,7 @@ files:
 - lib/active_mutator/edit.rb
 - lib/active_mutator/engine.rb
 - lib/active_mutator/events.rb
+- lib/active_mutator/example_id.rb
 - lib/active_mutator/fingerprint.rb
 - lib/active_mutator/inserter.rb
 - lib/active_mutator/memory_ceiling.rb
@@ -144,7 +145,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.19
+rubygems_version: 3.6.7
 specification_version: 4
 summary: Mutation testing for Ruby, built on Prism
 test_files: []