evilution 0.24.0 → 0.26.0

data/lib/evilution/integration/base.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require "prism"
 require_relative "../integration"
+require_relative "loading/mutation_applier"
 
 class Evilution::Integration::Base
   def self.baseline_runner
@@ -12,14 +12,15 @@ class Evilution::Integration::Base
     raise NotImplementedError, "#{name}.baseline_options must be implemented"
   end
 
-  def initialize(hooks: nil)
+  def initialize(hooks: nil, mutation_applier: Evilution::Integration::Loading::MutationApplier.new)
     @hooks = hooks
+    @mutation_applier = mutation_applier
   end
 
   def call(mutation)
     ensure_framework_loaded
     fire_hook(:mutation_insert_pre, mutation: mutation, file_path: mutation.file_path)
-    load_error = apply_mutation(mutation)
+    load_error = @mutation_applier.call(mutation)
     return load_error if load_error
 
     fire_hook(:mutation_insert_post, mutation: mutation, file_path: mutation.file_path)
@@ -47,156 +48,4 @@ class Evilution::Integration::Base
   def fire_hook(event, **payload)
     @hooks.fire(event, **payload) if @hooks
   end
-
-  def apply_mutation(mutation)
-    prism_error = validate_mutated_syntax(mutation.mutated_source)
-    return prism_error if prism_error
-
-    pin_autoloaded_constants(mutation.original_source)
-    clear_concern_state(mutation.file_path)
-    with_redefinition_recovery(mutation.original_source) do
-      eval_mutated_source(mutation)
-    end
-    nil
-  rescue SyntaxError => e
-    {
-      passed: false,
-      error: "syntax error in mutated source: #{e.message}",
-      error_class: e.class.name,
-      error_backtrace: Array(e.backtrace).first(5)
-    }
-  rescue ScriptError, StandardError => e
-    {
-      passed: false,
-      error: "#{e.class}: #{e.message}",
-      error_class: e.class.name,
-      error_backtrace: Array(e.backtrace).first(5)
-    }
-  end
-
-  def validate_mutated_syntax(source)
-    return nil if Prism.parse(source).success?
-
-    {
-      passed: false,
-      error: "mutated source has syntax errors",
-      error_class: "SyntaxError",
-      error_backtrace: []
-    }
-  end
-
-  # Evaluate the mutated source with __FILE__ set to the original path so
-  # that `require_relative` and `__dir__` resolve against the real source
-  # tree, where sibling files actually exist.
-  def eval_mutated_source(mutation)
-    absolute = File.expand_path(mutation.file_path)
-    # rubocop:disable Security/Eval
-    eval(mutation.mutated_source, TOPLEVEL_BINDING, absolute, 1)
-    # rubocop:enable Security/Eval
-  end
-
-  def with_redefinition_recovery(original_source)
-    yield
-  rescue ArgumentError => e
-    raise unless redefinition_conflict?(e)
-
-    remove_defined_constants(original_source)
-    yield
-  end
-
-  def redefinition_conflict?(error)
-    error.message.include?("already defined")
-  end
-
-  def pin_autoloaded_constants(source)
-    collect_constant_names(Prism.parse(source).value).each do |name|
-      Object.const_get(name) if Object.const_defined?(name, false)
-    rescue NameError # :nodoc:
-      nil
-    end
-  end
-
-  def collect_constant_names(node, nesting = [])
-    names = []
-    case node
-    when Prism::ModuleNode, Prism::ClassNode
-      const = node.constant_path.full_name
-      qualified = nesting.any? && !const.include?("::") ? "#{nesting.join("::")}::#{const}" : const
-      names << qualified
-      names.concat(collect_constant_names(node.body, nesting + [const])) if node.body
-    when Prism::ProgramNode
-      names.concat(collect_constant_names(node.statements, nesting)) if node.statements
-    when Prism::StatementsNode
-      node.body.each { |child| names.concat(collect_constant_names(child, nesting)) }
-    end
-    names
-  end
-
-  def remove_defined_constants(source)
-    collect_constant_names(Prism.parse(source).value).reverse_each do |name|
-      parent_name, _, local_name = name.rpartition("::")
-      parent = resolve_loaded_constant_parent(parent_name)
-      next unless parent
-      next unless parent.const_defined?(local_name, false)
-      next if parent.autoload?(local_name)
-
-      parent.send(:remove_const, local_name.to_sym)
-    end
-  end
-
-  def resolve_loaded_constant_parent(parent_name)
-    return Object if parent_name.empty?
-
-    parent_name.split("::").reduce(Object) do |mod, part|
-      return nil unless mod.const_defined?(part, false)
-      return nil if mod.autoload?(part)
-
-      resolved = mod.const_get(part, false)
-      return nil unless resolved.is_a?(Module)
-
-      resolved
-    end
-  end
-
-  def clear_concern_state(file_path)
-    return unless defined?(ActiveSupport::Concern)
-
-    absolute = File.expand_path(file_path)
-    subpath = resolve_require_subpath(file_path)
-
-    ObjectSpace.each_object(Module) do |mod|
-      next unless mod.singleton_class.ancestors.include?(ActiveSupport::Concern)
-
-      %i[@_included_block @_prepended_block].each do |ivar|
-        next unless mod.instance_variable_defined?(ivar)
-
-        block = mod.instance_variable_get(ivar)
-        block_file = block.source_location&.first
-        next unless block_file
-
-        expanded = File.expand_path(block_file)
-        mod.remove_instance_variable(ivar) if source_matches?(expanded, absolute, subpath)
-      end
-    end
-  end
-
-  def source_matches?(block_path, absolute, subpath)
-    block_path == absolute || (subpath && block_path.end_with?("/#{subpath}"))
-  end
-
-  def resolve_require_subpath(file_path)
-    absolute = File.expand_path(file_path)
-    best_subpath = nil
-
-    $LOAD_PATH.each do |entry|
-      dir = File.expand_path(entry)
-      prefix = dir.end_with?("/") ? dir : "#{dir}/"
-      next unless absolute.start_with?(prefix)
-
-      candidate = absolute.delete_prefix(prefix)
-      best_subpath = candidate if best_subpath.nil? || candidate.length < best_subpath.length
-    end
-
-    best_subpath
-  end
 end

