evilution 0.21.0 → 0.22.1

data/lib/evilution/integration/rspec.rb

@@ -1,17 +1,29 @@
 # frozen_string_literal: true
 
-require "fileutils"
 require "stringio"
-require "tmpdir"
 require_relative "base"
 require_relative "crash_detector"
 require_relative "../spec_resolver"
 require_relative "../related_spec_heuristic"
-require_relative "../temp_dir_tracker"
 
 require_relative "../integration"
 
 class Evilution::Integration::RSpec < Evilution::Integration::Base
+  def self.baseline_runner
+    lambda { |spec_file|
+      require "rspec/core"
+      ::RSpec.reset
+      status = ::RSpec::Core::Runner.run(
+        ["--format", "progress", "--no-color", "--order", "defined", spec_file]
+      )
+      status.zero?
+    }
+  end
+
+  def self.baseline_options
+    { runner: baseline_runner }
+  end
+
   def initialize(test_files: nil, hooks: nil)
     @test_files = test_files
     @rspec_loaded = false
@@ -22,105 +34,24 @@ class Evilution::Integration::RSpec < Evilution::Integration::Base
     super(hooks: hooks)
   end
 
-  def call(mutation)
-    @temp_dir = nil
-    ensure_rspec_loaded
-    @hooks.fire(:mutation_insert_pre, mutation: mutation, file_path: mutation.file_path) if @hooks
-    apply_mutation(mutation)
-    @hooks.fire(:mutation_insert_post, mutation: mutation, file_path: mutation.file_path) if @hooks
-    run_rspec(mutation)
-  ensure
-    restore_original(mutation)
-  end
-
   private
 
   attr_reader :test_files
 
-  def ensure_rspec_loaded
+  def ensure_framework_loaded
     return if @rspec_loaded
 
-    @hooks.fire(:setup_integration_pre, integration: :rspec) if @hooks
+    fire_hook(:setup_integration_pre, integration: :rspec)
     require "rspec/core"
     Evilution::Integration::CrashDetector.register_with_rspec
     @rspec_loaded = true
-    @hooks.fire(:setup_integration_post, integration: :rspec) if @hooks
+    fire_hook(:setup_integration_post, integration: :rspec)
   rescue LoadError => e
     raise Evilution::Error, "rspec-core is required but not available: #{e.message}"
   end
 
-  def apply_mutation(mutation)
-    @temp_dir = Dir.mktmpdir("evilution")
-    Evilution::TempDirTracker.register(@temp_dir)
-    @displaced_feature = nil
-    subpath = resolve_require_subpath(mutation.file_path)
-
-    if subpath
-      dest = File.join(@temp_dir, subpath)
-      FileUtils.mkdir_p(File.dirname(dest))
-      File.write(dest, mutation.mutated_source)
-      $LOAD_PATH.unshift(@temp_dir)
-      displace_loaded_feature(mutation.file_path)
-    else
-      absolute = File.expand_path(mutation.file_path)
-      dest = File.join(@temp_dir, absolute)
-      FileUtils.mkdir_p(File.dirname(dest))
-      File.write(dest, mutation.mutated_source)
-      load(dest)
-    end
-  end
-
-  def restore_original(mutation) # rubocop:disable Lint/UnusedMethodArgument
-    return unless @temp_dir
-
-    $LOAD_PATH.delete(@temp_dir)
-    $LOADED_FEATURES.reject! { |f| f.start_with?(@temp_dir) }
-    $LOADED_FEATURES << @displaced_feature if @displaced_feature && !$LOADED_FEATURES.include?(@displaced_feature)
-    @displaced_feature = nil
-    FileUtils.rm_rf(@temp_dir)
-    Evilution::TempDirTracker.unregister(@temp_dir)
-    @temp_dir = nil
-  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
-
-  def displace_loaded_feature(file_path)
-    absolute = File.expand_path(file_path)
-    return unless $LOADED_FEATURES.include?(absolute)
-
-    @displaced_feature = absolute
-    $LOADED_FEATURES.delete(absolute)
-  end
-
-  def run_rspec(mutation)
-    # When used via the Runner with Isolation::Fork, each mutation is executed
-    # in its own forked child process, so RSpec state (loaded example groups,
-    # world, configuration) cannot accumulate across mutation runs — the child
-    # process exits after each run.
-    #
-    # This integration can also be invoked directly (e.g. in specs or alternative
-    # 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
+  def run_tests(mutation)
+    reset_state
 
     out = StringIO.new
     err = StringIO.new
