evilution 0.23.0 → 0.25.0

data/lib/evilution/runner/mutation_executor.rb

@@ -0,0 +1,325 @@
+# 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
+
+class Evilution::Runner::MutationExecutor
+  def initialize(config, isolator:, baseline_runner:, cache:, hooks:, diagnostics:, on_result: nil)
+    @config = config
+    @isolator = isolator
+    @baseline_runner = baseline_runner
+    @cache = cache
+    @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
+  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]
+  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]]
+  end
+
+  def build_pool
+    Evilution::Parallel::Pool.new(
+      size: config.jobs,
+      hooks: hooks,
+      item_timeout: config.timeout ? config.timeout * 2 : nil
+    )
+  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
+    )
+  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]
+    )
+  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)
+  end
+end

data/lib/evilution/runner/mutation_planner.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+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)
+
+  def initialize(config, registry:, disable_detector: Evilution::DisableComment.new,
+                 sig_detector: Evilution::AST::SorbetSigDetector.new)
+    @config = config
+    @registry = registry
+    @disable_detector = disable_detector
+    @sig_detector = sig_detector
+    @disabled_ranges_cache = {}
+    @sig_ranges_cache = {}
+  end
+
+  def call(subjects)
+    mutations, generation_skipped = generate(subjects)
+    mutations, disabled = filter_disabled(mutations)
+    disabled.each(&:strip_sources!) if config.show_disabled?
+    disabled_mutations = config.show_disabled? ? disabled : []
+
+    mutations, sig_skipped = filter_sig_blocks(mutations)
+    equivalent, enabled = filter_equivalent(mutations)
+
+    Plan.new(
+      enabled: enabled,
+      equivalent: equivalent,
+      skipped_count: generation_skipped + disabled.length + sig_skipped,
+      disabled_mutations: disabled_mutations
+    )
+  end
+
+  private
+
+  attr_reader :config, :registry
+
+  def generate(subjects)
+    filter = build_ignore_filter
+    operator_options = build_operator_options
+    mutations = subjects.flat_map do |subject|
+      registry.mutations_for(subject, filter: filter, operator_options: operator_options)
+    end
+    skipped = filter ? filter.skipped_count : 0
+    [mutations, skipped]
+  end
+
+  def build_operator_options
+    { skip_heredoc_literals: config.skip_heredoc_literals? }
+  end
+
+  def build_ignore_filter
+    patterns = config.ignore_patterns
+    return nil if patterns.nil? || patterns.empty?
+
+    Evilution::AST::Pattern::Filter.new(patterns)
+  end
+
+  def filter_disabled(mutations)
+    enabled = []
+    disabled = []
+
+    mutations.each do |mutation|
+      if mutation_disabled?(mutation)
+        disabled << mutation
+      else
+        enabled << mutation
+      end
+    end
+
+    [enabled, disabled]
+  end
+
+  def mutation_disabled?(mutation)
+    ranges = disabled_ranges_for(mutation.file_path)
+    ranges.any? { |range| range.cover?(mutation.line) }
+  end
+
+  def disabled_ranges_for(file_path)
+    @disabled_ranges_cache[file_path] ||= begin
+      source = File.read(file_path)
+      @disable_detector.call(source)
+    rescue SystemCallError
+      []
+    end
+  end
+
+  def filter_sig_blocks(mutations)
+    enabled = []
+    skipped = 0
+
+    mutations.each do |mutation|
+      if mutation_in_sig_block?(mutation)
+        skipped += 1
+      else
+        enabled << mutation
+      end
+    end
+
+    [enabled, skipped]
+  end
+
+  def mutation_in_sig_block?(mutation)
+    ranges = sig_line_ranges_for(mutation.file_path)
+    ranges.any? { |range| range.cover?(mutation.line) }
+  end
+
+  def sig_line_ranges_for(file_path)
+    @sig_ranges_cache[file_path] ||= begin
+      source = File.read(file_path)
+      @sig_detector.line_ranges(source)
+    rescue SystemCallError
+      []
+    end
+  end
+
+  def filter_equivalent(mutations)
+    Evilution::Equivalent::Detector.new.call(mutations)
+  end
+end

