evilution 0.26.0 → 0.28.0

data/lib/evilution/reporter/suggestion/templates.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require_relative "../suggestion"
+
+module Evilution::Reporter::Suggestion::Templates
+end

data/lib/evilution/result/error_info.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative "../result"
+
+class Evilution::Result::ErrorInfo
+  attr_reader :message, :klass, :backtrace
+
+  def self.from_fields(message: nil, klass: nil, backtrace: nil)
+    return nil if message.nil? && klass.nil? && backtrace.nil?
+
+    new(message: message, klass: klass, backtrace: backtrace)
+  end
+
+  def initialize(message: nil, klass: nil, backtrace: nil)
+    @message = message
+    @klass = klass
+    @backtrace = backtrace.nil? ? nil : backtrace.dup.freeze
+    freeze
+  end
+end

data/lib/evilution/result/memory_stats.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative "../result"
+
+class Evilution::Result::MemoryStats
+  attr_reader :child_rss_kb, :memory_delta_kb, :parent_rss_kb
+
+  def self.from_fields(child_rss_kb: nil, memory_delta_kb: nil, parent_rss_kb: nil)
+    return nil if child_rss_kb.nil? && memory_delta_kb.nil? && parent_rss_kb.nil?
+
+    new(child_rss_kb: child_rss_kb, memory_delta_kb: memory_delta_kb, parent_rss_kb: parent_rss_kb)
+  end
+
+  def initialize(child_rss_kb: nil, memory_delta_kb: nil, parent_rss_kb: nil)
+    @child_rss_kb = child_rss_kb
+    @memory_delta_kb = memory_delta_kb
+    @parent_rss_kb = parent_rss_kb
+    freeze
+  end
+end

data/lib/evilution/result/mutation_result.rb

@@ -1,20 +1,16 @@
 # frozen_string_literal: true
 
 require_relative "../result"
+require_relative "error_info"
+require_relative "memory_stats"
 
 class Evilution::Result::MutationResult
   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,
-              :error_message, :error_class, :error_backtrace
+  attr_reader :mutation, :status, :duration, :killing_test, :test_command, :memory, :error
 
-  # rubocop:disable Metrics/ParameterLists
   def initialize(mutation:, status:, duration: 0.0, killing_test: nil,
-                 test_command: nil, child_rss_kb: nil, memory_delta_kb: nil,
-                 parent_rss_kb: nil, error_message: nil, error_class: nil,
-                 error_backtrace: nil)
-    # rubocop:enable Metrics/ParameterLists
+                 test_command: nil, memory: nil, error: nil)
     raise ArgumentError, "invalid status: #{status}" unless STATUSES.include?(status)
 
     @mutation = mutation
@@ -22,15 +18,35 @@ class Evilution::Result::MutationResult
     @duration = duration
     @killing_test = killing_test
     @test_command = test_command
-    @child_rss_kb = child_rss_kb
-    @memory_delta_kb = memory_delta_kb
-    @parent_rss_kb = parent_rss_kb
-    @error_message = error_message
-    @error_class = error_class
-    @error_backtrace = error_backtrace.nil? ? nil : error_backtrace.dup.freeze
+    @memory = memory
+    @error = error
     freeze
   end
 
+  def child_rss_kb
+    @memory.nil? ? nil : @memory.child_rss_kb
+  end
+
+  def memory_delta_kb
+    @memory.nil? ? nil : @memory.memory_delta_kb
+  end
+
+  def parent_rss_kb
+    @memory.nil? ? nil : @memory.parent_rss_kb
+  end
+
+  def error_message
+    @error.nil? ? nil : @error.message
+  end
+
+  def error_class
+    @error.nil? ? nil : @error.klass
+  end
+
+  def error_backtrace
+    @error.nil? ? nil : @error.backtrace
+  end
+
   def killed?
     status == :killed
   end

data/lib/evilution/runner/baseline_runner.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative "../runner"
 require_relative "../baseline"
 require_relative "../spec_resolver"
 require_relative "../integration/rspec"
