evilution 0.26.0 → 0.28.0

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,43 @@
+# 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
+      # ObjectSpace iteration may surface partially-initialized or anonymous
+      # classes whose `<` comparison raises. Skipping them is safe — they
+      # cannot be ExampleGroup descendants we need to track.
+    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
+        # Constant may have been removed concurrently (e.g. via autoload
+        # reload) between #constants(false) and #remove_const. Best-effort
+        # cleanup — nothing to do if it's already gone.
+      end
+
+      klass.instance_variables.each do |ivar|
+        klass.remove_instance_variable(ivar)
+      end
+    rescue TypeError
+      # Same defensive case as #snapshot: skip classes whose `<` raises
+      # mid-iteration.
+    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

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative "../../rspec"
+require_relative "internals"
+
+class Evilution::Integration::RSpec::StateGuard::WorldFilteredExamples
+  def snapshot
+    fe = Evilution::Integration::RSpec::StateGuard::Internals.world_ivar(:@filtered_examples)
+    fe ? Set.new(fe.keys.map(&:object_id)) : nil
+  end
+
+  def release(snapshot_keys)
+    fe = Evilution::Integration::RSpec::StateGuard::Internals.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
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative "../../rspec"
+require_relative "internals"
+
+class Evilution::Integration::RSpec::StateGuard::WorldSourcesByPath
+  def snapshot
+    src = Evilution::Integration::RSpec::StateGuard::Internals.world_ivar(:@sources_by_path)
+    src ? Set.new(src.keys) : nil
+  end
+
+  def release(before)
+    return unless before
+
+    src = Evilution::Integration::RSpec::StateGuard::Internals.world_ivar(:@sources_by_path)
+    return unless src
+
+    src.delete_if { |k, _v| !before.include?(k) }
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "../rspec"
+require_relative "state_guard/object_space_example_groups"
+require_relative "state_guard/world_example_groups"
+require_relative "state_guard/world_sources_by_path"
+require_relative "state_guard/world_filtered_examples"
+require_relative "state_guard/reporter_arrays"
+require_relative "state_guard/example_groups_constants"
+
+class Evilution::Integration::RSpec::StateGuard
+  DEFAULT_STRATEGIES = [
+    ObjectSpaceExampleGroups.new,
+    WorldExampleGroups.new,
+    WorldSourcesByPath.new,
+    WorldFilteredExamples.new,
+    ReporterArrays.new,
+    ExampleGroupsConstants.new
+  ].freeze
+
+  def initialize(strategies: DEFAULT_STRATEGIES)
+    @strategies = strategies
+  end
+
+  def snapshot
+    @strategies.map { |s| [s, s.snapshot] }
+  end
+
+  def release(token)
+    token.reverse_each { |strategy, captured| release_one(strategy, captured) }
+  end
+
+  private
+
+  def release_one(strategy, captured)
+    strategy.release(captured)
+  rescue StandardError => e
+    warn "[evilution] state release failed for #{strategy.class.name}: #{e.class}: #{e.message}"
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative "../rspec"
+
+class Evilution::Integration::RSpec::TestFileResolver
+  def initialize(test_files:, spec_selector:, related_spec_heuristic:,
+                 related_specs_heuristic_enabled:, fallback_to_full_suite:, warner:)
+    @test_files = test_files
+    @spec_selector = spec_selector
+    @related_spec_heuristic = related_spec_heuristic
+    @related_specs_heuristic_enabled = related_specs_heuristic_enabled
+    @fallback_to_full_suite = fallback_to_full_suite
+    @warner = warner
+  end
+
+  def call(mutation)
+    return @test_files if @test_files
+
+    resolved = Array(@spec_selector.call(mutation.file_path))
+    if resolved.empty?
+      @warner.call(mutation.file_path, fallback_to_full_suite: @fallback_to_full_suite)
+      return @fallback_to_full_suite ? ["spec"] : nil
+    end
+
+    return resolved unless @related_specs_heuristic_enabled
+
+    related = @related_spec_heuristic.call(mutation)
+    (resolved + related).uniq
+  end
+end

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative "../rspec"
+
+class Evilution::Integration::RSpec::UnresolvedSpecWarner
+  def initialize
+    @warned = Set.new
+  end
+
+  def call(file_path, fallback_to_full_suite:)
+    return if @warned.include?(file_path)
+
+    @warned << file_path
+    action = fallback_to_full_suite ? "running full suite" : "marking mutation unresolved"
+    warn "[evilution] No matching spec found for #{file_path}, #{action}. " \
+         "Use --spec to specify the spec file."
+  end
+end

data/lib/evilution/integration/rspec.rb

@@ -2,7 +2,6 @@
 
 require "stringio"
 require_relative "base"
-require_relative "crash_detector"
 require_relative "../spec_resolver"
 require_relative "../spec_selector"
 require_relative "../related_spec_heuristic"
@@ -11,262 +10,92 @@ require_relative "../integration"
 
 class Evilution::Integration::RSpec < Evilution::Integration::Base
   def self.baseline_runner
-    lambda { |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?
-    }
+    BaselineRunner.new
   end
 
   def self.baseline_options
     { runner: baseline_runner }
   end
 
