evilution 0.28.0 → 0.30.0

data/lib/evilution/reporter/cli/item_formatters/coverage_gap.rb

@@ -5,14 +5,19 @@ require_relative "../item_formatters"
 class Evilution::Reporter::CLI::ItemFormatters::CoverageGap
   def format(gap)
     location = "#{gap.file_path}:#{gap.line}"
-    header = if gap.single?
-               "  #{gap.primary_operator}: #{location} (#{gap.subject_name})"
-             else
-               operators = gap.operator_names.join(", ")
-               "  #{location} (#{gap.subject_name}) [#{gap.count} mutations: #{operators}]"
-             end
+    "#{format_header(gap, location)}\n#{format_body(gap)}"
+  end
+
+  private
+
+  def format_header(gap, location)
+    return "  #{gap.primary_operator}: #{location} (#{gap.subject_name})" if gap.single?
+
+    "  #{location} (#{gap.subject_name}) [#{gap.count} mutations: #{gap.operator_names.join(", ")}]"
+  end
+
+  def format_body(gap)
     body = gap.mutation_results.first.mutation.unified_diff || gap.primary_diff
-    indented = body.split("\n").map { |l| "    #{l}" }.join("\n")
-    "#{header}\n#{indented}"
+    body.split("\n").map { |l| "    #{l}" }.join("\n")
   end
 end

data/lib/evilution/reporter/cli/line_formatters/error_rate_warning.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative "../line_formatters"
+
+# EV-nrgw / GH #1168: Score is `killed / score_denominator` where
+# `score_denominator = total - errors - neutral - equivalent - unresolved -
+# unparseable` — errors are excluded from the denominator entirely. A run
+# can read PASS at 100% while 16 of 19 mutations silently errored. This
+# formatter surfaces a warning right under the metrics block when the error
+# rate crosses the threshold so the silent failure mode becomes loud.
+class Evilution::Reporter::CLI::LineFormatters::ErrorRateWarning
+  DEFAULT_THRESHOLD = 0.25
+
+  def initialize(threshold: DEFAULT_THRESHOLD)
+    @threshold = threshold
+  end
+
+  def format(summary)
+    return nil if summary.total.zero?
+    return nil if summary.errors.zero?
+
+    rate = summary.errors.to_f / summary.total
+    return nil if rate <= @threshold
+
+    pct = (rate * 100).round(1)
+    "! High error rate: #{summary.errors}/#{summary.total} (#{pct}%) mutations errored — " \
+      "score may be unreliable. See the \"Errored mutations:\" section for the underlying cause."
+  end
+end

data/lib/evilution/reporter/cli/line_formatters/mutations.rb

@@ -3,14 +3,23 @@
 require_relative "../line_formatters"
 
 class Evilution::Reporter::CLI::LineFormatters::Mutations
+  OPTIONAL_FIELDS = %i[neutral equivalent unresolved unparseable skipped].freeze
+
   def format(summary)
-    parts = "Mutations: #{summary.total} total, #{summary.killed} killed, " \
-            "#{summary.survived} survived, #{summary.timed_out} timed out"
-    parts += ", #{summary.neutral} neutral" if summary.neutral.positive?
-    parts += ", #{summary.equivalent} equivalent" if summary.equivalent.positive?
-    parts += ", #{summary.unresolved} unresolved" if summary.unresolved.positive?
-    parts += ", #{summary.unparseable} unparseable" if summary.unparseable.positive?
-    parts += ", #{summary.skipped} skipped" if summary.skipped.positive?
-    parts
+    base_line(summary) + optional_sections(summary)
+  end
+
+  private
+
+  def base_line(summary)
+    "Mutations: #{summary.total} total, #{summary.killed} killed, " \
+      "#{summary.survived} survived, #{summary.timed_out} timed out"
+  end
+
+  def optional_sections(summary)
+    OPTIONAL_FIELDS.filter_map do |field|
+      count = summary.public_send(field)
+      ", #{count} #{field}" if count.positive?
+    end.join
   end
 end

data/lib/evilution/reporter/cli/metrics_block.rb

@@ -3,6 +3,7 @@
 require_relative "../cli"
 require_relative "line_formatters/mutations"
 require_relative "line_formatters/score"
+require_relative "line_formatters/error_rate_warning"
 require_relative "line_formatters/duration"
 require_relative "line_formatters/efficiency"
 require_relative "line_formatters/peak_memory"
