evilution 0.17.0 → 0.19.0

data/lib/evilution/integration/rspec.rb

@@ -12,6 +12,8 @@ class Evilution::Integration::RSpec < Evilution::Integration::Base
   def initialize(test_files: nil, hooks: nil)
     @test_files = test_files
     @rspec_loaded = false
+    @spec_resolver = Evilution::SpecResolver.new
+    @warned_files = Set.new
     super(hooks: hooks)
   end
 
@@ -98,9 +100,14 @@ class Evilution::Integration::RSpec < Evilution::Integration::Base
     # process exits after each run.
     #
     # This integration can also be invoked directly (e.g. in specs or alternative
-    # runners) without fork isolation. RSpec.reset is called here as
-    # defense-in-depth to clear RSpec state between mutation runs in those cases.
-    ::RSpec.reset
+    # runners) without fork isolation. clear_examples reuses the existing World
+    # and Configuration (avoiding per-run instance growth) while clearing loaded
+    # example groups, constants, and configuration state.
+    if ::RSpec.respond_to?(:clear_examples)
+      ::RSpec.clear_examples
+    else
+      ::RSpec.reset
+    end
 
     out = StringIO.new
     err = StringIO.new
@@ -108,11 +115,60 @@ class Evilution::Integration::RSpec < Evilution::Integration::Base
     args = build_args(mutation)
     command = "rspec #{args.join(" ")}"
 
+    eg_before = snapshot_example_groups
     status = ::RSpec::Core::Runner.run(args, out, err)
 
     { passed: status.zero?, test_command: command }
   rescue StandardError => e
     { passed: false, error: e.message, test_command: command }
+  ensure
+    release_rspec_state(eg_before)
+  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)
+    # Remove ExampleGroups constants so the named reference is dropped.
+    # We avoid a full RSpec.reset here because it creates new World and
+    # Configuration instances each call; the pre-run reset already handles
+    # that. Instead, clear the world's example_groups array (which holds
+    # direct class references) and the source cache.
+    ::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)
+
+      # Remove nested module constants (LetDefinitions, NamedSubjectPreventSuper)
+      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 build_args(mutation)
@@ -123,7 +179,20 @@ class Evilution::Integration::RSpec < Evilution::Integration::Base
   def resolve_test_files(mutation)
     return test_files if test_files
 
-    resolved = Evilution::SpecResolver.new.call(mutation.file_path)
-    resolved ? [resolved] : ["spec"]
+    resolved = @spec_resolver.call(mutation.file_path)
+    if resolved
+      [resolved]
+    else
+      warn_unresolved_spec(mutation.file_path)
+      ["spec"]
+    end
+  end
+
+  def warn_unresolved_spec(file_path)
+    return if @warned_files.include?(file_path)
+
+    @warned_files << file_path
+    warn "[evilution] No matching spec found for #{file_path}, running full suite. " \
+         "Use --spec to specify the spec file."
   end
 end

data/lib/evilution/isolation/fork.rb

@@ -16,6 +16,7 @@ class Evilution::Isolation::Fork
   def call(mutation:, test_command:, timeout:)
     sandbox_dir = Dir.mktmpdir("evilution-run")
     start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    parent_rss = Evilution::Memory.rss_kb
     read_io, write_io = IO.pipe
 
     pid = ::Process.fork do
@@ -33,7 +34,7 @@ class Evilution::Isolation::Fork
     result = wait_for_result(pid, read_io, timeout)
     duration = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time
 
-    build_mutation_result(mutation, result, duration)
+    build_mutation_result(mutation, result, duration, parent_rss)
   ensure
     read_io&.close
     write_io&.close
@@ -67,10 +68,12 @@ class Evilution::Isolation::Fork
     if read_io.wait_readable(timeout)
       data = read_io.read
       ::Process.wait(pid)
-      return { timeout: false }.merge(Marshal.load(data)) unless data.empty? # rubocop:disable Security/MarshalLoad
 
