evilution 0.26.0 → 0.28.0

data/lib/evilution/runner/mutation_executor.rb

@@ -1,325 +1,86 @@
 # frozen_string_literal: true
 
-require_relative "../parallel/pool"
-require_relative "../reporter/progress_bar"
-require_relative "../result/mutation_result"
-
-class Evilution::Runner; end unless defined?(Evilution::Runner) # rubocop:disable Lint/EmptyClass
+require_relative "../runner"
 
 class Evilution::Runner::MutationExecutor
+  autoload :ResultCache, File.expand_path("mutation_executor/result_cache", __dir__)
+  autoload :ResultPacker, File.expand_path("mutation_executor/result_packer", __dir__)
+  autoload :ResultNotifier, File.expand_path("mutation_executor/result_notifier", __dir__)
+  autoload :MutationRunner, File.expand_path("mutation_executor/mutation_runner", __dir__)
+  autoload :NeutralizationPipeline, File.expand_path("mutation_executor/neutralization_pipeline", __dir__)
+  autoload :Strategy, File.expand_path("mutation_executor/strategy", __dir__)
+  autoload :Neutralizer, File.expand_path("mutation_executor/neutralizer", __dir__)
+
   def initialize(config, isolator:, baseline_runner:, cache:, hooks:, diagnostics:, on_result: nil)
     @config = config
     @isolator = isolator
     @baseline_runner = baseline_runner
-    @cache = cache
+    @cache = ResultCache.new(cache)
+    @packer = ResultPacker.new
     @hooks = hooks
     @diagnostics = diagnostics
     @on_result = on_result
   end
 
   def call(mutations, baseline_result = nil)
-    @progress_bar = build_progress_bar(mutations.length)
-    result = if config.jobs > 1
-               run_parallel(mutations, baseline_result)
-             else
-               run_sequential(mutations, baseline_result)
-             end
-    @progress_bar&.finish
-    result
+    integration = @baseline_runner.build_integration
+    spec_resolver = baseline_failed?(baseline_result) ? @baseline_runner.neutralization_resolver : nil
+    notifier = build_notifier
+    pipeline = build_pipeline(spec_resolver)
+    strategy = @config.jobs > 1 ? build_parallel(notifier, pipeline) : build_sequential(notifier, pipeline)
+
+    strategy.call(mutations, baseline_result: baseline_result, integration: integration)
   end
 
   private
 
-  attr_reader :config, :isolator, :baseline_runner, :cache, :hooks, :diagnostics, :on_result
-
-  def run_sequential(mutations, baseline_result)
-    integration = baseline_runner.build_integration
-    spec_resolver = baseline_result&.failed? ? baseline_runner.neutralization_resolver : nil
-    results = []
-    survived_count = 0
-    truncated = false
-
-    mutations.each_with_index do |mutation, index|
-      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?
-      notify_result(result, index + 1)
-
-      if config.fail_fast? && survived_count >= config.fail_fast
-        truncated = true
-        break
-      end
-    end
-
-    [results, truncated]
+  def baseline_failed?(baseline_result)
+    baseline_result && baseline_result.failed?
   end
 
-  def run_parallel(mutations, baseline_result)
-    integration = baseline_runner.build_integration
-    pool = build_pool
-    spec_resolver = baseline_result&.failed? ? baseline_runner.neutralization_resolver : nil
-    state = { results: [], survived_count: 0, truncated: false, completed: 0 }
-    all_worker_stats = []
-
-    mutations.each_slice(config.jobs) do |batch|
-      break if state[:truncated]
-
-      batch_results = run_parallel_batch(batch, pool, isolator, integration)
-      all_worker_stats.concat(pool.worker_stats)
-      process_batch(batch_results, baseline_result, spec_resolver, state)
-    end
-
-    diagnostics.log_worker_stats(diagnostics.aggregate_worker_stats(all_worker_stats))
-    [state[:results], state[:truncated]]
+  def build_notifier
+    ResultNotifier.new(@config, diagnostics: @diagnostics, on_result: @on_result)
   end
 
