evilution 0.32.0 → 0.34.0

data/lib/evilution/coverage/map_builder.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require "coverage"
+require "stringio"
+require_relative "../coverage"
+require_relative "map"
+require_relative "recorder"
+
+# Builds a per-example coverage Map by running the given spec files under
+# ::Coverage (lines mode) with the Recorder installed as an around(:each)
+# hook. The run happens in a FORKED CHILD so the global ::RSpec.configure
+# hook, ::RSpec.world mutation, and ::Coverage state never leak into the
+# calling process; the parent receives only the serialized map over a pipe.
+class Evilution::Coverage::MapBuilder
+  LOCATION_LINE_SUFFIX = /\A(.+?)(:\d+(?::\d+)*)\z/
+
+  # RSpec reports example locations relative to its run dir as "./spec/x.rb:5".
+  # Store them ABSOLUTE (path expanded against the project root, line suffix
+  # preserved) so they replay regardless of the per-mutation run's CWD --
+  # Integration::RSpec#resolve_target passes absolute targets through unchanged.
+  def self.absolute_location(raw, root)
+    match = LOCATION_LINE_SUFFIX.match(raw)
+    path, suffix = match ? [match[1], match[2]] : [raw, ""]
+    "#{File.expand_path(path, root)}#{suffix}"
+  end
+
+  def initialize(spec_files:, target_files:, project_root: Evilution::PROJECT_ROOT)
+    @spec_files = spec_files
+    @target_files = target_files
+    @project_root = project_root.to_s
+  end
+
+  def call
+    read_io, write_io = IO.pipe
+    read_io.binmode
+    write_io.binmode
+    pid = fork do
+      read_io.close
+      Marshal.dump(build_in_child.to_h, write_io)
+      write_io.close
+      exit!(0)
+    end
+    write_io.close
+    payload = read_io.read
+    read_io.close
+    Process.wait(pid)
+    # Trust boundary: payload is a Marshal dump this process's own forked child
+    # produced over a private pipe -- same rationale as Channel::Frame.
+    Evilution::Coverage::Map.from_h(Marshal.load(payload))
+  end
+
+  private
+
+  # Runs entirely inside the forked child.
+  def build_in_child
+    recorder = Evilution::Coverage::Recorder.new(target_files: @target_files)
+    ::Coverage.start(lines: true) unless ::Coverage.running?
+    # The child inherited the parent's fully-loaded RSpec.world; wipe it so the
+    # nested runner executes ONLY @spec_files and never re-enters the host suite
+    # (which would recursively fork this builder).
+    reset_world
+    install_hook(recorder)
+    ::RSpec::Core::Runner.run(@spec_files, StringIO.new, StringIO.new)
+    recorder.to_map(built_files: @target_files)
+  end
+
+  def reset_world
+    ::RSpec.respond_to?(:clear_examples) ? ::RSpec.clear_examples : ::RSpec.reset
+  end
+
+  def install_hook(recorder)
+    root = @project_root
+    ::RSpec.configure do |config|
+      config.around(:each) do |example|
+        location = Evilution::Coverage::MapBuilder.absolute_location(
+          example.metadata[:location].to_s, root
+        )
+        recorder.around_example(location) { example.run }
+      end
+    end
+  end
+end

