evilution 0.24.0 → 0.26.0

data/lib/evilution/result/mutation_result.rb

@@ -3,7 +3,7 @@
 require_relative "../result"
 
 class Evilution::Result::MutationResult
-  STATUSES = %i[killed survived timeout error neutral equivalent unresolved].freeze
+  STATUSES = %i[killed survived timeout error neutral equivalent unresolved unparseable].freeze
 
   attr_reader :mutation, :status, :duration, :killing_test, :test_command,
               :child_rss_kb, :memory_delta_kb, :parent_rss_kb,
@@ -58,4 +58,8 @@ class Evilution::Result::MutationResult
   def unresolved?
     status == :unresolved
   end
+
+  def unparseable?
+    status == :unparseable
+  end
 end

data/lib/evilution/result/summary.rb

@@ -51,8 +51,16 @@ class Evilution::Result::Summary
     results.count(&:unresolved?)
   end
 
+  def unparseable
+    results.count(&:unparseable?)
+  end
+
+  def score_denominator
+    total - errors - neutral - equivalent - unresolved - unparseable
+  end
+
   def score
-    denominator = total - errors - neutral - equivalent - unresolved
+    denominator = score_denominator
     return 0.0 if denominator.zero?
 
     killed.to_f / denominator
@@ -82,6 +90,10 @@ class Evilution::Result::Summary
     results.select(&:unresolved?)
   end
 
+  def unparseable_results
+    results.select(&:unparseable?)
+  end
+
   def coverage_gaps
     Evilution::Result::CoverageGapGrouper.new.call(survived_results)
   end

data/lib/evilution/runner/baseline_runner.rb

@@ -4,6 +4,9 @@ require_relative "../baseline"
 require_relative "../spec_resolver"
 require_relative "../integration/rspec"
 require_relative "../integration/minitest"
+require_relative "../example_filter"
+require_relative "../spec_ast_cache"
+require_relative "../source_ast_cache"
 
 class Evilution::Runner; end unless defined?(Evilution::Runner) # rubocop:disable Lint/EmptyClass
 
@@ -29,8 +32,16 @@ class Evilution::Runner::BaselineRunner
   def build_integration
     klass = integration_class
     test_files = config.spec_files.empty? ? nil : config.spec_files
-    kwargs = { test_files: test_files, hooks: hooks, fallback_to_full_suite: config.fallback_to_full_suite? }
-    kwargs[:related_specs_heuristic] = config.related_specs_heuristic? if klass == Evilution::Integration::RSpec
+    kwargs = {
+      test_files: test_files,
+      hooks: hooks,
+      fallback_to_full_suite: config.fallback_to_full_suite?,
+      spec_selector: config.spec_selector
+    }
+    if klass == Evilution::Integration::RSpec
+      kwargs[:related_specs_heuristic] = config.related_specs_heuristic?
+      kwargs[:example_filter] = build_example_filter
+    end
     klass.new(**kwargs)
   end
 
@@ -56,6 +67,16 @@ class Evilution::Runner::BaselineRunner
 
   attr_reader :config, :hooks
 
+  def build_example_filter
+    return nil unless config.example_targeting?
+
+    Evilution::ExampleFilter.new(
+      cache: Evilution::SpecAstCache.new(**config.example_targeting_cache),
+      fallback: config.example_targeting_fallback,
+      source_cache: Evilution::SourceAstCache.new
+    )
+  end
+
   def log_start
     return if config.quiet || !config.text? || !$stderr.tty?
 

data/lib/evilution/runner/isolation_resolver.rb

@@ -30,10 +30,10 @@ class Evilution::Runner::IsolationResolver
 
   def perform_preload
     return if config.preload == false
-    return unless resolve_isolation == :fork
 
     path = resolve_preload_path
     return unless path
+    return unless should_preload?
 
     prepare_load_path_for_preload
     require File.expand_path(path)
@@ -48,6 +48,17 @@ class Evilution::Runner::IsolationResolver
 
   attr_reader :config, :hooks
 