@@ -139,6 +70,19 @@ class Evilution::Integration::RSpec < Evilution::Integration::Base
     release_rspec_state(eg_before)
   end
 
+  def build_args(mutation)
+    files = resolve_test_files(mutation)
+    ["--format", "progress", "--no-color", "--order", "defined", *files]
+  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|
@@ -150,11 +94,6 @@ class Evilution::Integration::RSpec < Evilution::Integration::Base
 
   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
@@ -166,7 +105,6 @@ class Evilution::Integration::RSpec < Evilution::Integration::Base
       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
@@ -205,11 +143,6 @@ class Evilution::Integration::RSpec < Evilution::Integration::Base
     end
   end
 
-  def build_args(mutation)
-    files = resolve_test_files(mutation)
-    ["--format", "progress", "--no-color", "--order", "defined", *files]
-  end
-
   def resolve_test_files(mutation)
     return test_files if test_files
 

data/lib/evilution/isolation/fork.rb

@@ -57,8 +57,13 @@ class Evilution::Isolation::Fork
   def execute_in_child(mutation, test_command)
     result = test_command.call(mutation)
     { child_rss_kb: Evilution::Memory.rss_kb }.merge(result)
-  rescue StandardError => e
-    { passed: false, error: e.message }
+  rescue ScriptError, StandardError => e
+    {
+      passed: false,
+      error: e.message,
+      error_class: e.class.name,
+      error_backtrace: Array(e.backtrace).first(5)
+    }
   end
 
   def wait_for_result(pid, read_io, timeout)
@@ -107,7 +112,10 @@ class Evilution::Isolation::Fork
       duration: duration,
       test_command: result[:test_command],
       child_rss_kb: result[:child_rss_kb],
-      parent_rss_kb: parent_rss_kb
+      parent_rss_kb: parent_rss_kb,
+      error_message: result[:error],
+      error_class: result[:error_class],
+      error_backtrace: result[:error_backtrace]
     )
   end
 end

data/lib/evilution/isolation/in_process.rb

@@ -34,8 +34,14 @@ class Evilution::Isolation::InProcess
     { timeout: false }.merge(result)
   rescue Timeout::Error
     { timeout: true }
-  rescue StandardError => e
-    { timeout: false, passed: false, error: e.message }
+  rescue ScriptError, StandardError => e
+    {
+      timeout: false,
+      passed: false,
+      error: e.message,
+      error_class: e.class.name,
+      error_backtrace: Array(e.backtrace).first(5)
+    }
   end
 
   def suppress_output
@@ -74,7 +80,10 @@ class Evilution::Isolation::InProcess
       test_command: result[:test_command],
       child_rss_kb: rss_after,
       memory_delta_kb: memory_delta_kb,
-      parent_rss_kb: rss_before
+      parent_rss_kb: rss_before,
+      error_message: result[:error],
+      error_class: result[:error_class],
+      error_backtrace: result[:error_backtrace]
     )
   end
 end

data/lib/evilution/mcp/mutate_tool.rb

@@ -12,7 +12,7 @@ require_relative "../mcp"
 class Evilution::MCP::MutateTool < MCP::Tool
   tool_name "evilution-mutate"
   description "Run mutation testing on Ruby source files. " \