-      ::Process.wait(pid) rescue nil # rubocop:disable Style/RescueModifier
-      { timeout: false, passed: false, error: "empty result from child" }
+      if data.empty?
+        { timeout: false, passed: false, error: "empty result from child" }
+      else
+        { timeout: false }.merge(Marshal.load(data)) # rubocop:disable Security/MarshalLoad
+      end
     else
       terminate_child(pid)
       { timeout: true }
@@ -90,7 +93,7 @@ class Evilution::Isolation::Fork
     ::Process.wait(pid) rescue nil # rubocop:disable Style/RescueModifier
   end
 
-  def build_mutation_result(mutation, result, duration)
+  def build_mutation_result(mutation, result, duration, parent_rss_kb)
     status = if result[:timeout]
                :timeout
              elsif result[:error]
@@ -106,7 +109,8 @@ class Evilution::Isolation::Fork
       status: status,
       duration: duration,
       test_command: result[:test_command],
-      child_rss_kb: result[:child_rss_kb]
+      child_rss_kb: result[:child_rss_kb],
+      parent_rss_kb: parent_rss_kb
     )
   end
 end

data/lib/evilution/isolation/in_process.rb

@@ -7,6 +7,13 @@ require_relative "../result/mutation_result"
 require_relative "../isolation"
 
 class Evilution::Isolation::InProcess
+  @null_out = File.open(File::NULL, "w")
+  @null_err = File.open(File::NULL, "w")
+
+  class << self
+    attr_reader :null_out, :null_err
+  end
+
   def call(mutation:, test_command:, timeout:)
     start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
     rss_before = Evilution::Memory.rss_kb
@@ -15,7 +22,7 @@ class Evilution::Isolation::InProcess
     duration = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time
     delta = compute_memory_delta(rss_before, rss_after, result)
 
-    build_mutation_result(mutation, result, duration, rss_after, delta)
+    build_mutation_result(mutation, result, duration, rss_before, rss_after, delta)
   end
 
   private
@@ -34,13 +41,9 @@ class Evilution::Isolation::InProcess
   def suppress_output
     saved_stdout = $stdout
     saved_stderr = $stderr
-    File.open(File::NULL, "w") do |null_out|
-      File.open(File::NULL, "w") do |null_err|
-        $stdout = null_out
-        $stderr = null_err
-        yield
-      end
-    end
+    $stdout = self.class.null_out
+    $stderr = self.class.null_err
+    yield
   ensure
     $stdout = saved_stdout
     $stderr = saved_stderr
@@ -53,7 +56,7 @@ class Evilution::Isolation::InProcess
     rss_after - rss_before
   end
 
-  def build_mutation_result(mutation, result, duration, rss_after, memory_delta_kb)
+  def build_mutation_result(mutation, result, duration, rss_before, rss_after, memory_delta_kb)
     status = if result[:timeout]
                :timeout
              elsif result[:error]
@@ -70,7 +73,8 @@ class Evilution::Isolation::InProcess
       duration: duration,
       test_command: result[:test_command],
       child_rss_kb: rss_after,
-      memory_delta_kb: memory_delta_kb
+      memory_delta_kb: memory_delta_kb,
+      parent_rss_kb: rss_before
     )
   end
 end

data/lib/evilution/mcp/session_diff_tool.rb

@@ -3,6 +3,7 @@
 require "json"
 require "mcp"
 require_relative "../session/store"
+require_relative "../session/diff"
 
 require_relative "../mcp"
 
@@ -33,7 +34,10 @@ class Evilution::MCP::SessionDiffTool < MCP::Tool
       base_data = store.load(base)
       head_data = store.load(head)
 
-      ::MCP::Tool::Response.new([{ type: "text", text: ::JSON.generate(build_diff(base_data, head_data)) }])
+      diff = Evilution::Session::Diff.new
+      result = diff.call(base_data, head_data)
+
+      ::MCP::Tool::Response.new([{ type: "text", text: ::JSON.generate(result.to_h) }])
     rescue Evilution::Error => e
       error_response("not_found", e.message)
     rescue ::JSON::ParserError => e