data/lib/evilution/coverage/map_store.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require "json"
+require "fileutils"
+require_relative "../coverage"
+require_relative "map"
+require_relative "digest"
+
+# Disk cache for a per-example coverage Map under .evilution/coverage/, keyed by
+# a per-file content digest so a map survives across runs and invalidates one
+# file at a time.
+#
+# load is partial: it returns a Map pruned to the files whose on-disk content
+# still matches the cached digest. A stale or deleted file is dropped (so its
+# `built?` is false and the caller falls back to lexical targeting) while every
+# fresh file stays queryable. A missing or corrupt cache returns nil, signalling
+# the caller to rebuild from scratch.
+class Evilution::Coverage::MapStore
+  DEFAULT_ROOT = ".evilution/coverage"
+  CACHE_FILE = "map.json"
+
+  def initialize(root: DEFAULT_ROOT, digest: Evilution::Coverage::Digest.new)
+    @root = root
+    @digest = digest
+  end
+
+  def save(map, source_files)
+    payload = { "digests" => digests_for(source_files), "map" => map.to_h }
+    FileUtils.mkdir_p(@root)
+    File.write(cache_path, JSON.generate(payload))
+  end
+
+  def load(source_files)
+    payload = read_payload
+    return nil unless payload
+
+    cached_digests = payload["digests"] || {}
+    fresh = source_files.select { |file| fresh?(file, cached_digests) }
+    pruned_map(payload["map"] || {}, fresh)
+  end
+
+  # Source files whose on-disk content no longer matches the cache (changed,
+  # deleted, or never cached) -- the caller rebuilds these. Every file is stale
+  # when there is no cache at all.
+  def stale_files(source_files)
+    payload = read_payload
+    return source_files.dup unless payload
+
+    cached_digests = payload["digests"] || {}
+    source_files.reject { |file| fresh?(file, cached_digests) }
+  end
+
+  private
+
+  def fresh?(file, cached_digests)
+    cached = cached_digests[file]
+    !cached.nil? && cached == @digest.for_file(file)
+  end
+
+  def pruned_map(raw_map, fresh_files)
+    index = (raw_map["index"] || {}).slice(*fresh_files)
+    built = (raw_map["built_files"] || []) & fresh_files
+    executed = (raw_map["executed_lines"] || {}).slice(*fresh_files)
+    Evilution::Coverage::Map.from_h(
+      "index" => index, "built_files" => built, "executed_lines" => executed
+    )
+  end
+
+  def digests_for(source_files)
+    source_files.each_with_object({}) do |file, out|
+      digest = @digest.for_file(file)
+      out[file] = digest unless digest.nil?
+    end
+  end
+
+  def read_payload
+    return nil unless File.file?(cache_path)
+
+    JSON.parse(File.read(cache_path))
+  rescue JSON::ParserError, Errno::ENOENT
+    nil
+  end
+
+  def cache_path
+    File.join(@root, CACHE_FILE)
+  end
+end

data/lib/evilution/coverage/recorder.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require_relative "../coverage"
+require_relative "map"
+
+# Wraps each example with a before/after coverage diff and attributes the
+# newly-executed lines (in target files only) to that example's location.
+# coverage_source is injected for testability; in production it is
+# -> { ::Coverage.peek_result }.
+class Evilution::Coverage::Recorder
+  def initialize(target_files:, coverage_source: -> { ::Coverage.peek_result })
+    @target_files = target_files.to_a
+    @coverage_source = coverage_source
+    @index = Hash.new { |h, file| h[file] = Hash.new { |g, line| g[line] = [] } }
+    @executed = Hash.new { |h, file| h[file] = [] }
+  end
+
+  def around_example(example_location)
+    before = snapshot
+    result = yield
+    after = snapshot
+    attribute(before, after, example_location)
+    result
+  end
+
+  def to_map(built_files:)
+    Evilution::Coverage::Map.new(
+      index: materialize(@index),
+      built_files: built_files,
+      executed_lines: @executed.transform_values(&:uniq)
+    )
+  end
+
+  private
+
+  def snapshot
+    @coverage_source.call || {}
+  end
+
+  def attribute(before, after, example_location)
+    @target_files.each do |file|
+      after_counts = line_counts(after[file])
+      next unless after_counts
+
+      record_executed(file, after_counts)
+      record_increases(file, line_counts(before[file]) || [], after_counts, example_location)
+    end
+  end
+
+  # Every line with a non-zero count in the after-snapshot has run at least once
+  # by now -- including lines covered only at load (a `def` line is already > 0
+  # in the first example's after-snapshot). Recording them lets the Map tell a
+  # load-covered line from a line that never ran.
+  def record_executed(file, after_counts)
+    after_counts.each_with_index do |count, idx|
+      next if count.nil? || count.zero?
+
+      @executed[file] << (idx + 1)
+    end
+  end
+
+  # Credit example_location with every line whose execution count rose between
+  # the before/after snapshots (a newly-executed, executable line).
+  def record_increases(file, before_counts, after_counts, example_location)
+    after_counts.each_with_index do |count, idx|
+      next if count.nil? || count.zero?
+      next unless count > (before_counts[idx] || 0)
+
+      @index[file][idx + 1] << example_location
+    end
+  end
+
+  # Coverage.peek_result yields per-file line counts either as a bare array
+  # (legacy Coverage.start) or as a { lines: [...] } hash (Coverage.start with
+  # lines:/branches:/methods: modes). Normalize to the bare counts array.
+  def line_counts(entry)
+    entry.is_a?(Hash) ? entry[:lines] : entry
+  end
+
+  def materialize(index)
+    index.each_with_object({}) do |(file, lines), out|
+      out[file] = lines.each_with_object({}) { |(line, locs), inner| inner[line] = locs }
+    end
+  end
+end