data/lib/evilution/runner/report_publisher.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+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
+  end
+
+  def publish(summary)
+    reporter = build_reporter
+    return unless reporter
+
+    output = reporter.call(summary)
+    return if config.quiet
+
+    if config.html?
+      path = "evilution-report.html"
+      File.write(path, output)
+      warn "HTML report written to #{path}"
+    else
+      $stdout.puts(output)
+    end
+  end
+
+  def save_session(summary)
+    return unless config.save_session?
+
+    Evilution::Session::Store.new.save(summary)
+  rescue StandardError => e
+    warn "[evilution] failed to save session: #{e.message}" unless config.quiet
+  end
+
+  private
+
+  attr_reader :config
+
+  def build_reporter
+    case config.format
+    when :json
+      Evilution::Reporter::JSON.new(integration: config.integration)
+    when :text
+      Evilution::Reporter::CLI.new
+    when :html
+      Evilution::Reporter::HTML.new(baseline: load_baseline_session, integration: config.integration)
+    end
+  end
+
+  def load_baseline_session
+    path = config.baseline_session
+    return nil unless path
+
+    Evilution::Session::Store.new.load(path)
+  end
+end

data/lib/evilution/runner/subject_pipeline.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+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
+    @parser = parser
+  end
+
+  def call
+    subjects = parse_subjects
+    subjects = filter_by_descendants(subjects) if descendants_target?
+    subjects = filter_by_target(subjects) if method_target?
+    subjects = filter_by_line_ranges(subjects) if config.line_ranges?
+    subjects
+  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
+  end
+
+  private
+
+  attr_reader :config, :parser
+
+  def parse_subjects
+    target_files.flat_map { |file| parser.call(file) }
+  end
+
+  def source_glob_target?
+    config.target&.start_with?("source:")
+  end
+
+  def descendants_target?
+    config.target&.start_with?("descendants:")
+  end
+
+  def method_target?
+    config.target? && !source_glob_target? && !descendants_target?
+  end
+
+  def resolve_source_glob
+    pattern = config.target.delete_prefix("source:")
+    files = Dir.glob(pattern)
+    raise Evilution::Error, "no files found matching '#{pattern}'" if files.empty?
+
+    files.sort
+  end
+
+  def filter_by_descendants(subjects)
+    base_name = config.target.delete_prefix("descendants:")
+    inheritance = Evilution::AST::InheritanceScanner.call(target_files)
+    class_names = resolve_descendant_set(base_name, inheritance)
+    raise Evilution::Error, "no classes found matching '#{config.target}'" if class_names.empty?
+
+    subjects.select { |s| class_names.include?(s.name.split(/[#.]/).first) }
+  end
+
+  def resolve_descendant_set(base_name, inheritance)
+    descendants = Set.new
+    known = inheritance.key?(base_name) || inheritance.value?(base_name)
+    return descendants unless known
+
+    descendants.add(base_name)
+    changed = true
+    while changed
+      changed = false
+      inheritance.each do |child, parent|
+        next unless descendants.include?(parent)
+        next if descendants.include?(child)
+
+        descendants.add(child)
+        changed = true
+      end
+    end
+    descendants
+  end
+
+  def filter_by_target(subjects)
+    matched = subjects.select(&target_matcher)
+    raise Evilution::Error, "no method found matching '#{config.target}'" if matched.empty?
+
+    matched
+  end
+
+  def target_matcher
+    target = config.target
+    if target.end_with?("*")
+      prefix = target.chomp("*")
+      ->(s) { s.name.split(/[#.]/).first.start_with?(prefix) }
+    elsif target.end_with?("#", ".")
+      prefix = target
+      ->(s) { s.name.start_with?(prefix) }
+    elsif target.include?("#") || target.include?(".")
+      ->(s) { s.name == target }
+    else
+      ->(s) { s.name.start_with?("#{target}#") || s.name.start_with?("#{target}.") }
+    end
+  end
+
+  def filter_by_line_ranges(subjects)
+    subjects.select do |subject|
+      range = config.line_ranges[subject.file_path]
+      next true unless range
+
+      subject_start = subject.line_number
+      subject_end = subject_start + subject.source.count("\n")
+      subject_start <= range.last && subject_end >= range.first
+    end
+  end
+end