data/lib/evilution/integration/crash_detector.rb

@@ -41,8 +41,11 @@ class Evilution::Integration::CrashDetector
   def crash_summary
     return nil if @crashes.empty?
 
-    types = @crashes.map { |e| e.class.name }.uniq
-    "#{types.join(", ")} (#{@crashes.length} crash#{"es" unless @crashes.length == 1})"
+    "#{unique_crash_classes.join(", ")} (#{@crashes.length} crash#{"es" unless @crashes.length == 1})"
+  end
+
+  def unique_crash_classes
+    @crashes.map { |e| e.class.name }.uniq
   end
 
   private

data/lib/evilution/integration/loading/concern_state_cleaner.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative "../loading"
+require_relative "../../load_path/subpath_resolver"
+
+# Re-evaluating an `ActiveSupport::Concern` module raises
+# "MultipleIncludedBlocks" because AS::Concern records the block source
+# location on the first include/prepend call. Before a re-eval we clear the
+# `@_included_block` / `@_prepended_block` ivar on modules whose block came
+# from the file we're about to re-eval.
+class Evilution::Integration::Loading::ConcernStateCleaner
+  IVARS = %i[@_included_block @_prepended_block].freeze
+
+  def initialize(subpath_resolver: Evilution::LoadPath::SubpathResolver.new)
+    @subpath_resolver = subpath_resolver
+  end
+
+  def call(file_path)
+    return unless defined?(ActiveSupport::Concern)
+
+    absolute = File.expand_path(file_path)
+    subpath = @subpath_resolver.call(file_path)
+
+    ObjectSpace.each_object(Module) do |mod|
+      next unless mod.singleton_class.ancestors.include?(ActiveSupport::Concern)
+
+      clear_concern_ivars(mod, absolute, subpath)
+    end
+  end
+
+  private
+
+  def clear_concern_ivars(mod, absolute, subpath)
+    IVARS.each do |ivar|
+      next unless mod.instance_variable_defined?(ivar)
+
+      block = mod.instance_variable_get(ivar)
+      block_file = block.source_location&.first
+      next unless block_file
+
+      expanded = File.expand_path(block_file)
+      mod.remove_instance_variable(ivar) if source_matches?(expanded, absolute, subpath)
+    end
+  end
+
+  def source_matches?(block_path, absolute, subpath)
+    block_path == absolute || (subpath && block_path.end_with?("/#{subpath}"))
+  end
+end