-  def build_pool
-    Evilution::Parallel::Pool.new(
-      size: config.jobs,
-      hooks: hooks,
-      item_timeout: config.timeout ? config.timeout * 2 : nil
+  def build_pipeline(spec_resolver)
+    NeutralizationPipeline.new(
+      [
+        Neutralizer::InfraError.new,
+        Neutralizer::BaselineFailed.new(
+          config: @config,
+          spec_resolver: spec_resolver || ->(_f) {},
+          fallback_dir: @baseline_runner.neutralization_fallback_dir
+        )
+      ]
     )
   end
 
-  def run_parallel_batch(batch, pool, worker_isolator, integration)
-    uncached_indices, cached_results = partition_cached(batch)
-    worker_results = run_uncached_workers(batch, uncached_indices, pool, worker_isolator, integration)
-    compact_results = merge_parallel_results(batch, uncached_indices, cached_results, worker_results)
-    batch.each(&:strip_sources!)
-    batch_results = rebuild_results(batch, compact_results)
-    batch_results.each { |r| store_cached_result(r.mutation, r) }
-    batch_results
-  end
-
-  def run_uncached_workers(batch, uncached_indices, pool, worker_isolator, 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 = worker_isolator.call(mutation: mutation, test_command: test_command, timeout: config.timeout)
-      compact_result(result)
-    end
-  end
-
-  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?
-      state[:completed] += 1
-      notify_result(result, state[:completed])
-    end
-
-    diagnostics.log_memory("after batch", "#{state[:completed]} complete")
-    state[:truncated] = true if should_truncate?(state[:survived_count])
-  end
-
-  # 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
-
-  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,
-      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
+  def build_sequential(notifier, pipeline)
+    Strategy::Sequential.new(
+      runner: MutationRunner.new(config: @config, cache: @cache, isolator: @isolator),
+      pipeline: pipeline,
+      notifier: notifier
     )
   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,
-      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_results(batch, compact_results)
-    batch.zip(compact_results).map do |mutation, data|
-      Evilution::Result::MutationResult.new(
-        mutation: mutation,
-        status: data[:status],
-        duration: data[:duration],
-        killing_test: data[:killing_test],
-        test_command: data[:test_command],
-        child_rss_kb: data[:child_rss_kb],
-        memory_delta_kb: data[:memory_delta_kb],
-        parent_rss_kb: data[:parent_rss_kb],
-        error_message: data[:error_message],
-        error_class: data[:error_class],
-        error_backtrace: data[:error_backtrace]
-      )
-    end
-  end
-
-  def should_truncate?(survived_count)
-    config.fail_fast? && survived_count >= config.fail_fast
-  end
-
-  def partition_cached(batch)
-    uncached_indices = []
-    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)
-      else
-        uncached_indices << i
-      end
-    end
-
-    [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] }
-    batch.each_index.map { |i| result_map[i] }
-  end
-
-  def execute_or_fetch(mutation)
-    cached = fetch_cached_result(mutation)
-    return cached if cached
-
-    result = yield
-    store_cached_result(mutation, result)
-    result
-  end
-
-  def fetch_cached_result(mutation)
-    return nil unless cache
-
-    data = cache.fetch(mutation)
-    return nil unless data
-    return nil unless %i[killed timeout].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]
+  def build_parallel(notifier, pipeline)
+    Strategy::Parallel.new(
+      cache: @cache,
+      isolator: @isolator,
+      packer: @packer,
+      pipeline: pipeline,
+      notifier: notifier,
+      pool_factory: -> { build_pool },
+      diagnostics: @diagnostics,
+      config: @config
     )
   end
 
-  def store_cached_result(mutation, result)
-    return unless cache
-    return unless result.killed? || result.timeout?
-
-    cache.store(mutation,
-                status: result.status,
-                duration: result.duration,
-                killing_test: result.killing_test,
-                test_command: result.test_command)
-  end
-
-  def notify_result(result, index)
-    on_result&.call(result)
-    @progress_bar&.tick(status: result.status)
-    diagnostics.log_progress(index, result.status)
-    diagnostics.log_mutation_diagnostics(result)
-  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)
+  def build_pool
+    Evilution::Parallel::Pool.new(
+      size: @config.jobs,
+      hooks: @hooks,
+      item_timeout: @config.timeout ? @config.timeout * 2 : nil
+    )
   end
 end

data/lib/evilution/runner/mutation_planner.rb

@@ -1,12 +1,11 @@
 # frozen_string_literal: true
 
+require_relative "../runner"
 require_relative "../disable_comment"
 require_relative "../ast/sorbet_sig_detector"
 require_relative "../ast/pattern/filter"
 require_relative "../equivalent/detector"
 
-class Evilution::Runner; end unless defined?(Evilution::Runner) # rubocop:disable Lint/EmptyClass
-
 class Evilution::Runner::MutationPlanner
   Plan = Struct.new(:enabled, :equivalent, :skipped_count, :disabled_mutations, keyword_init: true)
 

data/lib/evilution/runner/report_publisher.rb

@@ -1,12 +1,11 @@
 # frozen_string_literal: true
 
+require_relative "../runner"
 require_relative "../reporter/json"
 require_relative "../reporter/cli"
 require_relative "../reporter/html"
 require_relative "../session/store"
 
-class Evilution::Runner; end unless defined?(Evilution::Runner) # rubocop:disable Lint/EmptyClass
-
 class Evilution::Runner::ReportPublisher
   def initialize(config)
     @config = config

data/lib/evilution/runner/subject_pipeline.rb

@@ -1,10 +1,9 @@
 # frozen_string_literal: true
 
+require_relative "../runner"
 require_relative "../ast/inheritance_scanner"
 require_relative "../git/changed_files"
 