@@ -11,6 +12,7 @@ class Evilution::Reporter::CLI::MetricsBlock
   DEFAULT_LINES = [
     Evilution::Reporter::CLI::LineFormatters::Mutations.new,
     Evilution::Reporter::CLI::LineFormatters::Score.new,
+    Evilution::Reporter::CLI::LineFormatters::ErrorRateWarning.new,
     Evilution::Reporter::CLI::LineFormatters::Duration.new,
     Evilution::Reporter::CLI::LineFormatters::Efficiency.new,
     Evilution::Reporter::CLI::LineFormatters::PeakMemory.new

data/lib/evilution/reporter/json.rb

@@ -5,6 +5,7 @@ require "time"
 require_relative "suggestion"
 
 require_relative "../reporter"
+require_relative "../session/schema"
 
 class Evilution::Reporter::JSON
   def initialize(suggest_tests: false, integration: :rspec)
@@ -19,21 +20,37 @@ class Evilution::Reporter::JSON
 
   def build_report(summary)
     report = {
+      schema_version: Evilution::Session::Schema::CURRENT_VERSION,
       version: Evilution::VERSION,
       timestamp: Time.now.iso8601,
       summary: build_summary(summary),
-      survived: map_details(summary.survived_results),
       coverage_gaps: build_coverage_gaps(summary),
+      **result_categories(summary)
+    }
+    append_disabled_to_report(report, summary)
+    report
+  end
+
+  def result_categories(summary)
+    direct_categories(summary).merge(derived_categories(summary))
+  end
+
+  def direct_categories(summary)
+    {
+      survived: map_details(summary.survived_results),
       killed: map_details(summary.killed_results),
       neutral: map_details(summary.neutral_results),
-      timed_out: map_details(summary.results.select(&:timeout?)),
-      errors: map_details(summary.results.select(&:error?)),
       equivalent: map_details(summary.equivalent_results),
       unresolved: map_details(summary.unresolved_results),
       unparseable: map_details(summary.unparseable_results)
     }
-    append_disabled_to_report(report, summary)
-    report
+  end
+
+  def derived_categories(summary)
+    {
+      timed_out: map_details(summary.results.select(&:timeout?)),
+      errors: map_details(summary.results.select(&:error?))
+    }
   end
 
   def map_details(results)
@@ -47,7 +64,13 @@ class Evilution::Reporter::JSON
   end
 
   def build_summary(summary)
-    data = {
+    data = build_core_summary(summary).merge(build_metrics_summary(summary))
+    append_optional_summary_fields(data, summary)
+    data
+  end
+
+  def build_core_summary(summary)
+    {
       total: summary.total,
       killed: summary.killed,
       survived: summary.survived,
@@ -56,23 +79,39 @@ class Evilution::Reporter::JSON
       neutral: summary.neutral,
       equivalent: summary.equivalent,
       unresolved: summary.unresolved,
-      unparseable: summary.unparseable,
+      unparseable: summary.unparseable
+    }
+  end
+
+  def build_metrics_summary(summary)
+    {
       score: summary.score.round(4),
       duration: summary.duration.round(4),
       killtime: summary.killtime.round(4),
       efficiency: summary.efficiency.round(4),
       mutations_per_second: summary.mutations_per_second.round(2)
     }
+  end
+
+  def append_optional_summary_fields(data, summary)
     data[:truncated] = true if summary.truncated?
     data[:skipped] = summary.skipped if summary.skipped.positive?
     peak = summary.peak_memory_mb
     data[:peak_memory_mb] = peak.round(1) if peak
-    data
   end
 
   def build_mutation_detail(result)
     mutation = result.mutation
-    detail = {
+    detail = base_mutation_fields(mutation, result)
+    append_survived_fields(detail, mutation) if result.status == :survived
+    detail[:test_command] = result.test_command if result.test_command
+    append_memory_fields(detail, result)
+    append_error_fields(detail, result)
+    detail
+  end
+
+  def base_mutation_fields(mutation, result)
+    {
       operator: mutation.operator_name,
       file: mutation.file_path,
       line: mutation.line,
@@ -80,15 +119,12 @@ class Evilution::Reporter::JSON
       duration: result.duration.round(4),
       diff: mutation.diff
     }
-    if result.status == :survived
-      detail[:suggestion] = @suggestion.suggestion_for(mutation)
-      unified = mutation.unified_diff
-      detail[:unified_diff] = unified if unified
-    end
-    detail[:test_command] = result.test_command if result.test_command
-    append_memory_fields(detail, result)
-    append_error_fields(detail, result)
-    detail
+  end
+
+  def append_survived_fields(detail, mutation)
+    detail[:suggestion] = @suggestion.suggestion_for(mutation)
+    unified = mutation.unified_diff
+    detail[:unified_diff] = unified if unified
   end
 
   def append_memory_fields(detail, result)

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

@@ -12,17 +12,4 @@ module Evilution::Reporter::Suggestion::DiffHelpers
   def sanitize_method_name(name)
     name.gsub(/[^a-zA-Z0-9_]/, "_").gsub(/_+/, "_").gsub(/\A_|_\z/, "")
   end
-
-  def extract_diff_lines(diff)
-    lines = diff.split("\n")
-    original = lines.find { |l| l.start_with?("- ") }
-    mutated = lines.find { |l| l.start_with?("+ ") }
-    [clean_diff_line(original, "- "), clean_diff_line(mutated, "+ ")]
-  end
-
-  def clean_diff_line(line, prefix)
-    return nil if line.nil?
-
-    line.sub(/^#{Regexp.escape(prefix)}/, "").strip
-  end
 end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative "../suggestion"
+
+class Evilution::Reporter::Suggestion::DiffLines
+  def self.from_diff(raw_diff)
+    lines = raw_diff.split("\n")
+    new(
+      original: clean(lines.find { |l| l.start_with?("- ") }, "- "),
+      mutated: clean(lines.find { |l| l.start_with?("+ ") }, "+ ")
+    )
+  end
+
+  def self.clean(line, prefix)
+    return nil if line.nil?
+
+    line.sub(/^#{Regexp.escape(prefix)}/, "").strip
+  end
+  private_class_method :clean
+
+  attr_reader :original, :mutated
+
+  def initialize(original:, mutated:)
+    @original = original
+    @mutated = mutated
+    freeze
+  end
+end

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

@@ -2,6 +2,7 @@
 
 require_relative "../templates"
 require_relative "../diff_helpers"
+require_relative "../diff_lines"
 
 module Evilution::Reporter::Suggestion::Templates::Minitest
   H = Evilution::Reporter::Suggestion::DiffHelpers
@@ -17,21 +18,26 @@ module Evilution::Reporter::Suggestion::Templates::Minitest
   end
 
   def self.build(test_name:, action: :changed, &body_block)
-    lambda do |mutation|
-      method_name = H.parse_method_name(mutation.subject.name)
-      safe_name = H.sanitize_method_name(method_name)
-      original_line, mutated_line = H.extract_diff_lines(mutation.diff)
-      body = body_block.call(method_name)
-      indented = body.lines.map { |l| "  #{l}" }.join.chomp
+    ->(mutation) { render(test_name, action, body_block, mutation) }
+  end
 
-      <<~MINITEST.strip
-        # Mutation: #{format_header(action, original_line, mutated_line, mutation.subject.name)}
-        # #{mutation.file_path}:#{mutation.line}
-        def test_#{test_name}_#{safe_name}
-        #{indented}
-        end
-      MINITEST
-    end
+  def self.render(test_name, action, body_block, mutation)
+    method_name = H.parse_method_name(mutation.subject.name)
+    safe_name = H.sanitize_method_name(method_name)
+    diff_lines = Evilution::Reporter::Suggestion::DiffLines.from_diff(mutation.diff)
+    indented = indent_body(body_block.call(method_name))
+
+    <<~MINITEST.strip
+      # Mutation: #{format_header(action, diff_lines.original, diff_lines.mutated, mutation.subject.name)}
+      # #{mutation.file_path}:#{mutation.line}
+      def test_#{test_name}_#{safe_name}
+      #{indented}
+      end
+    MINITEST
+  end
+
+  def self.indent_body(body)
+    body.lines.map { |l| "  #{l}" }.join.chomp
   end
 
   MINITEST_ENTRIES = {

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

@@ -2,6 +2,7 @@
 
 require_relative "../templates"
 require_relative "../diff_helpers"
+require_relative "../diff_lines"
 
 module Evilution::Reporter::Suggestion::Templates::Rspec
   H = Evilution::Reporter::Suggestion::DiffHelpers
@@ -17,20 +18,25 @@ module Evilution::Reporter::Suggestion::Templates::Rspec
   end
 
   def self.build(it_desc:, action: :changed, &body_block)
-    lambda do |mutation|
-      method_name = H.parse_method_name(mutation.subject.name)
-      original_line, mutated_line = H.extract_diff_lines(mutation.diff)
-      body = body_block.call(method_name)
-      indented = body.lines.map { |l| "  #{l}" }.join.chomp
+    ->(mutation) { render(it_desc, action, body_block, mutation) }
+  end
 
-      <<~RSPEC.strip
-        # Mutation: #{format_header(action, original_line, mutated_line, mutation.subject.name)}
-        # #{mutation.file_path}:#{mutation.line}
-        it '#{it_desc} ##{method_name}' do
-        #{indented}
-        end
-      RSPEC
-    end
+  def self.render(it_desc, action, body_block, mutation)
+    method_name = H.parse_method_name(mutation.subject.name)
+    diff_lines = Evilution::Reporter::Suggestion::DiffLines.from_diff(mutation.diff)
+    indented = indent_body(body_block.call(method_name))
+
+    <<~RSPEC.strip
+      # Mutation: #{format_header(action, diff_lines.original, diff_lines.mutated, mutation.subject.name)}
+      # #{mutation.file_path}:#{mutation.line}
+      it '#{it_desc} ##{method_name}' do
+      #{indented}
+      end
+    RSPEC
+  end
+
+  def self.indent_body(body)
+    body.lines.map { |l| "  #{l}" }.join.chomp
   end
 
   RSPEC_ENTRIES = {

data/lib/evilution/result/mutation_result.rb

@@ -23,28 +23,34 @@ class Evilution::Result::MutationResult
     freeze
   end
 
+  # Positive type checks, not nil checks. EV-s5br / GH #1174: the
+  # nil_replacement mutator can swap a nil default into `false` (or some other
+  # non-typed value), and `nil?` then returns false, sending a missing method
+  # to the wrong receiver and crashing the parent worker. Asking the field
+  # explicitly whether it is the expected struct keeps the parent process
+  # alive and lets the mutation count as a measured (errored) result.
   def child_rss_kb
-    @memory.nil? ? nil : @memory.child_rss_kb
+    @memory.is_a?(Evilution::Result::MemoryStats) ? @memory.child_rss_kb : nil
   end
 
   def memory_delta_kb
-    @memory.nil? ? nil : @memory.memory_delta_kb
+    @memory.is_a?(Evilution::Result::MemoryStats) ? @memory.memory_delta_kb : nil
   end
 
   def parent_rss_kb
-    @memory.nil? ? nil : @memory.parent_rss_kb
+    @memory.is_a?(Evilution::Result::MemoryStats) ? @memory.parent_rss_kb : nil
   end
 
   def error_message
-    @error.nil? ? nil : @error.message
+    @error.is_a?(Evilution::Result::ErrorInfo) ? @error.message : nil
   end
 
   def error_class
-    @error.nil? ? nil : @error.klass
+    @error.is_a?(Evilution::Result::ErrorInfo) ? @error.klass : nil
   end
 
   def error_backtrace
-    @error.nil? ? nil : @error.backtrace
+    @error.is_a?(Evilution::Result::ErrorInfo) ? @error.backtrace : nil
   end
 
   def killed?

data/lib/evilution/runner/baseline_runner.rb

@@ -30,25 +30,36 @@ 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,
+    kwargs = base_integration_kwargs
+    kwargs.merge!(rspec_integration_kwargs) if klass == Evilution::Integration::RSpec
+    klass.new(**kwargs)
+  end
+
+  def base_integration_kwargs
+    {
+      test_files: config.spec_files.empty? ? nil : config.spec_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 rspec_integration_kwargs
+    {
+      related_specs_heuristic: config.related_specs_heuristic?,
+      example_filter: build_example_filter
+    }
   end
 
   def call(subjects)
     return nil unless config.baseline? && subjects.any?
 
     log_start
-    baseline = Evilution::Baseline.new(timeout: config.timeout, **integration_class.baseline_options)
+    baseline = Evilution::Baseline.new(
+      timeout: config.timeout,
+      test_files: config.spec_files.empty? ? nil : config.spec_files,
+      **integration_class.baseline_options
+    )
     result = baseline.call(subjects)
     log_complete(result)
     result

data/lib/evilution/runner/diagnostics.rb

@@ -32,19 +32,23 @@ class Evilution::Runner::Diagnostics
   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
+    parts = mutation_metric_parts(result)
+    stderr.write("[verbose] #{result.mutation}: #{parts.join(", ")}\n") unless parts.empty?
 
-    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
+    log_mutation_error(result) if result.error?
+  end
 
+  def mutation_metric_parts(result)
+    parts = []
+    parts << format("child_rss: %<mb>.1f MB", mb: result.child_rss_kb / 1024.0) if result.child_rss_kb
+    parts << format_memory_delta(result.memory_delta_kb) if result.memory_delta_kb
     parts << gc_stats_string
+    parts
+  end
 
-    stderr.write("[verbose] #{result.mutation}: #{parts.join(", ")}\n") unless parts.empty?
-
-    log_mutation_error(result) if result.error?
+  def format_memory_delta(delta_kb)
+    sign = delta_kb.negative? ? "" : "+"
+    format("delta: %<sign>s%<mb>.1f MB", sign: sign, mb: delta_kb / 1024.0)
   end
 
   def log_worker_stats(stats)

data/lib/evilution/runner/isolation_resolver.rb

@@ -4,6 +4,7 @@ require_relative "../runner"
 require_relative "../isolation/fork"
 require_relative "../isolation/in_process"
 require_relative "../rails_detector"
+require_relative "../gem_detector"
 
 class Evilution::Runner::IsolationResolver
   PRELOAD_CANDIDATES = [
@@ -108,16 +109,52 @@ class Evilution::Runner::IsolationResolver
   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
+    return resolve_explicit_with_fallback(config.preload) if config.preload.is_a?(String)
+
+    resolve_autodetected_preload
+  end
+
+  # Explicit preload path resolution with auto-detect fallthrough under :fork.
+  # When the user-configured path is missing, surface a stderr warning naming
+  # the missing path and try the auto-detect chain so a stale .evilution.yml
+  # entry doesn't silently disable preloading. Fallthrough requires both
+  # :fork isolation AND a detected Rails root (otherwise the chain has nowhere
+  # to look and the explicit-missing error is raised directly).
+  def resolve_explicit_with_fallback(explicit)
+    return explicit if File.file?(explicit)
+
+    raise_explicit_preload_missing(explicit) unless can_fallthrough_to_autodetect?
+
+    warn_missing_explicit_preload(explicit)
+    fallback = find_first_existing_candidate
+    return fallback if fallback
+
+    raise build_combined_missing_error(explicit)
+  end
+
+  def can_fallthrough_to_autodetect?
+    resolve_isolation == :fork && !detected_rails_root.nil?
+  end
+
+  def resolve_autodetected_preload
+    if detected_rails_root
+      fallback = find_first_existing_candidate
+      return fallback if fallback
+
+      raise Evilution::ConfigError, autodetect_missing_message
     end
 
+    detected_gem_entry
+  end
+
+  def detected_gem_entry
+    return @detected_gem_entry if defined?(@detected_gem_entry)
+
+    root = Evilution::GemDetector.gem_root_for_any(target_files)
+    @detected_gem_entry = root && Evilution::GemDetector.gem_entry_for(root, target_paths: target_files)
+  end
+
+  def find_first_existing_candidate
     root = detected_rails_root
     return nil unless root
 
@@ -125,11 +162,37 @@ class Evilution::Runner::IsolationResolver
       abs = File.join(root, rel)
       return abs if File.file?(abs)
     end
+    nil
+  end
+
+  def autodetect_missing_message
+    "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
+
+  def build_combined_missing_error(explicit)
+    Evilution::ConfigError.new(
+      "Preload file not found. Configured preload #{explicit.inspect} does not exist, " \
+      "and none of the auto-detect candidates exist either. " \
+      "Tried: [#{PRELOAD_CANDIDATES.join(", ")}]. " \
+      "Pass --preload <file> or set preload: in .evilution.yml. " \
+      "Use --no-preload (or preload: false) to disable preloading entirely.",
+      file: explicit
+    )
+  end
+
+  def raise_explicit_preload_missing(path)
+    raise Evilution::ConfigError.new("preload file not found: #{path.inspect}", file: path)
+  end
 
-    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."
+  def warn_missing_explicit_preload(path)
+    return if config.quiet
+
+    $stderr.write(
+      "[evilution] warning: configured preload #{path.inspect} not found; " \
+      "falling through to auto-detect chain.\n"
+    )
   end
 
   # When the user explicitly requests InProcess on a Rails project, warn once

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

@@ -7,6 +7,8 @@ class Evilution::Runner::MutationExecutor::ResultCache
   CACHEABLE_STATUSES = %i[killed timeout].freeze
   private_constant :CACHEABLE_STATUSES
 
+  Partition = Data.define(:uncached_indices, :cached_results)
+
   def initialize(backend)
     @backend = backend
   end
@@ -56,7 +58,7 @@ class Evilution::Runner::MutationExecutor::ResultCache
       end
     end
 
-    [uncached_indices, cached_results]
+    Partition.new(uncached_indices: uncached_indices, cached_results: cached_results)
   end
 
   private