evilution 0.20.0 → 0.22.0

data/lib/evilution/integration/minitest_crash_detector.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require_relative "../integration"
+
+class Evilution::Integration::MinitestCrashDetector
+  def initialize
+    reset
+  end
+
+  def start
+    # Required by Minitest reporter interface
+  end
+
+  def report
+    # Required by Minitest reporter interface
+  end
+
+  def passed?
+    @crashes.empty?
+  end
+
+  def reset
+    @assertion_failures = 0
+    @crashes = []
+  end
+
+  def record(result)
+    result.failures.each do |failure|
+      if failure.is_a?(::Minitest::UnexpectedError)
+        @crashes << failure.error
+      elsif failure.is_a?(::Minitest::Assertion)
+        @assertion_failures += 1
+      end
+    end
+  end
+
+  def has_assertion_failure? # rubocop:disable Naming/PredicatePrefix
+    @assertion_failures.positive?
+  end
+
+  def has_crash? # rubocop:disable Naming/PredicatePrefix
+    @crashes.any?
+  end
+
+  def only_crashes?
+    @crashes.any? && @assertion_failures.zero?
+  end
+
+  def crash_summary
+    return nil if @crashes.empty?
+
+    types = @crashes.map { |e| e.class.name }.uniq
+    "#{types.join(", ")} (#{@crashes.length} crash#{"es" unless @crashes.length == 1})"
+  end
+end

data/lib/evilution/integration/rspec.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
-require "fileutils"
 require "stringio"
-require "tmpdir"
 require_relative "base"
 require_relative "crash_detector"
 require_relative "../spec_resolver"
@@ -11,6 +9,21 @@ require_relative "../related_spec_heuristic"
 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
@@ -21,98 +34,24 @@ class Evilution::Integration::RSpec < Evilution::Integration::Base
     super(hooks: hooks)
   end
 
-  def call(mutation)
-    @original_content = nil
-    @temp_dir = nil
-    @lock_file = 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)
-    subpath = resolve_require_subpath(mutation.file_path)
-
-    if subpath
-      @temp_dir = Dir.mktmpdir("evilution")
-      dest = File.join(@temp_dir, subpath)
-      FileUtils.mkdir_p(File.dirname(dest))
-      File.write(dest, mutation.mutated_source)
-      $LOAD_PATH.unshift(@temp_dir)
-    else
-      # Fallback: direct write when file isn't under any $LOAD_PATH entry.
-      # Acquire an exclusive lock to prevent concurrent workers from corrupting the file.
-      lock_path = File.join(Dir.tmpdir, "evilution-#{File.expand_path(mutation.file_path).hash.abs}.lock")
-      @lock_file = File.open(lock_path, File::CREAT | File::RDWR)
-      @lock_file.flock(File::LOCK_EX)
-      @original_content = File.read(mutation.file_path)
-      File.write(mutation.file_path, mutation.mutated_source)
-    end
-  end
-
-  def restore_original(mutation)
-    if @temp_dir
-      $LOAD_PATH.delete(@temp_dir)
-      $LOADED_FEATURES.reject! { |f| f.start_with?(@temp_dir) }
-      FileUtils.rm_rf(@temp_dir)
-      @temp_dir = nil
-    elsif @original_content
-      File.write(mutation.file_path, @original_content)
-      @lock_file&.flock(File::LOCK_UN)
-      @lock_file&.close
-      @lock_file = nil
-    end
-  end
-
-  def resolve_require_subpath(file_path)
-    absolute = File.expand_path(file_path)
-
-    $LOAD_PATH.each do |entry|
-      dir = File.expand_path(entry)
-      prefix = dir.end_with?("/") ? dir : "#{dir}/"
-      next unless absolute.start_with?(prefix)
-
-      return absolute.delete_prefix(prefix)
-    end
-
-    nil
-  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
@@ -131,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|
@@ -142,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
@@ -158,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
@@ -197,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

@@ -3,6 +3,7 @@
 require "fileutils"
 require "tmpdir"
 require_relative "../memory"
+require_relative "../temp_dir_tracker"
 
 require_relative "../isolation"
 
@@ -44,12 +45,8 @@ class Evilution::Isolation::Fork
 
   private
 
-  def restore_original_source(mutation)
-    return if File.read(mutation.file_path) == mutation.original_source
-
-    File.write(mutation.file_path, mutation.original_source)
-  rescue StandardError => e
-    warn("Warning: failed to restore #{mutation.file_path}: #{e.message}")
+  def restore_original_source(mutation) # rubocop:disable Lint/UnusedMethodArgument
+    Evilution::TempDirTracker.cleanup_all
   end
 
   def suppress_child_output

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

@@ -7,7 +7,7 @@ require_relative "../mutator"
 class Evilution::Mutator::Base < Prism::Visitor
   attr_reader :mutations
 
-  def initialize
+  def initialize(**_options)
     @mutations = []
     @subject = nil
     @file_source = nil
@@ -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

@@ -3,7 +3,7 @@
 require_relative "../operator"
 
 class Evilution::Mutator::Operator::IndexToDig < Evilution::Mutator::Base
-  def initialize
+  def initialize(**options)
     super
     @consumed = Set.new
   end
@@ -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/string_literal.rb

@@ -3,7 +3,25 @@
 require_relative "../operator"
 
 class Evilution::Mutator::Operator::StringLiteral < Evilution::Mutator::Base
+  def initialize(skip_heredoc_literals: false, **rest)
+    super(**rest)
+    @skip_heredoc_literals = skip_heredoc_literals
+  end
+
+  def visit_interpolated_string_node(node)
+    return super unless node.heredoc?
+    return if @skip_heredoc_literals
+
+    node.parts.each do |part|
+      next if part.is_a?(Prism::StringNode)
+
+      visit(part)
+    end
+  end
+
   def visit_string_node(node)
+    return super if node.heredoc?
+
     replacement = node.content.empty? ? '"mutation"' : '""'
 
     add_mutation(