data/lib/evilution/coverage.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require_relative "../evilution"
+
+# Per-example line-coverage support: build a `source file:line -> [examples]`
+# map so mutation targeting can run exactly the examples that execute a line.
+module Evilution::Coverage
+end

data/lib/evilution/coverage_example_filter.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative "../evilution"
+require_relative "coverage/map"
+
+# Per-mutation example targeting backed by a real line-coverage Map (EV-ndjd).
+# Honours the same contract as the lexical Evilution::ExampleFilter --
+# call(mutation, spec_paths) -> Array[location] | spec_paths | nil -- so it drops
+# straight into the existing ExampleFilter seam.
+#
+# Resolution order for the mutated source file F at line L:
+#   - F not fully built in the map (digest miss / partial build) -> delegate to
+#     the lexical filter (safe fallback) with the original spec_paths.
+#   - F built and L covered by examples -> run exactly those covering examples
+#     (a SUBSET of what the resolved spec runs, so a strict speedup that cannot
+#     lose a kill full-file would catch).
+#   - F not built, or L attributed to no example -> defer to lexical/full-file.
+#
+# Accuracy-first: coverage ONLY narrows the example set when it positively knows
+# the covering examples. It never marks a mutation :unresolved on "no coverage" --
+# on real repos a line can be exercised indirectly (before(:all), load time, a
+# spec the per-example diff did not attribute), and asserting a gap there loses
+# kills (EV-7uui validation). When coverage has no answer, the proven lexical
+# path decides.
+class Evilution::CoverageExampleFilter
+  def initialize(map:, lexical:, project_root: Evilution::PROJECT_ROOT)
+    @map = map
+    @lexical = lexical
+    @project_root = project_root.to_s
+  end
+
+  def call(mutation, spec_paths)
+    file = File.expand_path(mutation.file_path, @project_root)
+    return @lexical.call(mutation, spec_paths) unless @map.built?(file)
+
+    examples = @map.examples_for(file, mutation.line)
+    return examples unless examples.empty?
+
+    @lexical.call(mutation, spec_paths)
+  end
+end