@@ -8,8 +9,6 @@ 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
-
 unless defined?(Evilution::Runner::INTEGRATIONS)
   Evilution::Runner::INTEGRATIONS = {
     rspec: Evilution::Integration::RSpec,

data/lib/evilution/runner/diagnostics.rb

@@ -1,10 +1,9 @@
 # frozen_string_literal: true
 
+require_relative "../runner"
 require_relative "../memory"
 require_relative "../parallel/pool"
 
-class Evilution::Runner; end unless defined?(Evilution::Runner) # rubocop:disable Lint/EmptyClass
-
 class Evilution::Runner::Diagnostics
   def initialize(config, stderr: $stderr)
     @config = config

data/lib/evilution/runner/isolation_resolver.rb

@@ -1,14 +1,14 @@
 # frozen_string_literal: true
 
+require_relative "../runner"
 require_relative "../isolation/fork"
 require_relative "../isolation/in_process"
 require_relative "../rails_detector"
 
-class Evilution::Runner; end unless defined?(Evilution::Runner) # rubocop:disable Lint/EmptyClass
-
 class Evilution::Runner::IsolationResolver
   PRELOAD_CANDIDATES = [
     File.join("spec", "rails_helper.rb"),
+    File.join("spec", "spec_helper.rb"),
     File.join("test", "test_helper.rb")
   ].freeze
 
@@ -30,13 +30,15 @@ class Evilution::Runner::IsolationResolver
 
   def perform_preload
     return if config.preload == false
+    return unless should_preload?
 
     path = resolve_preload_path
     return unless path
-    return unless should_preload?
 
     prepare_load_path_for_preload
     require File.expand_path(path)
+  rescue Evilution::ConfigError
+    raise
   rescue ScriptError, StandardError => e
     raise Evilution::ConfigError.new(
       "failed to preload #{path.inspect}: #{e.class}: #{e.message}",
@@ -123,7 +125,11 @@ class Evilution::Runner::IsolationResolver
       abs = File.join(root, rel)
       return abs if File.file?(abs)
     end
-    nil
+
+    raise Evilution::ConfigError,
+          "Preload file not found. Tried: [#{PRELOAD_CANDIDATES.join(", ")}]. " \
+          "Pass --preload <file> or set preload: in .evilution.yml. " \
+          "Use --no-preload (or preload: false) to disable preloading entirely."
   end
 
   # When the user explicitly requests InProcess on a Rails project, warn once

data/lib/evilution/runner/mutation_executor/mutation_runner.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative "../mutation_executor"
+require_relative "../../result/mutation_result"
+
+class Evilution::Runner::MutationExecutor::MutationRunner
+  def initialize(config:, cache:, isolator:)
+    @config = config
+    @cache = cache
+    @isolator = isolator
+  end
+
+  def call(mutation, integration:)
+    return unparseable_result(mutation) if mutation.unparseable?
+
+    cached = @cache.fetch(mutation)
+    return cached if cached
+
+    test_command = ->(m) { integration.call(m) }
+    result = @isolator.call(mutation: mutation, test_command: test_command, timeout: @config.timeout)
+    @cache.store(mutation, result)
+    result
+  end
+
+  private
+
+  def unparseable_result(mutation)
+    Evilution::Result::MutationResult.new(mutation: mutation, status: :unparseable)
+  end
+end

data/lib/evilution/runner/mutation_executor/neutralization_pipeline.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative "../mutation_executor"
+
+class Evilution::Runner::MutationExecutor::NeutralizationPipeline
+  def initialize(neutralizers)
+    @neutralizers = neutralizers
+  end
+
+  def call(result, **ctx)
+    @neutralizers.reduce(result) do |acc, nz|
+      ctx.empty? ? nz.call(acc) : nz.call(acc, **ctx)
+    end
+  end
+end

data/lib/evilution/runner/mutation_executor/neutralizer/baseline_failed.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative "../neutralizer"
+require_relative "../../../result/mutation_result"
+
+class Evilution::Runner::MutationExecutor::Neutralizer::BaselineFailed
+  def initialize(config:, spec_resolver:, fallback_dir:)
+    @config = config
+    @spec_resolver = spec_resolver
+    @fallback_dir = fallback_dir
+  end
+
+  def call(result, baseline_result:)
+    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) || @fallback_dir
+      should_neutralize = baseline_result.failed_spec_files.include?(spec_file)
+    end
+    return result unless should_neutralize
+
+    neutralize(result)
+  end
+
+  private
+
+  def neutralize(result)
+    Evilution::Result::MutationResult.new(
+      mutation: result.mutation,
+      status: :neutral,
+      duration: result.duration,
+      test_command: result.test_command,
+      memory: result.memory,
+      error: result.error
+    )
+  end
+end

data/lib/evilution/runner/mutation_executor/neutralizer/infra_error.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require_relative "../neutralizer"
+require_relative "../../../result/mutation_result"
+
+# 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.
+class Evilution::Runner::MutationExecutor::Neutralizer::InfraError
+  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 call(result, **_ctx)
+    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
+
+  private
+
+  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,
+      duration: result.duration,
+      test_command: result.test_command,
+      memory: result.memory,
+      error: result.error
+    )
+  end
+end

