evilution 0.23.0 → 0.25.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].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,
@@ -54,4 +54,12 @@ class Evilution::Result::MutationResult
   def equivalent?
     status == :equivalent
   end
+
+  def unresolved?
+    status == :unresolved
+  end
+
+  def unparseable?
+    status == :unparseable
+  end
 end

data/lib/evilution/result/summary.rb

@@ -47,8 +47,20 @@ class Evilution::Result::Summary
     results.count(&:equivalent?)
   end
 
+  def unresolved
+    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
+    denominator = score_denominator
     return 0.0 if denominator.zero?
 
     killed.to_f / denominator
@@ -74,6 +86,14 @@ class Evilution::Result::Summary
     results.select(&:equivalent?)
   end
 
+  def unresolved_results
+    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

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+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
+
+unless defined?(Evilution::Runner::INTEGRATIONS)
+  Evilution::Runner::INTEGRATIONS = {
+    rspec: Evilution::Integration::RSpec,
+    minitest: Evilution::Integration::Minitest
+  }.freeze
+end
+
+class Evilution::Runner::BaselineRunner
+  def initialize(config, hooks: nil)
+    @config = config
+    @hooks = hooks
+  end
+
+  def integration_class
+    @integration_class ||= Evilution::Runner::INTEGRATIONS.fetch(config.integration) do
+      raise Evilution::Error, "unknown integration: #{config.integration}"
+    end
+  end
+
+  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?,
+      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
+
+  def call(subjects)
+    return nil unless config.baseline? && subjects.any?
+
+    log_start
+    baseline = Evilution::Baseline.new(timeout: config.timeout, **integration_class.baseline_options)
+    result = baseline.call(subjects)
+    log_complete(result)
+    result
+  end
+
+  def neutralization_resolver
+    integration_class.baseline_options[:spec_resolver] || Evilution::SpecResolver.new
+  end
+
+  def neutralization_fallback_dir
+    integration_class.baseline_options[:fallback_dir] || "spec"
+  end
+
+  private
+
+  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?
+
+    $stderr.write("Running baseline test suite...\n")
+  end
+
+  def log_complete(result)
+    return if config.quiet || !config.text? || !$stderr.tty?
+
+    count = result.failed_spec_files.size
+    $stderr.write("Baseline complete: #{count} failing spec file#{"s" unless count == 1}\n")
+  end
+end

data/lib/evilution/runner/diagnostics.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+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
+    @stderr = stderr
+  end
+
+  def log_memory(phase, context = nil)
+    return unless verbose?
+
+    rss = Evilution::Memory.rss_mb
+    return unless rss
+
+    gc = gc_stats_string
+    msg = format("[memory] %<phase>s: %<rss>.1f MB", phase: phase, rss: rss)
+    ctx = [context, gc].compact.join(", ")
+    msg += " (#{ctx})" unless ctx.empty?
+    stderr.write("#{msg}\n")
+  end
+
+  def log_progress(current, status)
+    return unless text_tty?
+
+    stderr.write("mutation #{current} #{status}\n")
+  end
+
+  def log_mutation_diagnostics(result)
+    return unless verbose?
+
+    parts = []
+    parts << format("child_rss: %<mb>.1f MB", mb: result.child_rss_kb / 1024.0) if result.child_rss_kb
+
+    if result.memory_delta_kb
+      sign = result.memory_delta_kb.negative? ? "" : "+"
+      parts << format("delta: %<sign>s%<mb>.1f MB", sign: sign, mb: result.memory_delta_kb / 1024.0)
+    end
+
+    parts << gc_stats_string
+
+    stderr.write("[verbose] #{result.mutation}: #{parts.join(", ")}\n") unless parts.empty?
+
+    log_mutation_error(result) if result.error?
+  end
+
+  def log_worker_stats(stats)
+    return unless verbose? && stats.any?
+
+    stats.each do |stat|
+      pct = format("%.1f", stat.utilization * 100)
+      stderr.write("[verbose] worker #{stat.pid}: #{stat.items_completed} items, utilization #{pct}%\n")
+    end
+  end
+
+  def aggregate_worker_stats(stats)
+    return stats if stats.empty?
+
+    stats.group_by(&:pid).map do |pid, entries|
+      Evilution::Parallel::WorkQueue::WorkerStat.new(
+        pid,
+        entries.sum(&:items_completed),
+        entries.sum(&:busy_time),
+        entries.sum(&:wall_time)
+      )
+    end
+  end
+
+  private
+
+  attr_reader :config, :stderr
+
+  def verbose?
+    config.verbose && !config.quiet
+  end
+
+  def text_tty?
+    !config.quiet && config.text? && stderr.tty?
+  end
+
+  def log_mutation_error(result)
+    header = "[verbose] #{result.mutation}: error"
+    header += " #{result.error_class}" if result.error_class
+    header += ": #{result.error_message}" if result.error_message
+    stderr.write("#{header}\n")
+
+    Array(result.error_backtrace).first(5).each do |line|
+      stderr.write("[verbose]   #{line}\n")
+    end
+  end
+
+  def gc_stats_string
+    stats = GC.stat
+    format(
+      "heap_live_slots: %<live>d, allocated: %<alloc>d, freed: %<freed>d",
+      live: stats[:heap_live_slots],
+      alloc: stats[:total_allocated_objects],
+      freed: stats[:total_freed_objects]
+    )
+  end
+end