data/lib/evilution/integration/loading/test_load_path.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require_relative "../loading"
+
+# Mirrors `ruby -Itest` / `-Ispec` for in-process test loading.
+#
+# evilution loads resolved test files with Kernel#load instead of shelling out,
+# so the `-Itest` shown in the displayed command string is never actually
+# applied to $LOAD_PATH. Minitest and Test::Unit suites near-universally
+# `require "test_helper"` (which the suite's own runner satisfies via -Itest);
+# without the test root on $LOAD_PATH that bare require raises LoadError and
+# every mutation errors with score 0.0 (EV-52hf / GH #1326).
+#
+# Anchors against Evilution.project_base_dir, which resolves to PROJECT_ROOT
+# inside an isolated worker (EV-wqxu / GH #1278) and Dir.pwd otherwise, so the
+# same call works on both the baseline (parent) and mutation (child) paths.
+module Evilution::Integration::Loading::TestLoadPath
+  ROOT_NAMES = %w[test spec].freeze
+
+  module_function
+
+  # Prepend every relevant test directory to $LOAD_PATH (idempotently).
+  # Iterate in reverse so the first entry from #dirs_for ends up frontmost,
+  # preserving its order (mirrors how `ruby -Ia -Ib` lands a before b).
+  def add!(files, base: Evilution.project_base_dir)
+    dirs_for(files, base).reverse_each do |dir|
+      $LOAD_PATH.unshift(dir) unless $LOAD_PATH.include?(dir)
+    end
+  end
+
+  # The directories to put on $LOAD_PATH for the given resolved test files:
+  # the conventional test/ and spec/ roots under base, each file's own
+  # directory, and the topmost test/spec ancestor of each file (covers nested
+  # layouts like test/unit, spec/lib, spec/unit). Existing directories only,
+  # and only those inside the project base -- never a broad outside-project dir
+  # (e.g. a /tmp test file), which would over-widen $LOAD_PATH for the whole
+  # process (the baseline runs in the long-lived parent).
+  def dirs_for(files, base)
+    base = File.expand_path(base)
+    dirs = conventional_roots(base)
+    Array(files).each do |file|
+      file_dir = File.dirname(File.expand_path(file, base))
+      dirs << file_dir
+      root = root_ancestor(file_dir, base)
+      dirs << root if root
+    end
+    dirs.uniq.select { |dir| File.directory?(dir) && within?(dir, base) }
+  end
+
+  def within?(dir, base)
+    dir == base || dir.start_with?("#{base}/")
+  end
+
+  def conventional_roots(base)
+    ROOT_NAMES.map { |name| File.join(base, name) }
+  end
+
+  # Walk from `dir` up to `base`, returning the highest ancestor whose basename
+  # is a conventional test root (test/spec). Highest, so test/unit/foo_test.rb
+  # yields `test` (matching -Itest), not the intermediate test/unit.
+  def root_ancestor(dir, base)
+    base = File.expand_path(base)
+    found = nil
+    current = File.expand_path(dir)
+    loop do
+      found = current if ROOT_NAMES.include?(File.basename(current))
+      break if current == base
+
+      parent = File.dirname(current)
+      break if parent == current
+
+      current = parent
+    end
+    found
+  end
+end

data/lib/evilution/integration/minitest.rb

@@ -3,6 +3,7 @@
 require "stringio"
 require_relative "base"
 require_relative "minitest_crash_detector"
+require_relative "loading/test_load_path"
 require_relative "../spec_resolver"
 require_relative "../spec_selector"
 
@@ -18,7 +19,9 @@ class Evilution::Integration::Minitest < Evilution::Integration::Base
     require "stringio"
     stub_autorun!
     ::Minitest::Runnable.runnables.clear
-    baseline_test_files(test_file).each { |f| load(File.expand_path(f)) }
+    files = baseline_test_files(test_file)
+    Evilution::Integration::Loading::TestLoadPath.add!(files)
+    files.each { |f| load(File.expand_path(f)) }
     run_baseline_minitest
   end
 
@@ -128,6 +131,7 @@ class Evilution::Integration::Minitest < Evilution::Integration::Base
   end
 
   def execute_minitest(mutation, files, command)
+    Evilution::Integration::Loading::TestLoadPath.add!(files)
     files.each { |f| load(File.expand_path(f, Evilution.project_base_dir)) }
 
     detector = reset_crash_detector