+  # Under :fork, allow preloading — caller resolves whether a path exists (an
+  # explicit --preload / preload: value, or an auto-detected rails_helper) and
+  # bails early when none does. Under :in_process, only allow preloading when
+  # the user explicitly asked via --preload or preload: in YAML — don't
+  # auto-load spec/rails_helper.rb for a user who opted out of fork.
+  def should_preload?
+    return true if resolve_isolation == :fork
+
+    config.preload.is_a?(String)
+  end
+
   def target_files
     @target_files ||= @target_files_callback.call
   end

data/lib/evilution/runner/mutation_executor.rb

@@ -40,11 +40,9 @@ class Evilution::Runner::MutationExecutor
     truncated = false
 
     mutations.each_with_index do |mutation, index|
-      result = execute_or_fetch(mutation) do
-        test_command = ->(m) { integration.call(m) }
-        isolator.call(mutation: mutation, test_command: test_command, timeout: config.timeout)
-      end
+      result = execute_one(mutation, integration)
       mutation.strip_sources!
+      result = neutralize_if_infra_error(result)
       result = neutralize_if_baseline_failed(result, baseline_result, spec_resolver)
       results << result
       survived_count += 1 if result.survived?
@@ -109,6 +107,7 @@ class Evilution::Runner::MutationExecutor
 
   def process_batch(batch_results, baseline_result, spec_resolver, state)
     batch_results.each do |result|
+      result = neutralize_if_infra_error(result)
       result = neutralize_if_baseline_failed(result, baseline_result, spec_resolver)
       state[:results] << result
       state[:survived_count] += 1 if result.survived?
@@ -120,17 +119,56 @@ class Evilution::Runner::MutationExecutor
     state[:truncated] = true if should_truncate?(state[:survived_count])
   end
 
-  def neutralize_if_baseline_failed(result, baseline_result, spec_resolver)
-    return result unless result.survived? && baseline_result && baseline_result.failed?
+  # Reclassify results as :neutral when the failure was caused by test
+  # infrastructure rather than by the mutation. Two independent paths:
+  #
+  # 1) :error from a missing require / spec_helper / rails_helper / spec/support
+  #    initialization — detected by error_class ∈ INFRA_ERROR_CLASSES and
+  #    first backtrace frame matching INFRA_BACKTRACE_PATHS. Origin-only match
+  #    (not `any?`): Ruby backtraces typically carry spec_helper frames below
+  #    mutation-caused errors, so matching any frame would misclassify real
+  #    mutation NameError/LoadError as :neutral.
+  #
+  # 2) :killed from a CrashDetector test_crashed whose sole crash class is in
+  #    INFRA_CRASH_CLASSES (ActiveRecord::StatementTimeout, Timeout::Error,
+  #    etc.). These surface under parallel workers sharing a DB file or on a
+  #    slow CI; fork.rb initially reports them as :killed, and without this
+  #    demotion the kill count inflates with infra noise. No backtrace check:
+  #    the single-class signal from CrashDetector already rules out mixed
+  #    mutation-caused failures. See EV-toid / GH #814.
+  INFRA_ERROR_CLASSES = %w[LoadError NameError].freeze
+  INFRA_BACKTRACE_PATHS = %r{(?:^|/)(?:spec_helper\.rb|rails_helper\.rb|spec/support/)}
+  INFRA_CRASH_CLASSES = %w[
+    Timeout::Error
+    ActiveRecord::StatementTimeout
+    ActiveRecord::Deadlocked
+    ActiveRecord::ConnectionTimeoutError
+    ActiveRecord::LockWaitTimeout
+    SQLite3::BusyException
+  ].freeze
+  private_constant :INFRA_ERROR_CLASSES, :INFRA_BACKTRACE_PATHS, :INFRA_CRASH_CLASSES
+
+  def neutralize_if_infra_error(result)
+    return neutralize(result) if infra_crash?(result)
+    return result unless result.error?
+    return result unless INFRA_ERROR_CLASSES.include?(result.error_class)
+    return result unless infra_origin?(result.error_backtrace)
+
+    neutralize(result)
+  end
 