-  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_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
+  def initialize(
+    test_files: nil,
+    hooks: nil,
+    related_specs_heuristic: false,
+    fallback_to_full_suite: false,
+    spec_selector: nil,
+    example_filter: nil,
+    framework_loader: FrameworkLoader.new,
+    test_file_resolver: nil,
+    example_filter_applier: nil,
+    crash_detector_lifecycle: CrashDetectorLifecycle.new,
+    result_builder: ResultBuilder.new,
+    state_guard: StateGuard.new
+  )
+    @framework_loader = framework_loader
+    @test_file_resolver = test_file_resolver || TestFileResolver.new(
+      test_files: test_files,
+      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,
+      warner: UnresolvedSpecWarner.new
+    )
+    @example_filter_applier = example_filter_applier || build_example_filter_applier(example_filter)
+    @crash_detector_lifecycle = crash_detector_lifecycle
+    @result_builder = result_builder
+    @state_guard = state_guard
     super(hooks: hooks)
   end
 
   private
 
-  attr_reader :test_files
+  def build_example_filter_applier(example_filter)
+    return ExampleFilterApplier::Identity.new unless example_filter
+
+    ExampleFilterApplier::Custom.new(example_filter)
+  end
 
   def ensure_framework_loaded
-    return if @rspec_loaded
+    return if @framework_loader.loaded?
 
     fire_hook(:setup_integration_pre, integration: :rspec)
-    require "rspec/core"
-    add_spec_load_path
-    Evilution::Integration::CrashDetector.register_with_rspec
-    @rspec_loaded = true
+    @framework_loader.call
     fire_hook(:setup_integration_post, integration: :rspec)
-  rescue LoadError => e
-    raise Evilution::Error, "rspec-core is required but not available: #{e.message}"
   end
 
   def run_tests(mutation)
-    reset_state
+    files = @test_file_resolver.call(mutation)
+    return @result_builder.unresolved(mutation) if files.nil?
 
-    files = resolve_test_files(mutation)
-    return unresolved_result(mutation) if files.nil?
+    targets = @example_filter_applier.call(mutation, files)
+    return @result_builder.unresolved_example(mutation) if targets.nil?
 
-    targets = apply_example_filter(mutation, files)
-    return unresolved_example_result(mutation) if targets.nil?
-
-    out = StringIO.new
-    err = StringIO.new
-    args = build_args(targets)
+    args = ["--format", "progress", "--no-color", "--order", "defined", *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)
-  rescue StandardError => e
-    { 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,
-      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_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
-    else
-      ::RSpec.reset
-    end
-  end
-
-  def snapshot_example_groups
-    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_rspec_state(eg_before)
-    release_example_groups(eg_before)
-    ::RSpec::ExampleGroups.remove_all_constants if defined?(::RSpec::ExampleGroups)
-    release_world_example_groups
-  end
-
-  def release_example_groups(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
-
-  def release_world_example_groups
-    world = ::RSpec.world
-    world.instance_variable_get(:@example_groups).clear if world.instance_variable_defined?(:@example_groups)
-    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
-    else
-      @crash_detector = Evilution::Integration::CrashDetector.new(StringIO.new)
-      ::RSpec.configuration.add_formatter(@crash_detector)
-    end
-    @crash_detector
-  end
-
-  def build_rspec_result(status, command, detector)
-    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
-      { passed: false, test_command: command }
-    end
-  end
-
-  def resolve_test_files(mutation)
-    return test_files if test_files
-
-    resolved = Array(@spec_selector.call(mutation.file_path))
-    if resolved.empty?
-      warn_unresolved_spec(mutation.file_path)
-      return @fallback_to_full_suite ? ["spec"] : nil
+    reset_examples
+    detector = @crash_detector_lifecycle.current
+    snapshot = @state_guard.snapshot
+    begin
+      status = ::RSpec::Core::Runner.run(args, StringIO.new, StringIO.new)
+      @result_builder.from_run(status, command, detector)
+    rescue StandardError => e
+      { passed: false, error: e.message, test_command: command }
+    ensure
+      @state_guard.release(snapshot)
     end
-
-    return resolved unless @related_specs_heuristic_enabled
-
-    related = @related_spec_heuristic.call(mutation)
-    (resolved + related).uniq
   end
 
-  def warn_unresolved_spec(file_path)
-    return if @warned_files.include?(file_path)
-
-    @warned_files << file_path
-    action = @fallback_to_full_suite ? "running full suite" : "marking mutation unresolved"
-    warn "[evilution] No matching spec found for #{file_path}, #{action}. " \
-         "Use --spec to specify the spec file."
-  end
-
-  # RSpec's CLI adds spec/ to $LOAD_PATH so that `--require spec_helper`
-  # (commonly in .rspec) resolves. We call Runner.run directly, bypassing
-  # the CLI, so we must replicate this.
-  def add_spec_load_path
-    spec_dir = File.expand_path("spec")
-    $LOAD_PATH.unshift(spec_dir) unless $LOAD_PATH.include?(spec_dir)
+  def reset_examples
+    ::RSpec.respond_to?(:clear_examples) ? ::RSpec.clear_examples : ::RSpec.reset
   end
 end
+
+require_relative "rspec/framework_loader"
+require_relative "rspec/test_file_resolver"
+require_relative "rspec/unresolved_spec_warner"
+require_relative "rspec/example_filter_applier"
+require_relative "rspec/crash_detector_lifecycle"
+require_relative "rspec/result_builder"
+require_relative "rspec/baseline_runner"
+require_relative "rspec/state_guard"