data/lib/evilution/integration/rspec/state_guard/configuration_state.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require_relative "../../rspec"
+
+# Restores the RSpec.configuration state that ::RSpec::Core::Runner.run mutates
+# on the shared singleton during an in-process mutation run (EV-dwqw / GH #1343).
+#
+# The visible symptom was every SUBSEQUENT host example rendering its progress
+# dots without color (white instead of green). Root cause: the run's args carry
+# "--no-color", and ConfigurationOptions#configure applies it via
+# Configuration#force, which does `@preferred_options.merge!(:color_mode => :off)`
+# IN PLACE. `Configuration#color_mode` reads `@preferred_options.fetch(:color_mode)`
+# first, so the host's color setting stays :off for the rest of the process.
+# Separately, Runner#setup points `output_stream`/`error_stream` (attr_writers,
+# i.e. the @output_stream/@error_stream ivars) at the run's throwaway StringIOs.
+#
+# Forked runs never leak these (the mutation happens in a child that dies); only
+# the in-process isolation path mutates the host's own configuration.
+#
+# @preferred_options is mutated in place, so it is snapshotted by DUP and put
+# back by replacing the ivar; the stream ivars are reassigned during the run,
+# so capturing the original references is enough.
+class Evilution::Integration::RSpec::StateGuard::ConfigurationState
+  PREFERRED_OPTIONS = :@preferred_options
+  STREAM_IVARS = %i[@output_stream @error_stream].freeze
+  ALL_IVARS = [PREFERRED_OPTIONS, *STREAM_IVARS].freeze
+
+  # configuration is injectable for isolated unit testing; production uses the
+  # shared RSpec.configuration singleton.
+  def initialize(configuration: nil)
+    @configuration = configuration
+  end
+
+  def snapshot
+    config = configuration
+    state = {}
+    capture_preferred_options(config, state)
+    STREAM_IVARS.each do |ivar|
+      state[ivar] = config.instance_variable_get(ivar) if config.instance_variable_defined?(ivar)
+    end
+    state
+  end
+
+  # Restore exactly the pre-run state: ivars present at snapshot get their value
+  # back; ivars created by the run but absent before are removed, so nothing the
+  # run introduced can leak into the host either.
+  def release(captured)
+    return unless captured
+
+    config = configuration
+    ALL_IVARS.each do |ivar|
+      if captured.key?(ivar)
+        config.instance_variable_set(ivar, captured[ivar])
+      elsif config.instance_variable_defined?(ivar)
+        config.remove_instance_variable(ivar)
+      end
+    end
+  end
+
+  private
+
+  def configuration
+    @configuration || ::RSpec.configuration
+  end
+
+  def capture_preferred_options(config, state)
+    return unless config.instance_variable_defined?(PREFERRED_OPTIONS)
+
+    value = config.instance_variable_get(PREFERRED_OPTIONS)
+    state[PREFERRED_OPTIONS] = value.is_a?(Hash) ? value.dup : value
+  end
+end

data/lib/evilution/integration/rspec/state_guard/configuration_streams.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative "../../rspec"
+require_relative "internals"
+
+# Restores the RSpec.configuration fields that ::RSpec::Core::Runner.run mutates
+# on the shared singleton during an in-process mutation run (EV-dwqw / GH #1343):
+#
+#   - @color_mode    -- the run's args carry "--no-color", flipping it to :off,
+#                       which makes every SUBSEQUENT host example render its
+#                       progress dots without color (white instead of green).
+#   - @output_stream -- Runner#setup swaps it to the run's StringIO whenever the
+#                       host's was $stdout.
+#   - @error_stream  -- likewise pointed at the run's StringIO.
+#
+# Forked runs never leak these (the mutation happens in a child that dies), but
+# the in-process isolation path mutates the host's own configuration. Restore by
+# writing the ivars directly: configuration#output_stream= is guarded (it warns
+# and no-ops once a reporter exists), so the public setter cannot put it back.
+class Evilution::Integration::RSpec::StateGuard::ConfigurationStreams
+  IVARS = %i[@color_mode @output_stream @error_stream].freeze
+
+  def snapshot
+    config = ::RSpec.configuration
+    IVARS.each_with_object({}) do |ivar, acc|
+      acc[ivar] = config.instance_variable_get(ivar) if config.instance_variable_defined?(ivar)
+    end
+  end
+
+  # Restore exactly the pre-run state: ivars present at snapshot get their value
+  # back; ivars that were absent before but created by the run are removed, so a
+  # newly-defined ivar can't leak into the host either.
+  def release(captured)
+    return unless captured
+
+    config = ::RSpec.configuration
+    IVARS.each do |ivar|
+      if captured.key?(ivar)
+        config.instance_variable_set(ivar, captured[ivar])
+      elsif config.instance_variable_defined?(ivar)
+        config.remove_instance_variable(ivar)
+      end
+    end
+  end
+end