-class Evilution::Runner; end unless defined?(Evilution::Runner) # rubocop:disable Lint/EmptyClass
-
 class Evilution::Runner::SubjectPipeline
   def initialize(config, parser:)
     @config = config

data/lib/evilution/runner.rb

@@ -1,34 +1,7 @@
 # frozen_string_literal: true
 
-require_relative "config"
-require_relative "ast/parser"
-require_relative "memory"
-require_relative "mutator/registry"
-require_relative "isolation/fork"
-require_relative "isolation/in_process"
-require_relative "integration/rspec"
-require_relative "integration/minitest"
-require_relative "reporter/json"
-require_relative "reporter/cli"
-require_relative "reporter/html"
-require_relative "reporter/suggestion"
-require_relative "git/changed_files"
-require_relative "result/mutation_result"
-require_relative "result/summary"
-require_relative "baseline"
-require_relative "cache"
-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"
-require_relative "runner/baseline_runner"
-require_relative "runner/diagnostics"
-require_relative "runner/mutation_executor"
-require_relative "runner/report_publisher"
+require "fileutils"
+require_relative "../evilution"
 
 class Evilution::Runner
   attr_reader :config
@@ -38,12 +11,13 @@ class Evilution::Runner
     @on_result = on_result
     @hooks = hooks
     @parser = Evilution::AST::Parser.new
-    @registry = Evilution::Mutator::Registry.default
+    @registry = Evilution::Mutator::Registry.for_profile(config.profile)
     @cache = config.incremental? ? Evilution::Cache.new : nil
   end
 
   def call
     install_signal_handlers
+    configure_child_output
     emit_parallel_db_warning
     start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
 
@@ -156,6 +130,24 @@ class Evilution::Runner
     Evilution::ParallelDbWarning.warn_if_sqlite_parallel(config)
   end
 
+  def configure_child_output
+    unless config.quiet_children
+      Evilution::ChildOutput.log_dir = nil
+      return
+    end
+
+    dir = config.quiet_children_dir
+    begin
+      FileUtils.rm_rf(dir)
+      FileUtils.mkdir_p(dir)
+    rescue SystemCallError => e
+      raise Evilution::ConfigError,
+            "quiet_children_dir #{dir.inspect} is not writable: #{e.class}: #{e.message}. " \
+            "Pass --quiet-children-dir <writable path> or drop --quiet-children."
+    end
+    Evilution::ChildOutput.log_dir = dir
+  end
+
   def install_signal_handlers
     %w[INT TERM].each { |sig| install_signal_handler(sig) }
   end
@@ -192,3 +184,34 @@ class Evilution::Runner
     diagnostics.log_memory(phase, context)
   end
 end
+
+require_relative "config"
+require_relative "ast/parser"
+require_relative "memory"
+require_relative "mutator/registry"
+require_relative "isolation/fork"
+require_relative "isolation/in_process"
+require_relative "integration/rspec"
+require_relative "integration/minitest"
+require_relative "reporter/json"
+require_relative "reporter/cli"
+require_relative "reporter/html"
+require_relative "reporter/suggestion"
+require_relative "git/changed_files"
+require_relative "result/mutation_result"
+require_relative "result/summary"
+require_relative "baseline"
+require_relative "cache"
+require_relative "parallel/pool"
+require_relative "session/store"
+require_relative "temp_dir_tracker"
+require_relative "rails_detector"
+require_relative "parallel_db_warning"
+require_relative "child_output"
+require_relative "runner/subject_pipeline"
+require_relative "runner/mutation_planner"
+require_relative "runner/isolation_resolver"
+require_relative "runner/baseline_runner"
+require_relative "runner/diagnostics"
+require_relative "runner/mutation_executor"
+require_relative "runner/report_publisher"

data/lib/evilution/version.rb

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

data/lib/evilution.rb

@@ -89,6 +89,7 @@ require_relative "evilution/mutator/operator/string_interpolation"
 require_relative "evilution/mutator/operator/retry_removal"
 require_relative "evilution/mutator/operator/case_when"
 require_relative "evilution/mutator/operator/predicate_replacement"
+require_relative "evilution/mutator/operator/predicate_to_nil"
 require_relative "evilution/mutator/operator/equality_to_identity"
 require_relative "evilution/mutator/operator/lambda_body"
 require_relative "evilution/mutator/operator/begin_unwrap"

data/script/memory_check

@@ -88,7 +88,9 @@ if mutations.size >= 2
     batch.zip(compact_results).map do |mutation, data|
       Evilution::Result::MutationResult.new(
         mutation: mutation, status: data[:status], duration: data[:duration],
-        child_rss_kb: data[:child_rss_kb], memory_delta_kb: data[:memory_delta_kb]
+        memory: Evilution::Result::MemoryStats.new(
+          child_rss_kb: data[:child_rss_kb], memory_delta_kb: data[:memory_delta_kb]
+        )
       )
     end
   end