@@ -45,40 +49,6 @@ class Evilution::MCP::SessionDiffTool < MCP::Tool
 
     private
 
-    def build_diff(base_data, head_data)
-      base_survivors = base_data["survived"] || []
-      head_survivors = head_data["survived"] || []
-
-      base_keys = base_survivors.to_set { |m| mutation_key(m) }
-      head_keys = head_survivors.to_set { |m| mutation_key(m) }
-
-      {
-        "summary" => build_summary_diff(base_data, head_data),
-        "fixed" => base_survivors.reject { |m| head_keys.include?(mutation_key(m)) },
-        "new_survivors" => head_survivors.reject { |m| base_keys.include?(mutation_key(m)) },
-        "persistent" => head_survivors.select { |m| base_keys.include?(mutation_key(m)) }
-      }
-    end
-
-    def build_summary_diff(base_data, head_data)
-      base_summary = base_data["summary"] || {}
-      head_summary = head_data["summary"] || {}
-      base_score = base_summary["score"] || 0.0
-      head_score = head_summary["score"] || 0.0
-
-      {
-        "base_score" => base_score,
-        "head_score" => head_score,
-        "score_delta" => (head_score - base_score).round(4),
-        "base_survived" => base_summary["survived"] || 0,
-        "head_survived" => head_summary["survived"] || 0
-      }
-    end
-
-    def mutation_key(mutation)
-      [mutation["operator"], mutation["file"], mutation["line"], mutation["subject"]]
-    end
-
     def error_response(type, message)
       ::MCP::Tool::Response.new(
         [{ type: "text", text: ::JSON.generate({ error: { type: type, message: message } }) }],

data/lib/evilution/mutator/operator/collection_return.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+class Evilution::Mutator::Operator::CollectionReturn < Evilution::Mutator::Base
+  def visit_def_node(node)
+    body = node.body
+    if body.is_a?(Prism::StatementsNode) && body.body.length > 1
+      return_node = body.body.last
+      replacement = collection_replacement(return_node)
+
+      if replacement
+        add_mutation(
+          offset: body.location.start_offset,
+          length: body.location.length,
+          replacement: replacement,
+          node: node
+        )
+      end
+    end
+
+    super
+  end
+
+  def collection_replacement(node)
+    case node
+    when Prism::ArrayNode
+      "[]" if node.elements.any?
+    when Prism::HashNode
+      "{}" if node.elements.any?
+    end
+  end
+end

data/lib/evilution/mutator/operator/defined_check.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+class Evilution::Mutator::Operator::DefinedCheck < Evilution::Mutator::Base
+  def visit_defined_node(node)
+    add_mutation(
+      offset: node.location.start_offset,
+      length: node.location.length,
+      replacement: "true",
+      node: node
+    )
+
+    super
+  end
+end

data/lib/evilution/mutator/operator/keyword_argument.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+class Evilution::Mutator::Operator::KeywordArgument < Evilution::Mutator::Base
+  def visit_def_node(node)
+    params = node.parameters
+    if params
+      mutate_optional_keyword_defaults(params)
+      mutate_optional_keyword_removal(params)
+      mutate_keyword_rest_removal(params)
+    end
+
+    super
+  end
+
+  private
+
+  def mutate_optional_keyword_defaults(params)
+    params.keywords.each do |kw|
+      next unless kw.is_a?(Prism::OptionalKeywordParameterNode)
+
+      name_loc = kw.name_loc
+      kw_loc = kw.location
+
+      add_mutation(
+        offset: kw_loc.start_offset,
+        length: kw_loc.length,
+        replacement: @file_source[name_loc.start_offset...name_loc.end_offset],
+        node: kw
+      )
+    end
+  end
+
+  def mutate_optional_keyword_removal(params)
+    all_params = collect_all_params(params)
+    return if all_params.length < 2
+
+    params.keywords.each do |kw|
+      next unless kw.is_a?(Prism::OptionalKeywordParameterNode)
+
+      remaining = all_params.reject { |p| p.equal?(kw) }
+      replacement = remaining.map(&:slice).join(", ")
+
+      add_mutation(
+        offset: params.location.start_offset,
+        length: params.location.length,
+        replacement: replacement,
+        node: kw
+      )
+    end
+  end
+
+  def mutate_keyword_rest_removal(params)
+    kr = params.keyword_rest
+    return unless kr.is_a?(Prism::KeywordRestParameterNode)
+
+    all_params = collect_all_params(params)
+
+    if all_params.length < 2
+      add_mutation(
+        offset: kr.location.start_offset,
+        length: kr.location.length,
+        replacement: "",
+        node: kr
+      )
+    else
+      remaining = all_params.reject { |p| p.equal?(kr) }
+      replacement = remaining.map(&:slice).join(", ")
+
+      add_mutation(
+        offset: params.location.start_offset,
+        length: params.location.length,
+        replacement: replacement,
+        node: kr
+      )
+    end
+  end
+
+  def collect_all_params(params)
+    result = []
+    result.concat(params.requireds)
+    result.concat(params.optionals)
+    result << params.rest if params.rest
+    result.concat(params.posts)
+    result.concat(params.keywords)
+    result << params.keyword_rest if params.keyword_rest
+    result << params.block if params.block
+    result
+  end
+end

data/lib/evilution/mutator/operator/multiple_assignment.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+class Evilution::Mutator::Operator::MultipleAssignment < Evilution::Mutator::Base
+  def visit_multi_write_node(node)
+    lefts = node.lefts
+    values = node.value.is_a?(Prism::ArrayNode) ? node.value.elements : nil
+
+    if values && lefts.length == values.length && lefts.length >= 2 && node.rest.nil?
+      mutate_target_removal(node, lefts, values)
+      mutate_swap(node, lefts, values) if lefts.length == 2
+    end
+
+    super
+  end
+
+  private
+
+  def mutate_target_removal(node, lefts, values)
+    lefts.each_index do |i|
+      remaining_lefts = lefts.each_with_index.filter_map { |l, j| l.slice if j != i }
+      remaining_values = values.each_with_index.filter_map { |v, j| v.slice if j != i }
+
+      replacement = "#{remaining_lefts.join(", ")} = #{remaining_values.join(", ")}"
+
+      add_mutation(
+        offset: node.location.start_offset,
+        length: node.location.length,
+        replacement: replacement,
+        node: node
+      )
+    end
+  end
+
+  def mutate_swap(node, lefts, values)
+    swapped_lefts = "#{lefts[1].slice}, #{lefts[0].slice}"
+    replacement = "#{swapped_lefts} = #{values.map(&:slice).join(", ")}"
+
+    add_mutation(
+      offset: node.location.start_offset,
+      length: node.location.length,
+      replacement: replacement,
+      node: node
+    )
+  end
+end

data/lib/evilution/mutator/operator/regex_capture.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+class Evilution::Mutator::Operator::RegexCapture < Evilution::Mutator::Base
+  def visit_numbered_reference_read_node(node)
+    mutate_replace_with_nil(node)
+    mutate_swap_number(node)
+
+    super
+  end
+
+  private
+
+  def mutate_replace_with_nil(node)
+    add_mutation(
+      offset: node.location.start_offset,
+      length: node.location.length,
+      replacement: "nil",
+      node: node
+    )
+  end
+
+  def mutate_swap_number(node)
+    number = node.number
+
+    if number > 1
+      add_mutation(
+        offset: node.location.start_offset,
+        length: node.location.length,
+        replacement: "$#{number - 1}",
+        node: node
+      )
+    end
+
+    add_mutation(
+      offset: node.location.start_offset,
+      length: node.location.length,
+      replacement: "$#{number + 1}",
+      node: node
+    )
+  end
+end

data/lib/evilution/mutator/operator/scalar_return.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+class Evilution::Mutator::Operator::ScalarReturn < Evilution::Mutator::Base
+  def visit_def_node(node)
+    body = node.body
+    if body.is_a?(Prism::StatementsNode) && body.body.length > 1
+      return_node = body.body.last
+      replacement = scalar_replacement(return_node)
+
+      if replacement
+        add_mutation(
+          offset: body.location.start_offset,
+          length: body.location.length,
+          replacement: replacement,
+          node: node
+        )
+      end
+    end
+
+    super
+  end
+
+  private
+
+  def scalar_replacement(node)
+    case node
+    when Prism::StringNode
+      '""' unless node.content.empty?
+    when Prism::IntegerNode
+      "0" unless node.value.zero?
+    when Prism::FloatNode
+      "0.0" unless node.value.zero?
+    end
+  end
+end

data/lib/evilution/mutator/operator/splat_operator.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+class Evilution::Mutator::Operator::SplatOperator < Evilution::Mutator::Base
+  def visit_splat_node(node)
+    mutate_remove_splat(node) if node.expression
+
+    super
+  end
+
+  def visit_hash_node(node)
+    node.elements.each { |el| hash_elements.add(el) }
+    super
+  end
+
+  def visit_assoc_splat_node(node)
+    mutate_remove_double_splat(node) if node.value && !hash_elements.include?(node)
+
+    super
+  end
+
+  private
+
+  def hash_elements
+    @hash_elements ||= Set.new.compare_by_identity
+  end
+
+  def mutate_remove_splat(node)
+    add_mutation(
+      offset: node.location.start_offset,
+      length: node.location.length,
+      replacement: node.expression.slice,
+      node: node
+    )
+  end
+
+  def mutate_remove_double_splat(node)
+    add_mutation(
+      offset: node.location.start_offset,
+      length: node.location.length,
+      replacement: node.value.slice,
+      node: node
+    )
+  end
+end

data/lib/evilution/mutator/operator/yield_statement.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+class Evilution::Mutator::Operator::YieldStatement < Evilution::Mutator::Base
+  def visit_yield_node(node)
+    mutate_remove_yield(node)
+
+    if node.arguments
+      mutate_remove_arguments(node)
+      mutate_replace_value_with_nil(node)
+    end
+
+    super
+  end
+
+  private
+
+  def mutate_remove_yield(node)
+    add_mutation(
+      offset: node.location.start_offset,
+      length: node.location.length,
+      replacement: "nil",
+      node: node
+    )
+  end
+
+  def mutate_remove_arguments(node)
+    add_mutation(
+      offset: node.location.start_offset,
+      length: node.location.length,
+      replacement: "yield",
+      node: node
+    )
+  end
+
+  def mutate_replace_value_with_nil(node)
+    replacement = if node.lparen_loc
+                    "yield(nil)"
+                  else
+                    "yield nil"
+                  end
+
+    add_mutation(
+      offset: node.location.start_offset,
+      length: node.location.length,
+      replacement: replacement,
+      node: node
+    )
+  end
+end

data/lib/evilution/mutator/registry.rb

@@ -57,7 +57,15 @@ class Evilution::Mutator::Registry
       Evilution::Mutator::Operator::IndexAssignmentRemoval,
       Evilution::Mutator::Operator::PatternMatchingGuard,
       Evilution::Mutator::Operator::PatternMatchingAlternative,
-      Evilution::Mutator::Operator::PatternMatchingArray
+      Evilution::Mutator::Operator::PatternMatchingArray,
+      Evilution::Mutator::Operator::CollectionReturn,
+      Evilution::Mutator::Operator::ScalarReturn,
+      Evilution::Mutator::Operator::KeywordArgument,
+      Evilution::Mutator::Operator::MultipleAssignment,
+      Evilution::Mutator::Operator::YieldStatement,
+      Evilution::Mutator::Operator::SplatOperator,
+      Evilution::Mutator::Operator::DefinedCheck,
+      Evilution::Mutator::Operator::RegexCapture
     ].each { |op| registry.register(op) }
     registry
   end