data/lib/evilution/integration/rspec/state_guard.rb

@@ -7,6 +7,7 @@ require_relative "state_guard/world_sources_by_path"
 require_relative "state_guard/world_filtered_examples"
 require_relative "state_guard/reporter_arrays"
 require_relative "state_guard/example_groups_constants"
+require_relative "state_guard/configuration_state"
 
 class Evilution::Integration::RSpec::StateGuard
   DEFAULT_STRATEGIES = [
@@ -15,7 +16,8 @@ class Evilution::Integration::RSpec::StateGuard
     WorldSourcesByPath.new,
     WorldFilteredExamples.new,
     ReporterArrays.new,
-    ExampleGroupsConstants.new
+    ExampleGroupsConstants.new,
+    ConfigurationState.new
   ].freeze
 
   def initialize(strategies: DEFAULT_STRATEGIES)

data/lib/evilution/integration/test_unit.rb

@@ -2,6 +2,7 @@
 
 require_relative "base"
 require_relative "test_unit_crash_detector"
+require_relative "loading/test_load_path"
 require_relative "../spec_resolver"
 require_relative "../spec_selector"
 
@@ -40,8 +41,10 @@ class Evilution::Integration::TestUnit < Evilution::Integration::Base
     require_relative "test_unit/subject_class_registry"
     require_relative "test_unit/dispatcher"
     FrameworkLoader.new.call
+    files = baseline_test_files(test_file)
+    Evilution::Integration::Loading::TestLoadPath.add!(files)
     new_classes = SubjectClassRegistry.newly_loaded do
-      baseline_test_files(test_file).each { |f| load(File.expand_path(f)) }
+      files.each { |f| load(File.expand_path(f)) }
     end
     Dispatcher.call(new_classes, name: "evilution baseline").passed?
   end
@@ -89,9 +92,7 @@ class Evilution::Integration::TestUnit < Evilution::Integration::Base
   end
 
   def execute_test_unit(files, command)
-    new_classes = SubjectClassRegistry.newly_loaded do
-      files.each { |f| load(File.expand_path(f, Evilution.project_base_dir)) }
-    end
+    new_classes = load_test_classes(files)
     return ResultBuilder.no_tests_ran(command) if Dispatcher.test_method_count(new_classes).zero?
 
     detector = reset_crash_detector
@@ -100,6 +101,13 @@ class Evilution::Integration::TestUnit < Evilution::Integration::Base
     ResultBuilder.call(passed: result.passed?, command: command, detector: detector)
   end
 
+  def load_test_classes(files)
+    Evilution::Integration::Loading::TestLoadPath.add!(files)
+    SubjectClassRegistry.newly_loaded do
+      files.each { |f| load(File.expand_path(f, Evilution.project_base_dir)) }
+    end
+  end
+
   # Test::Unit has no public registry-clear analogous to
   # Minitest::Runnable.runnables.clear. SubjectClassRegistry's newly_loaded
   # block scopes each dispatch to classes loaded in *this* round, so stale