evilution 0.26.0 → 0.27.0

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"

data/lib/evilution/isolation/fork.rb

@@ -4,6 +4,7 @@ require "fileutils"
 require "tmpdir"
 require_relative "../memory"
 require_relative "../temp_dir_tracker"
+require_relative "../child_output"
 
 require_relative "../isolation"
 
@@ -59,8 +60,12 @@ class Evilution::Isolation::Fork
   end
 
   def suppress_child_output
-    $stdout.reopen(File::NULL, "w")
-    $stderr.reopen(File::NULL, "w")
+    if Evilution::ChildOutput.log_dir
+      Evilution::ChildOutput.redirect!
+    else
+      $stdout.reopen(File::NULL, "w")
+      $stderr.reopen(File::NULL, "w")
+    end
   end
 
   def execute_in_child(mutation, test_command)

data/lib/evilution/mcp/info_tool/actions/base.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative "../actions"
+require_relative "../response_formatter"
+
+class Evilution::MCP::InfoTool::Actions::Base
+  def self.call(**)
+    raise NotImplementedError
+  end
+
+  class << self
+    private
+
+    def success(payload)
+      Evilution::MCP::InfoTool::ResponseFormatter.success(payload)
+    end
+
+    def config_error(message)
+      Evilution::MCP::InfoTool::ResponseFormatter.error("config_error", message)
+    end
+  end
+end

data/lib/evilution/mcp/info_tool/actions/environment.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "../../../config"
+require_relative "../../../version"
+
+class Evilution::MCP::InfoTool::Actions::Environment < Evilution::MCP::InfoTool::Actions::Base
+  def self.call(**)
+    config = Evilution::Config.new(skip_config_file: false)
+    config_file = Evilution::Config::CONFIG_FILES.find { |path| File.exist?(path) }
+
+    success(
+      "version" => Evilution::VERSION,
+      "ruby" => RUBY_VERSION,
+      "config_file" => config_file,
+      "settings" => settings(config)
+    )
+  end
+
+  class << self
+    private
+
+    def settings(config)
+      {
+        "timeout" => config.timeout,
+        "format" => config.format,
+        "integration" => config.integration,
+        "jobs" => config.jobs,
+        "isolation" => config.isolation,
+        "baseline" => config.baseline,
+        "incremental" => config.incremental,
+        "fail_fast" => config.fail_fast,
+        "min_score" => config.min_score,
+        "suggest_tests" => config.suggest_tests,
+        "save_session" => config.save_session,
+        "target" => config.target,
+        "skip_heredoc_literals" => config.skip_heredoc_literals,
+        "ignore_patterns" => config.ignore_patterns
+      }
+    end
+  end
+end

data/lib/evilution/mcp/info_tool/actions/feedback.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "../../../version"
+require_relative "../../../feedback"
+require_relative "../../../feedback/messages"
+
+class Evilution::MCP::InfoTool::Actions::Feedback < Evilution::MCP::InfoTool::Actions::Base
+  def self.call(**)
+    success(
+      "discussion_url" => Evilution::Feedback::DISCUSSION_URL,
+      "version" => Evilution::VERSION,
+      "guidance_for_agent" => Evilution::Feedback::Messages.info_guidance
+    )
+  end
+end

data/lib/evilution/mcp/info_tool/actions/statuses.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "../status_glossary"
+
+class Evilution::MCP::InfoTool::Actions::Statuses < Evilution::MCP::InfoTool::Actions::Base
+  def self.call(**)
+    success("statuses" => Evilution::MCP::InfoTool::StatusGlossary.entries)
+  end
+end

data/lib/evilution/mcp/info_tool/actions/subjects.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "../config_factory"
+require_relative "../../../runner"
+require_relative "../../../mutator/registry"
+require_relative "../../../ast/pattern/filter"
+
+class Evilution::MCP::InfoTool::Actions::Subjects < Evilution::MCP::InfoTool::Actions::Base
+  def self.call(files: nil, line_ranges: nil, target: nil, integration: nil, skip_config: nil, **)
+    return config_error("files is required") if files.nil? || files.empty?
+
+    config = Evilution::MCP::InfoTool::ConfigFactory.subjects(
+      files: files, line_ranges: line_ranges,
+      target: target, integration: integration, skip_config: skip_config
+    )
+    runner = Evilution::Runner.new(config: config)
+    subjects = runner.parse_and_filter_subjects
+
+    registry = Evilution::Mutator::Registry.default
+    filter = build_subject_filter(config)
+    operator_options = { skip_heredoc_literals: config.skip_heredoc_literals? }
+
+    entries = subjects.map do |subj|
+      count = registry.mutations_for(subj, filter: filter, operator_options: operator_options).length
+      { "name" => subj.name, "file" => subj.file_path, "line" => subj.line_number, "mutations" => count }
+    ensure
+      subj.release_node!
+    end
+
+    success(
+      "subjects" => entries,
+      "total_subjects" => entries.length,
+      "total_mutations" => entries.sum { |e| e["mutations"] }
+    )
+  end
+
+  class << self
+    private
+
+    def build_subject_filter(config)
+      return nil if config.ignore_patterns.empty?
+
+      Evilution::AST::Pattern::Filter.new(config.ignore_patterns)
+    end
+  end
+end