data/lib/evilution/runner/isolation_resolver.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+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("test", "test_helper.rb")
+  ].freeze
+
+  def initialize(config, target_files:, hooks:)
+    @config = config
+    @target_files_callback = target_files
+    @hooks = hooks
+  end
+
+  def isolator
+    @isolator ||= build_isolator
+  end
+
+  def rails_root_detected?
+    return @rails_root_detected if defined?(@rails_root_detected)
+
+    @rails_root_detected = !detected_rails_root.nil?
+  end
+
+  def perform_preload
+    return if config.preload == false
+    return unless resolve_isolation == :fork
+
+    path = resolve_preload_path
+    return unless path
+
+    prepare_load_path_for_preload
+    require File.expand_path(path)
+  rescue ScriptError, StandardError => e
+    raise Evilution::ConfigError.new(
+      "failed to preload #{path.inspect}: #{e.class}: #{e.message}",
+      file: path
+    )
+  end
+
+  private
+
+  attr_reader :config, :hooks
+
+  def target_files
+    @target_files ||= @target_files_callback.call
+  end
+
+  def build_isolator
+    case resolve_isolation
+    when :fork then Evilution::Isolation::Fork.new(hooks: hooks)
+    when :in_process then Evilution::Isolation::InProcess.new
+    end
+  end
+
+  def resolve_isolation
+    case config.isolation
+    when :fork
+      :fork
+    when :in_process
+      warn_in_process_under_rails if rails_root_detected?
+      :in_process
+    else # :auto
+      rails_root_detected? ? :fork : :in_process
+    end
+  end
+
+  def detected_rails_root
+    return @detected_rails_root if defined?(@detected_rails_root)
+
+    @detected_rails_root = Evilution::RailsDetector.rails_root_for_any(target_files)
+  end
+
+  # Preload files (e.g. spec/rails_helper.rb) typically `require 'spec_helper'`
+  # which needs spec/ on $LOAD_PATH, and use `RSpec.configure` which needs
+  # rspec/core loaded. The RSpec CLI normally sets this up, but evilution
+  # calls Runner.run directly.
+  def prepare_load_path_for_preload
+    spec_dir = File.expand_path(resolve_spec_dir)
+    $LOAD_PATH.unshift(spec_dir) unless $LOAD_PATH.include?(spec_dir)
+    require "rspec/core" if config.integration == :rspec
+  end
+
+  def resolve_spec_dir
+    root = detected_rails_root
+    return File.join(root, "spec") if root
+
+    "spec"
+  end
+
+  def resolve_preload_path
+    if config.preload.is_a?(String)
+      unless File.file?(config.preload)
+        raise Evilution::ConfigError.new(
+          "preload file not found: #{config.preload.inspect}",
+          file: config.preload
+        )
+      end
+      return config.preload
+    end
+
+    root = detected_rails_root
+    return nil unless root
+
+    PRELOAD_CANDIDATES.each do |rel|
+      abs = File.join(root, rel)
+      return abs if File.file?(abs)
+    end
+    nil
+  end
+
+  # When the user explicitly requests InProcess on a Rails project, warn once
+  # per run. Rails wraps ActiveRecord transactions in
+  # Thread.handle_interrupt(Exception => :never), which defers Timeout's
+  # Thread#raise indefinitely — making InProcess unable to kill runaway mutants.
+  def warn_in_process_under_rails
+    return if config.quiet
+    return if @warned_in_process_under_rails
+
+    @warned_in_process_under_rails = true
+    $stderr.write(
+      "[evilution] warning: --isolation in_process is unsafe on Rails projects. " \
+      "ActiveRecord wraps transactions in Thread.handle_interrupt(Exception => :never), " \
+      "which swallows Timeout.timeout and can cause evilution to hang indefinitely on " \
+      "mutants that introduce infinite loops. Use --isolation fork for reliable interruption.\n"
+    )
+  end
+end