data/lib/evilution/integration/loading/constant_pinner.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative "../loading"
+require_relative "../../ast/constant_names"
+
+# Defeat Zeitwerk's re-autoload hook when we re-eval a file in place. Walking
+# the source AST for top-level class/module names and calling `const_get` on
+# each tells Zeitwerk "this constant is loaded" so our re-eval does not lose
+# state (e.g. `@_included_block`) to a follow-up autoload.
+class Evilution::Integration::Loading::ConstantPinner
+  def initialize(constant_names: Evilution::AST::ConstantNames.new)
+    @constant_names = constant_names
+  end
+
+  def call(source)
+    names = @constant_names.call(source)
+    names.each do |name|
+      Object.const_get(name) if Object.const_defined?(name, false)
+    rescue NameError # :nodoc:
+      nil
+    end
+    names
+  end
+end

data/lib/evilution/integration/loading/mutation_applier.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_relative "../loading"
+require_relative "syntax_validator"
+require_relative "constant_pinner"
+require_relative "concern_state_cleaner"
+require_relative "source_evaluator"
+require_relative "redefinition_recovery"
+
+# Composes the load-time pipeline that applies a mutation's new source to the
+# running VM: syntax-validate -> pin top-level constants (beats Zeitwerk) ->
+# clear AS::Concern state -> eval inside a redefinition-recovery wrapper.
+# Returns nil on success or a failure-shaped hash on any error.
+class Evilution::Integration::Loading::MutationApplier
+  def initialize(syntax_validator: Evilution::Integration::Loading::SyntaxValidator.new,
+                 constant_pinner: Evilution::Integration::Loading::ConstantPinner.new,
+                 concern_state_cleaner: Evilution::Integration::Loading::ConcernStateCleaner.new,
+                 source_evaluator: Evilution::Integration::Loading::SourceEvaluator.new,
+                 redefinition_recovery: Evilution::Integration::Loading::RedefinitionRecovery.new)
+    @syntax_validator = syntax_validator
+    @constant_pinner = constant_pinner
+    @concern_state_cleaner = concern_state_cleaner
+    @source_evaluator = source_evaluator
+    @redefinition_recovery = redefinition_recovery
+  end
+
+  def call(mutation)
+    syntax_error = @syntax_validator.call(mutation.mutated_source)
+    return syntax_error if syntax_error
+
+    @constant_pinner.call(mutation.original_source)
+    @concern_state_cleaner.call(mutation.file_path)
+    @redefinition_recovery.call(mutation.original_source) do
+      @source_evaluator.call(mutation.mutated_source, mutation.file_path)
+    end
+    nil
+  rescue SyntaxError => e
+    {
+      passed: false,
+      error: "syntax error in mutated source: #{e.message}",
+      error_class: e.class.name,
+      error_backtrace: Array(e.backtrace).first(5)
+    }
+  rescue ScriptError, StandardError => e
+    {
+      passed: false,
+      error: "#{e.class}: #{e.message}",
+      error_class: e.class.name,
+      error_backtrace: Array(e.backtrace).first(5)
+    }
+  end
+end