-              "Use suggest_tests: true to get concrete RSpec test code for surviving mutants."
+              "Use suggest_tests: true to get concrete test code (RSpec or Minitest) for surviving mutants."
   input_schema(
     properties: {
       files: {
@@ -43,7 +43,7 @@ class Evilution::MCP::MutateTool < MCP::Tool
       },
       suggest_tests: {
         type: "boolean",
-        description: "When true, suggestions for survived mutants include concrete RSpec test code " \
+        description: "When true, suggestions for survived mutants include concrete test code " \
                      "instead of static description text (default: false)"
       },
       verbosity: {
@@ -64,10 +64,10 @@ class Evilution::MCP::MutateTool < MCP::Tool
       config_opts = build_config_opts(parsed_files, line_ranges, target, timeout, jobs, fail_fast, spec,
                                       suggest_tests)
       config = Evilution::Config.new(**config_opts)
-      on_result = build_streaming_callback(server_context, suggest_tests)
+      on_result = build_streaming_callback(server_context, suggest_tests, config.integration)
       runner = Evilution::Runner.new(config: config, on_result: on_result)
       summary = runner.call
-      report = Evilution::Reporter::JSON.new(suggest_tests: suggest_tests == true).call(summary)
+      report = Evilution::Reporter::JSON.new(suggest_tests: suggest_tests == true, integration: config.integration).call(summary)
       compact = trim_report(report, normalize_verbosity(verbosity))
 
       ::MCP::Tool::Response.new([{ type: "text", text: compact }])
@@ -156,10 +156,10 @@ class Evilution::MCP::MutateTool < MCP::Tool
       data[key].each { |entry| entry.delete("diff") }
     end
 
-    def build_streaming_callback(server_context, suggest_tests)
+    def build_streaming_callback(server_context, suggest_tests, integration)
       return nil unless suggest_tests && server_context.respond_to?(:report_progress)
 
-      suggestion = Evilution::Reporter::Suggestion.new(suggest_tests: true)
+      suggestion = Evilution::Reporter::Suggestion.new(suggest_tests: true, integration: integration)
       survivor_index = 0
 
       proc do |result|

data/lib/evilution/mutator/base.rb

@@ -45,6 +45,10 @@ class Evilution::Mutator::Base < Prism::Visitor
     )
   end
 
+  def byteslice_source(offset, length)
+    @file_source.byteslice(offset, length).force_encoding(@file_source.encoding)
+  end
+
   def self.operator_name
     class_name = name || "anonymous"
     class_name.split("::").last

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

@@ -9,7 +9,7 @@ class Evilution::Mutator::Operator::BitwiseComplement < Evilution::Mutator::Base
       receiver_loc = node.receiver.location
 
       # Remove ~: replace entire ~expr with just the receiver expression
-      receiver_source = @file_source[receiver_loc.start_offset, receiver_loc.length]
+      receiver_source = byteslice_source(receiver_loc.start_offset, receiver_loc.length)
       add_mutation(
         offset: node.location.start_offset,
         length: node.location.length,

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+class Evilution::Mutator::Operator::BlockPassRemoval < Evilution::Mutator::Base
+  def visit_call_node(node)
+    if node.block.is_a?(Prism::BlockArgumentNode)
+      block_node = node.block
+      call_start = node.location.start_offset
+      node_end = call_start + node.location.length
+      block_end = block_node.location.start_offset + block_node.location.length
+
+      prefix = @file_source.byteslice(call_start...block_node.location.start_offset).rstrip
+      suffix = @file_source.byteslice(block_end...node_end)
+
+      # Clean up: remove trailing comma from prefix, remove empty parens
+      prefix = prefix.sub(/,\s*\z/, "")
+      replacement = "#{prefix}#{suffix}".sub(/\(\s*\)/, "")
+
+      add_mutation(
+        offset: call_start,
+        length: node.location.length,
+        replacement: replacement,
+        node: node
+      )
+    end
+
+    super
+  end
+end

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

@@ -21,7 +21,7 @@ class Evilution::Mutator::Operator::EnsureRemoval < Evilution::Mutator::Base
 
   def line_start_after_newline(offset)
     pos = offset
-    pos -= 1 while pos.positive? && @file_source[pos - 1] != "\n"
+    pos -= 1 while pos.positive? && @file_source.getbyte(pos - 1) != 0x0A
     pos
   end
 end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+class Evilution::Mutator::Operator::IndexToAt < Evilution::Mutator::Base
+  def visit_call_node(node)
+    if indexable?(node)
+      receiver_source = @file_source.byteslice(node.receiver.location.start_offset, node.receiver.location.length)
+      arg_source = @file_source.byteslice(node.arguments.location.start_offset, node.arguments.location.length)
+
+      add_mutation(
+        offset: node.location.start_offset,
+        length: node.location.length,
+        replacement: "#{receiver_source}.at(#{arg_source})",
+        node: node
+      )
+    end
+
+    super
+  end
+
+  private
+
+  def indexable?(node)
+    node.name == :[] &&
+      node.receiver &&
+      node.arguments &&
+      node.arguments.arguments.length == 1
+  end
+end

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

@@ -11,8 +11,8 @@ class Evilution::Mutator::Operator::IndexToDig < Evilution::Mutator::Base
   def visit_call_node(node)
     if chain_head?(node)
       root, args = collect_chain(node)
-      root_source = @file_source[root.location.start_offset, root.location.length]
-      arg_sources = args.map { |a| @file_source[a.location.start_offset, a.location.length] }
+      root_source = byteslice_source(root.location.start_offset, root.location.length)
+      arg_sources = args.map { |a| byteslice_source(a.location.start_offset, a.location.length) }
 
       add_mutation(
         offset: node.location.start_offset,

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

@@ -5,8 +5,8 @@ require_relative "../operator"
 class Evilution::Mutator::Operator::IndexToFetch < Evilution::Mutator::Base
   def visit_call_node(node)
     if indexable?(node)
-      receiver_source = @file_source[node.receiver.location.start_offset, node.receiver.location.length]
-      arg_source = @file_source[node.arguments.location.start_offset, node.arguments.location.length]
+      receiver_source = byteslice_source(node.receiver.location.start_offset, node.receiver.location.length)
+      arg_source = byteslice_source(node.arguments.location.start_offset, node.arguments.location.length)
 
       add_mutation(
         offset: node.location.start_offset,

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

@@ -26,7 +26,7 @@ class Evilution::Mutator::Operator::KeywordArgument < Evilution::Mutator::Base
       add_mutation(
         offset: kw_loc.start_offset,
         length: kw_loc.length,
-        replacement: @file_source[name_loc.start_offset...name_loc.end_offset],
+        replacement: byteslice_source(name_loc.start_offset, name_loc.end_offset - name_loc.start_offset),
         node: kw
       )
     end

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

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+class Evilution::Mutator::Operator::RegexSimplification < Evilution::Mutator::Base
+  def visit_regular_expression_node(node)
+    content = node.content
+    return super if content.empty?
+
+    content_offset = node.content_loc.start_offset
+
+    remove_quantifiers(node, content, content_offset)
+    remove_anchors(node, content, content_offset)
+    remove_character_class_ranges(node, content, content_offset)
+
+    super
+  end
+
+  private
+
+  def remove_quantifiers(node, content, content_offset)
+    i = 0
+    while i < content.length
+      if content[i] == "\\"
+        i += 2
+        next
+      end
+
+      if content[i] == "["
+        i = skip_character_class(content, i)
+        next
+      end
+
+      match = match_quantifier(content, i)
+      if match
+        add_mutation(
+          offset: content_offset + i,
+          length: match.length,
+          replacement: "",
+          node: node
+        )
+        i += match.length
+      else
+        i += 1
+      end
+    end
+  end
+
+  def match_quantifier(content, pos)
+    case content[pos]
+    when "+", "*", "?"
+      content[pos]
+    when "{"
+      if (m = content[pos..].match(/\A\{\d+(?:,\d*)?\}/))
+        m[0]
+      end
+    end
+  end
+
+  def remove_anchors(node, content, content_offset)
+    i = 0
+    while i < content.length
+      if content[i] == "\\"
+        anchor = match_backslash_anchor(content, i)
+        if anchor
+          add_mutation(
+            offset: content_offset + i,
+            length: anchor.length,
+            replacement: "",
+            node: node
+          )
+          i += anchor.length
+        else
+          i += 2
+        end
+        next
+      end
+
+      if content[i] == "["
+        i = skip_character_class(content, i)
+        next
+      end
+
+      if %w[^ $].include?(content[i])
+        add_mutation(
+          offset: content_offset + i,
+          length: 1,
+          replacement: "",
+          node: node
+        )
+      end
+
+      i += 1
+    end
+  end
+
+  def match_backslash_anchor(content, pos)
+    return nil unless content[pos] == "\\"
+
+    two_char = content[pos, 2]
+    return two_char if %w[\\A \\z \\Z].include?(two_char)
+
+    nil
+  end
+
+  def remove_character_class_ranges(node, content, content_offset)
+    i = 0
+    while i < content.length
+      if content[i] == "\\"
+        i += 2
+        next
+      end
+
+      if content[i] == "["
+        scan_ranges_in_class(node, content, content_offset, i)
+        i = skip_character_class(content, i)
+      else
+        i += 1
+      end
+    end
+  end
+
+  def scan_ranges_in_class(node, content, content_offset, class_start)
+    first_item = skip_class_prefix(content, class_start)
+    i = first_item
+
+    while i < content.length && content[i] != "]"
+      if content[i] == "\\"
+        i += 2
+        next
+      end
+
+      emit_range_removal(node, content, content_offset, first_item, i) if content[i] == "-"
+      i += 1
+    end
+  end
+
+  def skip_class_prefix(content, class_start)
+    i = class_start + 1
+    i += 1 if i < content.length && content[i] == "^"
+    i += 1 if i < content.length && content[i] == "]"
+    i
+  end
+
+  def emit_range_removal(node, content, content_offset, first_item, pos)
+    return unless pos > first_item && pos + 1 < content.length && content[pos + 1] != "]"
+
+    add_mutation(
+      offset: content_offset + pos,
+      length: 1,
+      replacement: "",
+      node: node
+    )
+  end
+
+  def skip_character_class(content, pos)
+    i = pos + 1
+    i += 1 if i < content.length && content[i] == "^"
+    i += 1 if i < content.length && content[i] == "]"
+
+    while i < content.length
+      return i + 1 if content[i] == "]"
+
+      i += content[i] == "\\" ? 2 : 1
+    end
+
+    i
+  end
+end

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

@@ -85,7 +85,7 @@ class Evilution::Mutator::Operator::RescueBodyReplacement < Evilution::Mutator::
   def indentation_of(offset)
     pos = offset - 1
     col = 0
-    while pos >= 0 && @file_source[pos] != "\n"
+    while pos >= 0 && @file_source.getbyte(pos) != 0x0A
       col += 1
       pos -= 1
     end

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

@@ -31,7 +31,7 @@ class Evilution::Mutator::Operator::RescueRemoval < Evilution::Mutator::Base
 
   def line_start_before(offset)
     pos = offset - 1
-    pos -= 1 while pos.positive? && @file_source[pos] != "\n"
+    pos -= 1 while pos.positive? && @file_source.getbyte(pos) != 0x0A
     pos
   end
 end

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

@@ -4,6 +4,8 @@ require_relative "../operator"
 
 class Evilution::Mutator::Operator::SymbolLiteral < Evilution::Mutator::Base
   def visit_symbol_node(node)
+    return super if label_form?(node)
+
     add_mutation(
       offset: node.location.start_offset,
       length: node.location.length,
@@ -20,4 +22,11 @@ class Evilution::Mutator::Operator::SymbolLiteral < Evilution::Mutator::Base
 
     super
   end
+
+  private
+
+  def label_form?(node)
+    closing = node.closing_loc
+    !closing.nil? && closing.slice == ":"
+  end
 end

data/lib/evilution/mutator/registry.rb

@@ -27,9 +27,11 @@ class Evilution::Mutator::Registry
       Evilution::Mutator::Operator::MethodCallRemoval,
       Evilution::Mutator::Operator::ArgumentRemoval,
       Evilution::Mutator::Operator::BlockRemoval,
+      Evilution::Mutator::Operator::BlockPassRemoval,
       Evilution::Mutator::Operator::ConditionalFlip,
       Evilution::Mutator::Operator::RangeReplacement,
       Evilution::Mutator::Operator::RegexpMutation,
+      Evilution::Mutator::Operator::RegexSimplification,
       Evilution::Mutator::Operator::ReceiverReplacement,
       Evilution::Mutator::Operator::SendMutation,
       Evilution::Mutator::Operator::ArgumentNilSubstitution,
@@ -52,6 +54,7 @@ class Evilution::Mutator::Registry
       Evilution::Mutator::Operator::BitwiseComplement,
       Evilution::Mutator::Operator::ZsuperRemoval,
       Evilution::Mutator::Operator::ExplicitSuperMutation,
+      Evilution::Mutator::Operator::IndexToAt,
       Evilution::Mutator::Operator::IndexToFetch,
       Evilution::Mutator::Operator::IndexToDig,
       Evilution::Mutator::Operator::IndexAssignmentRemoval,

data/lib/evilution/reporter/cli.rb

@@ -19,6 +19,7 @@ class Evilution::Reporter::CLI
     append_survived(lines, summary)
     append_neutral(lines, summary)
     append_equivalent(lines, summary)
+    append_errors(lines, summary)
     append_disabled(lines, summary)
     lines << ""
     lines << "[TRUNCATED] Stopped early due to --fail-fast" if summary.truncated?
@@ -54,6 +55,24 @@ class Evilution::Reporter::CLI
     summary.equivalent_results.each { |result| lines << format_neutral(result) }
   end
 
+  def append_errors(lines, summary)
+    errored = summary.results.select(&:error?)
+    return if errored.empty?
+
+    lines << ""
+    lines << "Errored mutations:"
+    errored.each { |result| lines << format_error(result) }
+  end
+
+  def format_error(result)
+    mutation = result.mutation
+    header = "  #{mutation.operator_name}: #{mutation.file_path}:#{mutation.line}"
+    return header unless result.error_message
+
+    indented = result.error_message.lines.map { |line| "    #{line.chomp}" }.join("\n")
+    "#{header}\n#{indented}"
+  end
+
   def append_disabled(lines, summary)
     return unless summary.disabled_mutations.any?