data/lib/evilution/runner/mutation_executor/neutralizer.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative "../mutation_executor"
+
+# Namespace for MutationExecutor's neutralization rules (InfraError,
+# BaselineFailed). Concrete neutralizer classes live in neutralizer/*.rb and
+# are autoloaded on first reference.
+module Evilution::Runner::MutationExecutor::Neutralizer
+  autoload :InfraError, File.expand_path("neutralizer/infra_error", __dir__)
+  autoload :BaselineFailed, File.expand_path("neutralizer/baseline_failed", __dir__)
+end

data/lib/evilution/runner/mutation_executor/result_cache.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require_relative "../mutation_executor"
+require_relative "../../result/mutation_result"
+
+class Evilution::Runner::MutationExecutor::ResultCache
+  CACHEABLE_STATUSES = %i[killed timeout].freeze
+  private_constant :CACHEABLE_STATUSES
+
+  def initialize(backend)
+    @backend = backend
+  end
+
+  def fetch(mutation)
+    return nil unless @backend
+
+    data = @backend.fetch(mutation)
+    return nil unless data
+    return nil unless CACHEABLE_STATUSES.include?(data[:status])
+
+    Evilution::Result::MutationResult.new(
+      mutation: mutation,
+      status: data[:status],
+      duration: data[:duration],
+      killing_test: data[:killing_test],
+      test_command: data[:test_command]
+    )
+  end
+
+  def store(mutation, result)
+    return unless @backend
+    return unless result.killed? || result.timeout?
+
+    @backend.store(mutation,
+                   status: result.status,
+                   duration: result.duration,
+                   killing_test: result.killing_test,
+                   test_command: result.test_command)
+  end
+
+  def partition(batch, packer:)
+    uncached_indices = []
+    cached_results = {}
+
+    batch.each_with_index do |mutation, i|
+      if mutation.unparseable?
+        cached_results[i] = packer.compact(unparseable_result(mutation))
+        next
+      end
+
+      cached = fetch(mutation)
+      if cached
+        cached_results[i] = packer.compact(cached)
+      else
+        uncached_indices << i
+      end
+    end
+
+    [uncached_indices, cached_results]
+  end
+
+  private
+
+  def unparseable_result(mutation)
+    Evilution::Result::MutationResult.new(mutation: mutation, status: :unparseable)
+  end
+end

data/lib/evilution/runner/mutation_executor/result_notifier.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative "../mutation_executor"
+require_relative "../../reporter/progress_bar"
+
+class Evilution::Runner::MutationExecutor::ResultNotifier
+  def initialize(config, diagnostics:, on_result:)
+    @config = config
+    @diagnostics = diagnostics
+    @on_result = on_result
+    @survived_count = 0
+    @progress_bar = nil
+  end
+
+  attr_reader :survived_count
+
+  def start(total)
+    @survived_count = 0
+    @progress_bar = build_progress_bar(total)
+  end
+
+  def notify(result, index)
+    @on_result.call(result) if @on_result
+    @progress_bar.tick(status: result.status) if @progress_bar
+    @diagnostics.log_progress(index, result.status)
+    @diagnostics.log_mutation_diagnostics(result)
+    @survived_count += 1 if result.survived?
+    truncate? ? :truncate : :continue
+  end
+
+  def finish
+    @progress_bar.finish if @progress_bar
+  end
+
+  private
+
+  def truncate?
+    @config.fail_fast? && @survived_count >= @config.fail_fast
+  end
+
+  def build_progress_bar(total)
+    return nil if !@config.progress? || @config.quiet || @config.verbose || !@config.text? || !$stderr.tty?
+
+    Evilution::Reporter::ProgressBar.new(total: total, output: $stderr)
+  end
+end

data/lib/evilution/runner/mutation_executor/result_packer.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative "../mutation_executor"
+require_relative "../../result/mutation_result"
+
+class Evilution::Runner::MutationExecutor::ResultPacker
+  def compact(result)
+    {
+      status: result.status,
+      duration: result.duration,
+      killing_test: result.killing_test,
+      test_command: result.test_command,
+      child_rss_kb: result.child_rss_kb,
+      memory_delta_kb: result.memory_delta_kb,
+      parent_rss_kb: result.parent_rss_kb,
+      error_message: result.error_message,
+      error_class: result.error_class,
+      error_backtrace: result.error_backtrace
+    }
+  end
+
+  def rebuild(mutation, data)
+    Evilution::Result::MutationResult.new(
+      mutation: mutation,
+      status: data[:status],
+      duration: data[:duration],
+      killing_test: data[:killing_test],
+      test_command: data[:test_command],
+      memory: Evilution::Result::MemoryStats.from_fields(
+        child_rss_kb: data[:child_rss_kb],
+        memory_delta_kb: data[:memory_delta_kb],
+        parent_rss_kb: data[:parent_rss_kb]
+      ),
+      error: Evilution::Result::ErrorInfo.from_fields(
+        message: data[:error_message],
+        klass: data[:error_class],
+        backtrace: data[:error_backtrace]
+      )
+    )
+  end
+end