data/lib/evilution/integration/loading/redefinition_recovery.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require_relative "../loading"
+require_relative "../../ast/constant_names"
+
+# Some DSLs (Rails 8 enum, define_method guards) raise ArgumentError on
+# re-declaration. On such a conflict we strip constants declared in the source
+# and retry the load once against a fresh namespace.
+class Evilution::Integration::Loading::RedefinitionRecovery
+  def initialize(constant_names: Evilution::AST::ConstantNames.new)
+    @constant_names = constant_names
+  end
+
+  def call(source, &block)
+    block.call
+  rescue ArgumentError => e
+    raise unless redefinition_conflict?(e)
+
+    remove_defined_constants(source)
+    block.call
+  end
+
+  private
+
+  def redefinition_conflict?(error)
+    error.message.include?("already defined")
+  end
+
+  def remove_defined_constants(source)
+    @constant_names.call(source).reverse_each do |name|
+      parent_name, _, local_name = name.rpartition("::")
+      parent = resolve_loaded_constant_parent(parent_name)
+      next unless parent
+      next unless parent.const_defined?(local_name, false)
+      next if parent.autoload?(local_name)
+
+      parent.send(:remove_const, local_name.to_sym)
+    end
+  end
+
+  def resolve_loaded_constant_parent(parent_name)
+    return Object if parent_name.empty?
+
+    parent_name.split("::").reduce(Object) do |mod, part|
+      return nil unless mod.const_defined?(part, false)
+      return nil if mod.autoload?(part)
+
+      resolved = mod.const_get(part, false)
+      return nil unless resolved.is_a?(Module)
+
+      resolved
+    end
+  end
+end

data/lib/evilution/integration/loading/source_evaluator.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative "../loading"
+
+# Evaluate source with __FILE__ set to the absolute original path so that
+# `require_relative` and `__dir__` resolve against the real source tree, where
+# sibling files actually exist.
+class Evilution::Integration::Loading::SourceEvaluator
+  def call(source, file_path)
+    absolute = File.expand_path(file_path)
+    # rubocop:disable Security/Eval
+    eval(source, TOPLEVEL_BINDING, absolute, 1)
+    # rubocop:enable Security/Eval
+  end
+end

data/lib/evilution/integration/loading/syntax_validator.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "prism"
+require_relative "../loading"
+
+class Evilution::Integration::Loading::SyntaxValidator
+  ERROR_MESSAGE = "mutated source has syntax errors"
+
+  def call(source)
+    return nil if Prism.parse(source).success?
+
+    {
+      passed: false,
+      error: ERROR_MESSAGE,
+      error_class: "SyntaxError",
+      error_backtrace: []
+    }
+  end
+end

data/lib/evilution/integration/loading.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require_relative "../integration"
+
+module Evilution::Integration::Loading
+end

data/lib/evilution/integration/minitest.rb

@@ -4,6 +4,7 @@ require "stringio"
 require_relative "base"
 require_relative "minitest_crash_detector"
 require_relative "../spec_resolver"
+require_relative "../spec_selector"
 
 require_relative "../integration"
 
@@ -35,10 +36,12 @@ class Evilution::Integration::Minitest < Evilution::Integration::Base
     }
   end
 
-  def initialize(test_files: nil, hooks: nil, fallback_to_full_suite: false)
+  def initialize(test_files: nil, hooks: nil, fallback_to_full_suite: false, spec_selector: nil)
     @test_files = test_files
     @minitest_loaded = false
-    @spec_resolver = Evilution::SpecResolver.new(test_dir: "test", test_suffix: "_test.rb", request_dir: "integration")
+    @spec_selector = spec_selector || Evilution::SpecSelector.new(
+      spec_resolver: Evilution::SpecResolver.new(test_dir: "test", test_suffix: "_test.rb", request_dir: "integration")
+    )
     @fallback_to_full_suite = fallback_to_full_suite
     @crash_detector = nil
     @warned_files = Set.new
