evilution 0.25.0 → 0.27.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/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/rspec/baseline_runner.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative "../rspec"
+
+class Evilution::Integration::RSpec::BaselineRunner
+  def call(spec_file)
+    require "rspec/core"
+    spec_dir = File.expand_path("spec")
+    $LOAD_PATH.unshift(spec_dir) unless $LOAD_PATH.include?(spec_dir)
+    ::RSpec.reset
+    status = ::RSpec::Core::Runner.run(
+      ["--format", "progress", "--no-color", "--order", "defined", spec_file]
+    )
+    status.zero?
+  end
+end

data/lib/evilution/integration/rspec/crash_detector_lifecycle.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "stringio"
+require_relative "../rspec"
+require_relative "../crash_detector"
+
+class Evilution::Integration::RSpec::CrashDetectorLifecycle
+  def current
+    if @detector
+      @detector.reset
+    else
+      @detector = Evilution::Integration::CrashDetector.new(StringIO.new)
+      ::RSpec.configuration.add_formatter(@detector)
+    end
+    @detector
+  end
+end

data/lib/evilution/integration/rspec/example_filter_applier.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative "../rspec"
+
+module Evilution::Integration::RSpec::ExampleFilterApplier
+  class Identity
+    def call(_mutation, files)
+      files
+    end
+  end
+
+  class Custom
+    def initialize(filter)
+      @filter = filter
+    end
+
+    def call(mutation, files)
+      @filter.call(mutation, files)
+    end
+  end
+end

data/lib/evilution/integration/rspec/framework_loader.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative "../rspec"
+require_relative "../crash_detector"
+
+class Evilution::Integration::RSpec::FrameworkLoader
+  def loaded?
+    @loaded == true
+  end
+
+  def call
+    return if @loaded
+
+    require "rspec/core"
+    add_spec_load_path
+    Evilution::Integration::CrashDetector.register_with_rspec
+    @loaded = true
+  rescue LoadError => e
+    raise Evilution::Error, "rspec-core is required but not available: #{e.message}"
+  end
+
+  private
+
+  def add_spec_load_path
+    spec_dir = File.expand_path("spec")
+    $LOAD_PATH.unshift(spec_dir) unless $LOAD_PATH.include?(spec_dir)
+  end
+end

data/lib/evilution/integration/rspec/result_builder.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "../rspec"
+
+class Evilution::Integration::RSpec::ResultBuilder
+  def unresolved(mutation)
+    {
+      passed: false,
+      unresolved: true,
+      error: "no matching spec resolved for #{mutation.file_path}",
+      test_command: "rspec (skipped: no spec resolved for #{mutation.file_path})"
+    }
+  end
+
+  def unresolved_example(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 from_run(status, command, detector)
+    return { passed: true, test_command: command } if status.zero?
+
+    if detector.only_crashes?
+      classes = detector.unique_crash_classes
+      return {
+        passed: false,
+        test_crashed: true,
+        error: "test crashes: #{detector.crash_summary}",
+        error_class: (classes.first if classes.length == 1),
+        test_command: command
+      }
+    end
+
+    { passed: false, test_command: command }
+  end
+end

data/lib/evilution/integration/rspec/state_guard/example_groups_constants.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative "../../rspec"
+
+class Evilution::Integration::RSpec::StateGuard; end unless defined?(Evilution::Integration::RSpec::StateGuard) # rubocop:disable Lint/EmptyClass
+
+class Evilution::Integration::RSpec::StateGuard::ExampleGroupsConstants
+  def snapshot
+    return nil unless defined?(::RSpec::ExampleGroups)
+
+    Set.new(::RSpec::ExampleGroups.constants(false))
+  end
+
+  def release(before)
+    return unless before
+    return unless defined?(::RSpec::ExampleGroups)
+
+    ::RSpec::ExampleGroups.constants(false).each do |c|
+      next if before.include?(c)
+
+      begin
+        ::RSpec::ExampleGroups.send(:remove_const, c)
+      rescue NameError
+        next
+      end
+    end
+  end
+end

data/lib/evilution/integration/rspec/state_guard/internals.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative "../../rspec"
+
+class Evilution::Integration::RSpec::StateGuard; end unless defined?(Evilution::Integration::RSpec::StateGuard) # rubocop:disable Lint/EmptyClass
+
+module Evilution::Integration::RSpec::StateGuard::Internals
+  module_function
+
+  def world_ivar(name)
+    world = ::RSpec.world
+    world.instance_variable_defined?(name) ? world.instance_variable_get(name) : nil
+  end
+
+  def config_ivar(name)
+    config = ::RSpec.configuration
+    config.instance_variable_defined?(name) ? config.instance_variable_get(name) : nil
+  end
+end

data/lib/evilution/integration/rspec/state_guard/object_space_example_groups.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative "../../rspec"
+
+class Evilution::Integration::RSpec::StateGuard; end unless defined?(Evilution::Integration::RSpec::StateGuard) # rubocop:disable Lint/EmptyClass
+
+class Evilution::Integration::RSpec::StateGuard::ObjectSpaceExampleGroups
+  def snapshot
+    groups = Set.new
+    ObjectSpace.each_object(Class) do |klass|
+      groups << klass.object_id if klass < ::RSpec::Core::ExampleGroup
+    rescue TypeError # rubocop:disable Lint/SuppressedException
+    end
+    groups
+  end
+
+  def release(eg_before)
+    return unless eg_before
+
+    ObjectSpace.each_object(Class) do |klass|
+      next unless klass < ::RSpec::Core::ExampleGroup
+      next if eg_before.include?(klass.object_id)
+
+      klass.constants(false).each do |const|
+        klass.send(:remove_const, const)
+      rescue NameError # rubocop:disable Lint/SuppressedException
+      end
+
+      klass.instance_variables.each do |ivar|
+        klass.remove_instance_variable(ivar)
+      end
+    rescue TypeError # rubocop:disable Lint/SuppressedException
+    end
+  end
+end

data/lib/evilution/integration/rspec/state_guard/reporter_arrays.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative "../../rspec"
+require_relative "internals"
+
+class Evilution::Integration::RSpec::StateGuard::ReporterArrays
+  IVARS = %i[@examples @failed_examples @pending_examples].freeze
+
+  def snapshot
+    reporter = Evilution::Integration::RSpec::StateGuard::Internals.config_ivar(:@reporter)
+    return nil unless reporter
+
+    IVARS.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(lengths)
+    return unless lengths
+
+    reporter = Evilution::Integration::RSpec::StateGuard::Internals.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
+end

data/lib/evilution/integration/rspec/state_guard/world_example_groups.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative "../../rspec"
+require_relative "internals"
+
+class Evilution::Integration::RSpec::StateGuard::WorldExampleGroups
+  def snapshot
+    groups = Evilution::Integration::RSpec::StateGuard::Internals.world_ivar(:@example_groups)
+    groups ? groups.dup.freeze : nil
+  end
+
+  def release(before)
+    return unless before
+
+    groups = Evilution::Integration::RSpec::StateGuard::Internals.world_ivar(:@example_groups)
+    return unless groups
+
+    groups.select! { |g| before.include?(g) }
+  end
+end