-    if config.spec_files.any?
-      neutralize = true
-    else
-      spec_file = spec_resolver.call(result.mutation.file_path) || baseline_runner.neutralization_fallback_dir
-      neutralize = baseline_result.failed_spec_files.include?(spec_file)
-    end
-    return result unless neutralize
+  def infra_crash?(result)
+    result.killed? && INFRA_CRASH_CLASSES.include?(result.error_class)
+  end
+
+  def infra_origin?(backtrace)
+    frames = Array(backtrace)
+    return false if frames.empty?
+
+    frames.first =~ INFRA_BACKTRACE_PATHS ? true : false
+  end
 
+  def neutralize(result)
     Evilution::Result::MutationResult.new(
       mutation: result.mutation,
       status: :neutral,
@@ -145,6 +183,20 @@ class Evilution::Runner::MutationExecutor
     )
   end
 
+  def neutralize_if_baseline_failed(result, baseline_result, spec_resolver)
+    return result unless result.survived? && baseline_result && baseline_result.failed?
+
+    if config.spec_files.any?
+      should_neutralize = true
+    else
+      spec_file = spec_resolver.call(result.mutation.file_path) || baseline_runner.neutralization_fallback_dir
+      should_neutralize = baseline_result.failed_spec_files.include?(spec_file)
+    end
+    return result unless should_neutralize
+
+    neutralize(result)
+  end
+
   def compact_result(result)
     {
       status: result.status,
@@ -187,6 +239,11 @@ class Evilution::Runner::MutationExecutor
     cached_results = {}
 
     batch.each_with_index do |mutation, i|
+      if mutation.unparseable?
+        cached_results[i] = compact_result(build_unparseable_result(mutation))
+        next
+      end
+
       cached = fetch_cached_result(mutation)
       if cached
         cached_results[i] = compact_result(cached)
@@ -198,6 +255,19 @@ class Evilution::Runner::MutationExecutor
     [uncached_indices, cached_results]
   end
 
+  def execute_one(mutation, integration)
+    return build_unparseable_result(mutation) if mutation.unparseable?
+
+    execute_or_fetch(mutation) do
+      test_command = ->(m) { integration.call(m) }
+      isolator.call(mutation: mutation, test_command: test_command, timeout: config.timeout)
+    end
+  end
+
+  def build_unparseable_result(mutation)
+    Evilution::Result::MutationResult.new(mutation: mutation, status: :unparseable)
+  end
+
   def merge_parallel_results(batch, uncached_indices, cached_results, worker_results)
     result_map = cached_results.dup
     uncached_indices.each_with_index { |batch_idx, worker_idx| result_map[batch_idx] = worker_results[worker_idx] }

data/lib/evilution/runner/subject_pipeline.rb

@@ -20,13 +20,7 @@ class Evilution::Runner::SubjectPipeline
   end
 
   def target_files
-    @target_files ||= if source_glob_target?
-                        resolve_source_glob
-                      elsif !config.target_files.empty?
-                        config.target_files
-                      else
-                        Evilution::Git::ChangedFiles.new.call
-                      end
+    @target_files ||= resolve_target_files
   end
 
   private
@@ -88,11 +82,27 @@ class Evilution::Runner::SubjectPipeline
 
   def filter_by_target(subjects)
     matched = subjects.select(&target_matcher)
-    raise Evilution::Error, "no method found matching '#{config.target}'" if matched.empty?
+    raise Evilution::Error, build_no_match_error if matched.empty?
 
     matched
   end
 
+  def resolve_target_files
+    return resolve_source_glob if source_glob_target?
+    return config.target_files unless config.target_files.empty?
+
+    @used_git_fallback = true
+    Evilution::Git::ChangedFiles.new.call
+  end
+
+  def build_no_match_error
+    base = "no subject matched '#{config.target}'"
+    return base unless @used_git_fallback
+
+    "#{base}; scanned git-changed files only. Pass file paths or " \
+      "--target source:<glob> to scan the full codebase."
+  end
+
   def target_matcher
     target = config.target
     if target.end_with?("*")

data/lib/evilution/runner.rb

@@ -21,6 +21,7 @@ require_relative "parallel/pool"
 require_relative "session/store"
 require_relative "temp_dir_tracker"
 require_relative "rails_detector"
+require_relative "parallel_db_warning"
 require_relative "runner/subject_pipeline"
 require_relative "runner/mutation_planner"
 require_relative "runner/isolation_resolver"
@@ -43,6 +44,7 @@ class Evilution::Runner
 
   def call
     install_signal_handlers
+    emit_parallel_db_warning
     start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
 
     subjects = subject_pipeline.call
@@ -150,6 +152,10 @@ class Evilution::Runner
     mutation_executor.call(mutations, baseline_result)
   end
 
+  def emit_parallel_db_warning
+    Evilution::ParallelDbWarning.warn_if_sqlite_parallel(config)
+  end
+
   def install_signal_handlers
     %w[INT TERM].each { |sig| install_signal_handler(sig) }
   end

data/lib/evilution/source_ast_cache.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "digest"
+require "prism"
+require_relative "../evilution"
+
+# Content-hash-keyed LRU of Prism::ParseResult. Different source bytes always
+# yield a different key, so the cache is valid for the lifetime of the process.
+class Evilution::SourceAstCache
+  DEFAULT_MAX_ENTRIES = 50
+  private_constant :DEFAULT_MAX_ENTRIES
+
+  def initialize(max_entries: DEFAULT_MAX_ENTRIES)
+    @max_entries = max_entries
+    @entries = {}
+  end
+
+  def fetch(source)
+    return Prism.parse(source) if @max_entries <= 0
+
+    key = Digest::SHA256.digest(source)
+    if @entries.key?(key)
+      result = @entries.delete(key)
+      @entries[key] = result
+      return result
+    end
+
+    result = Prism.parse(source)
+    @entries[key] = result
+    evict_until_within_bounds
+    result
+  end
+
+  private
+
+  def evict_until_within_bounds
+    @entries.shift while @entries.length > @max_entries
+  end
+end

data/lib/evilution/spec_ast_cache.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+require "prism"
+require_relative "../evilution"
+
+class Evilution::SpecAstCache
+  Block = Struct.new(:kind, :line, :end_line, :body_text)
+
+  BLOCK_METHODS = %i[
+    describe context fcontext xcontext
+    it fit xit specify
+    before after
+  ].freeze
+  private_constant :BLOCK_METHODS
+
+  DEFAULT_MAX_FILES = 50
+  DEFAULT_MAX_BLOCKS = 10_000
+  private_constant :DEFAULT_MAX_FILES, :DEFAULT_MAX_BLOCKS
+
+  def initialize(max_files: DEFAULT_MAX_FILES, max_blocks: DEFAULT_MAX_BLOCKS)
+    @max_files = max_files
+    @max_blocks = max_blocks
+    @entries = {}
+    @total_blocks = 0
+  end
+
+  def fetch(path)
+    if @entries.key?(path)
+      blocks = @entries.delete(path)
+      @entries[path] = blocks
+      return blocks
+    end
+
+    blocks = parse(path)
+    insert(path, blocks)
+    blocks
+  end
+
+  def cached?(path)
+    @entries.key?(path)
+  end
+
+  private
+
+  def insert(path, blocks)
+    @entries[path] = blocks
+    @total_blocks += blocks.length
+    evict_until_within_bounds
+  end
+
+  def evict_until_within_bounds
+    while @entries.length > @max_files || @total_blocks > @max_blocks
+      break if @entries.empty?
+
+      oldest_path = @entries.keys.first
+      evicted = @entries.delete(oldest_path)
+      @total_blocks -= evicted.length
+    end
+  end
+
+  def parse(path)
+    raise Evilution::ParseError.new("file not found: #{path}", file: path) unless File.exist?(path)
+
+    source = read_source(path)
+    result = Prism.parse(source)
+
+    if result.failure?
+      raise Evilution::ParseError.new(
+        "failed to parse #{path}: #{result.errors.map(&:message).join(", ")}",
+        file: path
+      )
+    end
+
+    comment_ranges = result.comments
+                           .map { |c| c.location.start_offset...c.location.end_offset }
+                           .sort_by(&:begin)
+    collector = BlockCollector.new(source, comment_ranges)
+    collector.visit(result.value)
+    collector.blocks
+  end
+
+  def read_source(path)
+    File.read(path)
+  rescue SystemCallError => e
+    raise Evilution::ParseError.new("cannot read #{path}: #{e.message}", file: path)
+  end
+
+  class BlockCollector < Prism::Visitor
+    attr_reader :blocks
+
+    def initialize(source, comment_ranges)
+      @source = source
+      @comment_ranges = comment_ranges
+      @blocks = []
+      super()
+    end
+
+    def visit_call_node(node)
+      @blocks << build_block(node) if block_method?(node)
+      super
+    end
+
+    private
+
+    def block_method?(node)
+      BLOCK_METHODS.include?(node.name) && node.block
+    end
+
+    def build_block(node)
+      location = node.location
+      Block.new(
+        node.name,
+        location.start_line,
+        location.end_line,
+        extract_body_text(node)
+      )
+    end
+
+    def extract_body_text(node)
+      block = node.block
+      return "" unless block
+
+      body = block.body
+      return "" unless body
+
+      start_off = body.location.start_offset
+      end_off = body.location.end_offset
+      slice = @source.byteslice(start_off, end_off - start_off) || ""
+      stripped = strip_comments(slice, start_off)
+      stripped.downcase
+    end
+
+    def strip_comments(slice, base_offset)
+      return slice if @comment_ranges.empty?
+
+      ranges = comment_ranges_within(base_offset, base_offset + slice.bytesize)
+      return slice if ranges.empty?
+
+      result = +""
+      cursor = base_offset
+      ranges.each do |range|
+        result << @source.byteslice(cursor, range.begin - cursor)
+        cursor = range.end
+      end
+      result << @source.byteslice(cursor, base_offset + slice.bytesize - cursor)
+      result
+    end
+
+    def comment_ranges_within(start_off, end_off)
+      lower = @comment_ranges.bsearch_index { |r| r.begin >= start_off }
+      return [] unless lower
+
+      result = []
+      idx = lower
+      while idx < @comment_ranges.length
+        range = @comment_ranges[idx]
+        break if range.begin >= end_off
+
+        result << range if range.end <= end_off
+        idx += 1
+      end
+      result
+    end
+  end
+  private_constant :BlockCollector
+end

data/lib/evilution/spec_resolver.rb

@@ -10,11 +10,12 @@ class Evilution::SpecResolver
     @request_dir = request_dir
   end
 
-  def call(source_path)
+  def call(source_path, spec_pattern: nil)
     return nil if source_path.nil? || source_path.empty?
 
     normalized = normalize_path(source_path)
     candidates = candidate_test_paths(normalized)
+    candidates = filter_by_pattern(candidates, spec_pattern) if spec_pattern
     candidates.find { |path| File.exist?(path) }
   end
 
@@ -24,6 +25,10 @@ class Evilution::SpecResolver
 
   private
 
+  def filter_by_pattern(candidates, pattern)
+    candidates.select { |path| File.fnmatch?(pattern, path, File::FNM_PATHNAME | File::FNM_EXTGLOB) }
+  end
+
   def normalize_path(path)
     path = path.delete_prefix("./")
     path = path.delete_prefix("#{Dir.pwd}/") if path.start_with?("/")

data/lib/evilution/spec_selector.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative "spec_resolver"
+
+class Evilution::SpecSelector
+  def initialize(spec_files: [], spec_mappings: {}, spec_pattern: nil, spec_resolver: Evilution::SpecResolver.new)
+    @spec_files = Array(spec_files)
+    @spec_mappings = spec_mappings || {}
+    @spec_pattern = spec_pattern
+    @spec_resolver = spec_resolver
+  end
+
+  def call(source_path)
+    return @spec_files unless @spec_files.empty?
+
+    mapped = mapping_for(source_path)
+    if mapped
+      existing = mapped.select { |path| File.exist?(path) }
+      return existing unless existing.empty?
+    end
+
+    resolved = @spec_resolver.call(source_path, spec_pattern: @spec_pattern)
+    resolved ? [resolved] : nil
+  end
+
+  private
+
+  def mapping_for(source_path)
+    @spec_mappings[normalize(source_path)]
+  end
+
+  def normalize(path)
+    return path if path.nil?
+
+    normalized = path.to_s
+    normalized = normalized.delete_prefix("#{Dir.pwd}/") if normalized.start_with?("/")
+    normalized.delete_prefix("./")
+  end
+end

data/lib/evilution/temp_dir_tracker.rb

@@ -21,9 +21,15 @@ module Evilution::TempDirTracker
   end
 
   def self.cleanup_all
-    @monitor.synchronize do
-      @dirs.each { |d| FileUtils.rm_rf(d) }
-      @dirs.clear
+    # Trap-safe: Signal.trap handlers forbid Monitor#synchronize, so both the
+    # snapshot and the per-dir tracking removal fall back to a lock-free path
+    # when ThreadError is raised. Successful removals drop the entry from
+    # @dirs; failures stay tracked so a later cleanup can retry.
+    snapshot_tracked_dirs.each do |d|
+      FileUtils.rm_rf(d)
+      remove_from_tracking(d)
+    rescue StandardError
+      nil
     end
   end
 
@@ -36,4 +42,18 @@ module Evilution::TempDirTracker
     @at_exit_registered = true
   end
   private_class_method :register_at_exit
+
+  def self.snapshot_tracked_dirs
+    @monitor.synchronize { @dirs.to_a }
+  rescue ThreadError
+    @dirs.to_a
+  end
+  private_class_method :snapshot_tracked_dirs
+
+  def self.remove_from_tracking(dir)
+    @monitor.synchronize { @dirs.delete(dir) }
+  rescue ThreadError
+    @dirs.delete(dir)
+  end
+  private_class_method :remove_from_tracking
 end

data/lib/evilution/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Evilution
-  VERSION = "0.24.0"
+  VERSION = "0.26.0"
 end

data/script/memory_check

@@ -7,8 +7,8 @@ require_relative "../lib/evilution/integration/rspec"
 
 FIXTURE = File.expand_path("../spec/support/fixtures/simple_class.rb", __dir__)
 FIXTURE_SPEC = File.expand_path("../spec/support/fixtures/simple_class_spec.rb", __dir__)
-COMPLEX_FIXTURE = File.expand_path("../lib/evilution/config.rb", __dir__)
-COMPLEX_FIXTURE_SPEC = File.expand_path("../spec/evilution/config_spec.rb", __dir__)
+COMPLEX_FIXTURE = File.expand_path("../spec/support/fixtures/memory_check/target.rb", __dir__)
+COMPLEX_FIXTURE_SPEC = File.expand_path("../spec/support/fixtures/memory_check/target_examples.rb", __dir__)
 ITERATIONS = Integer(ENV.fetch("MEMORY_CHECK_ITERATIONS", 50))
 MAX_GROWTH_KB = Integer(ENV.fetch("MEMORY_CHECK_MAX_GROWTH_KB", 10_240))
 
@@ -95,8 +95,10 @@ if mutations.size >= 2
 end
 
 # 5. RSpec integration per-mutation with complex fixture
-#    Uses Config (227 LOC, 73 specs, 564 mutations) for realistic per-mutation load:
-#    more ExampleGroup subclasses, deeper spec nesting, heavier metadata.
+#    Uses a frozen snapshot under spec/support/fixtures/memory_check/ for
+#    realistic per-mutation load: deep spec nesting, heavy metadata. Snapshot
+#    is intentional - decoupling the budget from project file growth so this
+#    check measures integration plumbing memory, not project size.
 complex_parser = Evilution::AST::Parser.new
 complex_registry = Evilution::Mutator::Registry.default
 complex_subjects = complex_parser.call(COMPLEX_FIXTURE)
@@ -105,7 +107,7 @@ complex_mutations = complex_subjects.flat_map { |s| complex_registry.mutations_f
 integration = Evilution::Integration::RSpec.new(test_files: [COMPLEX_FIXTURE_SPEC])
 
 # Budget is generous: per-mutation require() adds the file to $LOADED_FEATURES and
-# accumulates constant-redefinition warnings. Local runs land around 20-25 MB; CI
+# accumulates constant-redefinition warnings. Local runs land around 20 MB; CI
 # varies up to ~30 MB depending on Ruby build and GC pressure, so we leave headroom.
 all_passed &= run_check("RSpec integration per-mutation (Config)", iterations: 20, max_growth_kb: 40_960) do
   mutation = complex_mutations.sample