@@ -124,10 +127,12 @@ class Evilution::Integration::Minitest < Evilution::Integration::Base
     if passed
       { passed: true, test_command: command }
     elsif detector.only_crashes?
+      classes = detector.unique_crash_classes
       {
         passed: false,
         test_crashed: true,
         error: "test crashes: #{detector.crash_summary}",
+        error_class: (classes.first if classes.length == 1),
         test_command: command
       }
     else
@@ -138,13 +143,13 @@ class Evilution::Integration::Minitest < Evilution::Integration::Base
   def resolve_test_files(mutation)
     return test_files if test_files
 
-    resolved = @spec_resolver.call(mutation.file_path)
-    unless resolved
+    resolved = Array(@spec_selector.call(mutation.file_path))
+    if resolved.empty?
       warn_unresolved_test(mutation.file_path)
       return @fallback_to_full_suite ? glob_test_files : nil
     end
 
-    [resolved]
+    resolved
   end
 
   def glob_test_files

data/lib/evilution/integration/minitest_crash_detector.rb

@@ -49,7 +49,10 @@ class Evilution::Integration::MinitestCrashDetector
   def crash_summary
     return nil if @crashes.empty?
 
-    types = @crashes.map { |e| e.class.name }.uniq
-    "#{types.join(", ")} (#{@crashes.length} crash#{"es" unless @crashes.length == 1})"
+    "#{unique_crash_classes.join(", ")} (#{@crashes.length} crash#{"es" unless @crashes.length == 1})"
+  end
+
+  def unique_crash_classes
+    @crashes.map { |e| e.class.name }.uniq
   end
 end

data/lib/evilution/integration/rspec.rb

@@ -4,6 +4,7 @@ require "stringio"
 require_relative "base"
 require_relative "crash_detector"
 require_relative "../spec_resolver"
+require_relative "../spec_selector"
 require_relative "../related_spec_heuristic"
 
 require_relative "../integration"
@@ -26,13 +27,15 @@ class Evilution::Integration::RSpec < Evilution::Integration::Base
     { runner: baseline_runner }
   end
 
-  def initialize(test_files: nil, hooks: nil, related_specs_heuristic: false, fallback_to_full_suite: false)
+  def initialize(test_files: nil, hooks: nil, related_specs_heuristic: false, fallback_to_full_suite: false,
+                 spec_selector: nil, example_filter: nil)
     @test_files = test_files
     @rspec_loaded = false
-    @spec_resolver = Evilution::SpecResolver.new
+    @spec_selector = spec_selector || Evilution::SpecSelector.new
     @related_spec_heuristic = Evilution::RelatedSpecHeuristic.new
     @related_specs_heuristic_enabled = related_specs_heuristic
     @fallback_to_full_suite = fallback_to_full_suite
+    @example_filter = example_filter
     @crash_detector = nil
     @warned_files = Set.new
     super(hooks: hooks)
@@ -61,13 +64,18 @@ class Evilution::Integration::RSpec < Evilution::Integration::Base
     files = resolve_test_files(mutation)
     return unresolved_result(mutation) if files.nil?
 
+    targets = apply_example_filter(mutation, files)
+    return unresolved_example_result(mutation) if targets.nil?
+
     out = StringIO.new
     err = StringIO.new
-    args = build_args(files)
+    args = build_args(targets)
     command = "rspec #{args.join(" ")}"
 
     detector = reset_crash_detector
     eg_before = snapshot_example_groups
+    fe_before = snapshot_filtered_examples_keys
+    rep_before = snapshot_reporter_lengths
     status = ::RSpec::Core::Runner.run(args, out, err)
 
     build_rspec_result(status, command, detector)
@@ -75,12 +83,20 @@ class Evilution::Integration::RSpec < Evilution::Integration::Base
     { passed: false, error: e.message, test_command: command }
   ensure
     release_rspec_state(eg_before)
+    release_filtered_examples(fe_before)
+    release_reporter_state(rep_before)
   end
 
   def build_args(files)
     ["--format", "progress", "--no-color", "--order", "defined", *files]
   end
 