data/lib/evilution/runner/mutation_executor/strategy/parallel.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require_relative "../strategy"
+
+class Evilution::Runner::MutationExecutor::Strategy::Parallel
+  def initialize(cache:, isolator:, packer:, pipeline:, notifier:, pool_factory:, config:, diagnostics: nil)
+    @cache = cache
+    @isolator = isolator
+    @packer = packer
+    @pipeline = pipeline
+    @notifier = notifier
+    @pool_factory = pool_factory
+    @diagnostics = diagnostics
+    @config = config
+  end
+
+  def call(mutations, baseline_result:, integration:)
+    @notifier.start(mutations.length)
+    pool = @pool_factory.call
+    state = { results: [], truncated: false, completed: 0 }
+    all_worker_stats = []
+
+    mutations.each_slice(@config.jobs) do |batch|
+      break if state[:truncated]
+
+      batch_results = run_batch(batch, pool, integration)
+      all_worker_stats.concat(pool.worker_stats)
+      process_batch(batch_results, baseline_result, state)
+    end
+
+    @diagnostics.log_worker_stats(@diagnostics.aggregate_worker_stats(all_worker_stats)) if @diagnostics
+    @notifier.finish
+    [state[:results], state[:truncated]]
+  end
+
+  private
+
+  def run_batch(batch, pool, integration)
+    uncached_indices, cached_results = @cache.partition(batch, packer: @packer)
+    worker_results = run_uncached(batch, uncached_indices, pool, integration)
+    compact_results = merge(batch, uncached_indices, cached_results, worker_results)
+    batch_results = batch.zip(compact_results).map { |m, h| @packer.rebuild(m, h) }
+    uncached_indices.each { |i| @cache.store(batch_results[i].mutation, batch_results[i]) }
+    batch.each(&:strip_sources!)
+    batch_results
+  end
+
+  def run_uncached(batch, uncached_indices, pool, integration)
+    return [] if uncached_indices.empty?
+
+    uncached = uncached_indices.map { |i| batch[i] }
+    pool.map(uncached) do |mutation|
+      test_command = ->(m) { integration.call(m) }
+      result = @isolator.call(mutation: mutation, test_command: test_command, timeout: @config.timeout)
+      @packer.compact(result)
+    end
+  end
+
+  def merge(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] }
+    batch.each_index.map { |i| result_map[i] }
+  end
+
+  def process_batch(batch_results, baseline_result, state)
+    batch_results.each do |result|
+      result = @pipeline.call(result, baseline_result: baseline_result)
+      state[:results] << result
+      state[:completed] += 1
+      if @notifier.notify(result, state[:completed]) == :truncate
+        state[:truncated] = true
+        break
+      end
+    end
+
+    @diagnostics.log_memory("after batch", "#{state[:completed]} complete") if @diagnostics
+  end
+end

data/lib/evilution/runner/mutation_executor/strategy/sequential.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative "../strategy"
+
+class Evilution::Runner::MutationExecutor::Strategy::Sequential
+  def initialize(runner:, pipeline:, notifier:)
+    @runner = runner
+    @pipeline = pipeline
+    @notifier = notifier
+  end
+
+  def call(mutations, baseline_result:, integration:)
+    @notifier.start(mutations.length)
+    results = []
+    truncated = false
+
+    mutations.each_with_index do |mutation, index|
+      result = @runner.call(mutation, integration: integration)
+      mutation.strip_sources!
+      result = @pipeline.call(result, baseline_result: baseline_result)
+      results << result
+
+      if @notifier.notify(result, index + 1) == :truncate
+        truncated = true
+        break
+      end
+    end
+
+    @notifier.finish
+    [results, truncated]
+  end
+end

data/lib/evilution/runner/mutation_executor/strategy.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative "../mutation_executor"
+
+# Namespace for MutationExecutor's execution strategies (Sequential, Parallel).
+# Concrete strategy classes live in strategy/{sequential,parallel}.rb and are
+# autoloaded on first reference.
+module Evilution::Runner::MutationExecutor::Strategy
+  autoload :Sequential, File.expand_path("strategy/sequential", __dir__)
+  autoload :Parallel, File.expand_path("strategy/parallel", __dir__)
+end