+  def apply_example_filter(mutation, files)
+    return files unless @example_filter
+
+    @example_filter.call(mutation, files)
+  end
+
   def unresolved_result(mutation)
     {
       passed: false,
@@ -90,6 +106,15 @@ class Evilution::Integration::RSpec < Evilution::Integration::Base
     }
   end
 
+  def unresolved_example_result(mutation)
+    {
+      passed: false,
+      unresolved: true,
+      error: "no matching example found for #{mutation.file_path}",
+      test_command: "rspec (skipped: no matching example for #{mutation.file_path})"
+    }
+  end
+
   def reset_state
     if ::RSpec.respond_to?(:clear_examples)
       ::RSpec.clear_examples
@@ -138,6 +163,54 @@ class Evilution::Integration::RSpec < Evilution::Integration::Base
     world.instance_variable_set(:@sources_by_path, {}) if world.instance_variable_defined?(:@sources_by_path)
   end
 
+  def snapshot_filtered_examples_keys
+    fe = rspec_world_ivar(:@filtered_examples)
+    fe ? Set.new(fe.keys.map(&:object_id)) : nil
+  end
+
+  def snapshot_reporter_lengths
+    reporter = rspec_config_ivar(:@reporter)
+    return nil unless reporter
+
+    %i[@examples @failed_examples @pending_examples].each_with_object({}) do |ivar, acc|
+      next unless reporter.instance_variable_defined?(ivar)
+
+      arr = reporter.instance_variable_get(ivar)
+      acc[ivar] = arr.length if arr.is_a?(Array)
+    end
+  end
+
+  def release_filtered_examples(snapshot_keys)
+    fe = rspec_world_ivar(:@filtered_examples)
+    return unless fe && snapshot_keys
+
+    fe.each_key.to_a.each do |k|
+      fe.delete(k) unless snapshot_keys.include?(k.object_id)
+    end
+  end
+
+  def release_reporter_state(lengths)
+    return unless lengths
+
+    reporter = rspec_config_ivar(:@reporter)
+    return unless reporter
+
+    lengths.each do |ivar, length|
+      arr = reporter.instance_variable_get(ivar)
+      arr.slice!(length..) if arr.is_a?(Array) && arr.length > length
+    end
+  end
+
+  def rspec_world_ivar(ivar)
+    world = ::RSpec.world
+    world.instance_variable_defined?(ivar) ? world.instance_variable_get(ivar) : nil
+  end
+
+  def rspec_config_ivar(ivar)
+    config = ::RSpec.configuration
+    config.instance_variable_defined?(ivar) ? config.instance_variable_get(ivar) : nil
+  end
+
   def reset_crash_detector
     if @crash_detector
       @crash_detector.reset
@@ -152,10 +225,12 @@ class Evilution::Integration::RSpec < Evilution::Integration::Base
     if status.zero?
       { passed: true, test_command: command }
     elsif detector.only_crashes?
+      classes = detector.unique_crash_classes
       {
         passed: false,
         test_crashed: true,
         error: "test crashes: #{detector.crash_summary}",
+        error_class: (classes.first if classes.length == 1),
         test_command: command
       }
     else
@@ -166,16 +241,16 @@ class Evilution::Integration::RSpec < Evilution::Integration::Base
   def resolve_test_files(mutation)
     return test_files if test_files
 
-    resolved = @spec_resolver.call(mutation.file_path)
-    unless resolved
+    resolved = Array(@spec_selector.call(mutation.file_path))
+    if resolved.empty?
       warn_unresolved_spec(mutation.file_path)
       return @fallback_to_full_suite ? ["spec"] : nil
     end
 
-    return [resolved] unless @related_specs_heuristic_enabled
+    return resolved unless @related_specs_heuristic_enabled
 
     related = @related_spec_heuristic.call(mutation)
-    ([resolved] + related).uniq
+    (resolved + related).uniq
   end
 
   def warn_unresolved_spec(file_path)