evilution 0.19.0 → 0.21.0

data/lib/evilution/config.rb

@@ -25,14 +25,16 @@ class Evilution::Config
     spec_files: [],
     ignore_patterns: [],
     show_disabled: false,
-    baseline_session: nil
+    baseline_session: nil,
+    skip_heredoc_literals: false
   }.freeze
 
   attr_reader :target_files, :timeout, :format,
               :target, :min_score, :integration, :verbose, :quiet,
               :jobs, :fail_fast, :baseline, :isolation, :incremental, :suggest_tests,
               :progress, :save_session, :line_ranges, :spec_files, :hooks,
-              :ignore_patterns, :show_disabled, :baseline_session
+              :ignore_patterns, :show_disabled, :baseline_session,
+              :skip_heredoc_literals
 
   def initialize(**options)
     file_options = options.delete(:skip_config_file) ? {} : load_config_file
@@ -89,6 +91,10 @@ class Evilution::Config
     show_disabled
   end
 
+  def skip_heredoc_literals?
+    skip_heredoc_literals
+  end
+
   def self.file_options
     CONFIG_FILES.each do |path|
       next unless File.exist?(path)
@@ -131,6 +137,9 @@ class Evilution::Config
       # Generate concrete RSpec test code in suggestions (default: false)
       # suggest_tests: false
 
+      # Skip all string literal mutations inside heredocs (default: false)
+      # skip_heredoc_literals: false
+
       # Hooks: Ruby files returning a Proc, keyed by lifecycle event
       # hooks:
       #   worker_process_start: config/evilution_hooks/worker_start.rb
@@ -179,6 +188,7 @@ class Evilution::Config
     @ignore_patterns = validate_ignore_patterns(merged[:ignore_patterns])
     @show_disabled = merged[:show_disabled]
     @baseline_session = merged[:baseline_session]
+    @skip_heredoc_literals = merged[:skip_heredoc_literals]
     @hooks = validate_hooks(merged[:hooks])
   end
 

data/lib/evilution/equivalent/detector.rb

@@ -6,6 +6,7 @@ require_relative "heuristic/alias_swap"
 require_relative "heuristic/dead_code"
 require_relative "heuristic/arithmetic_identity"
 require_relative "heuristic/comment_marking"
+require_relative "heuristic/void_context"
 
 require_relative "../equivalent"
 
@@ -38,7 +39,8 @@ class Evilution::Equivalent::Detector
       Evilution::Equivalent::Heuristic::AliasSwap.new,
       Evilution::Equivalent::Heuristic::DeadCode.new,
       Evilution::Equivalent::Heuristic::ArithmeticIdentity.new,
-      Evilution::Equivalent::Heuristic::CommentMarking.new
+      Evilution::Equivalent::Heuristic::CommentMarking.new,
+      Evilution::Equivalent::Heuristic::VoidContext.new
     ]
   end
 end

data/lib/evilution/equivalent/heuristic/alias_swap.rb

@@ -7,7 +7,8 @@ class Evilution::Equivalent::Heuristic::AliasSwap
     Set[:detect, :find],
     Set[:length, :size],
     Set[:collect, :map],
-    Set[:count, :length]
+    Set[:count, :length],
+    Set[:count, :size]
   ].freeze
 
   MATCHING_OPERATORS = Set["send_mutation", "collection_replacement"].freeze

data/lib/evilution/equivalent/heuristic/void_context.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require_relative "../heuristic"
+
+class Evilution::Equivalent::Heuristic::VoidContext
+  # Method pairs where the only difference is the return value.
+  # In void context (return value unused), these are equivalent.
+  VOID_EQUIVALENT_PAIRS = Set[
+    Set[:each, :map],
+    Set[:each, :reverse_each]
+  ].freeze
+
+  MATCHING_OPERATORS = Set["send_mutation", "collection_replacement"].freeze
+
+  def match?(mutation)
+    return false unless MATCHING_OPERATORS.include?(mutation.operator_name)
+
+    pair = extract_method_pair(mutation.diff)
+    return false unless pair
+    return false unless VOID_EQUIVALENT_PAIRS.include?(pair)
+
+    void_context?(mutation)
+  end
+
+  private
+
+  def extract_method_pair(diff)
+    removed = extract_method(diff, "- ")
+    added = extract_method(diff, "+ ")
+    return nil unless removed && added
+
+    Set[removed.to_sym, added.to_sym]
+  end
+
+  def extract_method(diff, prefix)
+    line = diff.split("\n").find { |l| l.start_with?(prefix) }
+    return nil unless line
+
+    match = line.match(/\.(\w+)(?:[\s({]|$)/)
+    match && match[1]
+  end
+
+  def void_context?(mutation)
+    node = mutation.subject.node
+    return false unless node
+
+    body = node.body
+    return false unless body.is_a?(Prism::StatementsNode)
+
+    statements = body.body
+    call_node = find_call_at_line(statements, mutation.line)
+    return false unless call_node
+
+    # The call is in void context if:
+    # 1. It's a direct statement (not wrapped in assignment)
+    # 2. It's not the last statement in the method body
+    statement_index = statements.index { |s| contains_line?(s, mutation.line) && direct_call?(s) }
+    return false unless statement_index
+
+    statement_index < statements.length - 1
+  end
+
+  def find_call_at_line(statements, line)
+    statements.each do |stmt|
+      return stmt if stmt.is_a?(Prism::CallNode) && stmt.location.start_line == line
+    end
+    nil
+  end
+
+  def direct_call?(statement)
+    statement.is_a?(Prism::CallNode)
+  end
+
+  def contains_line?(node, line)
+    line.between?(node.location.start_line, node.location.end_line)
+  end
+end

data/lib/evilution/integration/crash_detector.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require_relative "../integration"
+
+class Evilution::Integration::CrashDetector
+  def self.register_with_rspec
+    ::RSpec::Core::Formatters.register self, :example_failed
+  end
+
+  def initialize(_output)
+    reset
+  end
+
+  def reset
+    @assertion_failures = 0
+    @crashes = []
+  end
+
+  def example_failed(notification)
+    exception = notification.example.exception
+
+    if assertion_exception?(exception)
+      @assertion_failures += 1
+    else
+      @crashes << exception
+    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
+
+  private
+
+  def assertion_exception?(exception)
+    exception.is_a?(::RSpec::Expectations::ExpectationNotMetError) ||
+      (defined?(::RSpec::Mocks::MockExpectationError) &&
+        exception.is_a?(::RSpec::Mocks::MockExpectationError))
+  end
+end

data/lib/evilution/integration/rspec.rb

@@ -4,7 +4,10 @@ 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"
 
@@ -13,14 +16,14 @@ class Evilution::Integration::RSpec < Evilution::Integration::Base
     @test_files = test_files
     @rspec_loaded = false
     @spec_resolver = Evilution::SpecResolver.new
+    @related_spec_heuristic = Evilution::RelatedSpecHeuristic.new
+    @crash_detector = nil
     @warned_files = Set.new
     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)
@@ -39,6 +42,7 @@ class Evilution::Integration::RSpec < Evilution::Integration::Base
 
     @hooks.fire(:setup_integration_pre, integration: :rspec) if @hooks
     require "rspec/core"
+    Evilution::Integration::CrashDetector.register_with_rspec
     @rspec_loaded = true
     @hooks.fire(:setup_integration_post, integration: :rspec) if @hooks
   rescue LoadError => e
@@ -46,51 +50,60 @@ class Evilution::Integration::RSpec < Evilution::Integration::Base
   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
-      @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)
+      displace_loaded_feature(mutation.file_path)
     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)
+      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)
-    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
+  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)
 
-      return absolute.delete_prefix(prefix)
+      candidate = absolute.delete_prefix(prefix)
+      best_subpath = candidate if best_subpath.nil? || candidate.length < best_subpath.length
     end
 
-    nil
+    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)
@@ -115,10 +128,11 @@ class Evilution::Integration::RSpec < Evilution::Integration::Base
     args = build_args(mutation)
     command = "rspec #{args.join(" ")}"
 
+    detector = reset_crash_detector
     eg_before = snapshot_example_groups
     status = ::RSpec::Core::Runner.run(args, out, err)
 
-    { passed: status.zero?, test_command: command }
+    build_rspec_result(status, command, detector)
   rescue StandardError => e
     { passed: false, error: e.message, test_command: command }
   ensure
@@ -171,6 +185,26 @@ class Evilution::Integration::RSpec < Evilution::Integration::Base
     world.instance_variable_set(:@sources_by_path, {}) if world.instance_variable_defined?(:@sources_by_path)
   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?
+      { passed: false, error: "test crashes: #{detector.crash_summary}", test_command: command }
+    else
+      { passed: false, test_command: command }
+    end
+  end
+
   def build_args(mutation)
     files = resolve_test_files(mutation)
     ["--format", "progress", "--no-color", "--order", "defined", *files]
@@ -180,12 +214,13 @@ class Evilution::Integration::RSpec < Evilution::Integration::Base
     return test_files if test_files
 
     resolved = @spec_resolver.call(mutation.file_path)
-    if resolved
-      [resolved]
-    else
+    unless resolved
       warn_unresolved_spec(mutation.file_path)
-      ["spec"]
+      return ["spec"]
     end
+
+    related = @related_spec_heuristic.call(mutation)
+    ([resolved] + related).uniq
   end
 
   def warn_unresolved_spec(file_path)

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/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

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+class Evilution::Mutator::Operator::BeginUnwrap < Evilution::Mutator::Base
+  def visit_begin_node(node)
+    return super if node.rescue_clause || node.else_clause || node.ensure_clause
+    return super if node.statements.nil?
+    return super if node.begin_keyword_loc.nil?
+
+    body_text = @file_source.byteslice(node.statements.location.start_offset, node.statements.location.length)
+    add_mutation(
+      offset: node.location.start_offset,
+      length: node.location.length,
+      replacement: body_text,
+      node: node
+    )
+
+    super
+  end
+end

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+class Evilution::Mutator::Operator::BlockParamRemoval < Evilution::Mutator::Base
+  def visit_def_node(node)
+    return super unless node.parameters
+    return super unless node.parameters.block
+
+    if only_block_param?(node.parameters)
+      remove_entire_params(node)
+    else
+      remove_block_param(node)
+    end
+
+    super
+  end
+
+  private
+
+  def only_block_param?(params)
+    params.requireds.empty? &&
+      params.optionals.empty? &&
+      params.keywords.empty? &&
+      params.rest.nil? &&
+      params.keyword_rest.nil?
+  end
+
+  def remove_entire_params(node)
+    start_offset = node.lparen_loc.start_offset
+    end_offset = node.rparen_loc.start_offset + node.rparen_loc.length
+    add_mutation(
+      offset: start_offset,
+      length: end_offset - start_offset,
+      replacement: "",
+      node: node
+    )
+  end
+
+  def remove_block_param(node)
+    block_loc = node.parameters.block.location
+    params_text = @file_source.byteslice(node.parameters.location.start_offset, node.parameters.location.length)
+    block_rel = block_loc.start_offset - node.parameters.location.start_offset
+
+    # Find the comma before the block param and remove ", &block"
+    comma_pos = params_text.rindex(",", block_rel - 1)
+    remove_start = node.parameters.location.start_offset + comma_pos
+    remove_end = block_loc.start_offset + block_loc.length
+
+    add_mutation(
+      offset: remove_start,
+      length: remove_end - remove_start,
+      replacement: "",
+      node: node
+    )
+  end
+end

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+class Evilution::Mutator::Operator::CaseWhen < Evilution::Mutator::Base
+  def visit_case_node(node)
+    remove_when_branches(node)
+    replace_when_bodies(node)
+    remove_else_branch(node)
+
+    super
+  end
+
+  private
+
+  def remove_when_branches(node)
+    return if node.conditions.length < 2
+
+    node.conditions.each do |when_node|
+      add_mutation(
+        offset: when_node.location.start_offset,
+        length: when_node.location.length,
+        replacement: "",
+        node: when_node
+      )
+    end
+  end
+
+  def replace_when_bodies(node)
+    node.conditions.each do |when_node|
+      next if when_node.statements.nil? || when_node.statements.body.empty?
+
+      add_mutation(
+        offset: when_node.statements.location.start_offset,
+        length: when_node.statements.location.length,
+        replacement: "nil",
+        node: when_node
+      )
+    end
+  end
+
+  def remove_else_branch(node)
+    return if node.else_clause.nil?
+    return if node.else_clause.statements.nil?
+
+    start_offset = node.else_clause.else_keyword_loc.start_offset
+    end_offset = node.else_clause.statements.location.start_offset + node.else_clause.statements.location.length
+    add_mutation(
+      offset: start_offset,
+      length: end_offset - start_offset,
+      replacement: "",
+      node: node.else_clause
+    )
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+class Evilution::Mutator::Operator::EqualityToIdentity < Evilution::Mutator::Base
+  def visit_call_node(node)
+    if node.name == :== && node.receiver && node.arguments
+      receiver_text = @file_source.byteslice(node.receiver.location.start_offset, node.receiver.location.length)
+      arg = node.arguments.arguments.first
+      arg_text = @file_source.byteslice(arg.location.start_offset, arg.location.length)
+
+      add_mutation(
+        offset: node.location.start_offset,
+        length: node.location.length,
+        replacement: "#{receiver_text}.equal?(#{arg_text})",
+        node: node
+      )
+    end
+
+    super
+  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

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+class Evilution::Mutator::Operator::LambdaBody < Evilution::Mutator::Base
+  def visit_lambda_node(node)
+    if node.body
+      add_mutation(
+        offset: node.body.location.start_offset,
+        length: node.body.location.length,
+        replacement: "nil",
+        node: node
+      )
+    end
+
+    super
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+class Evilution::Mutator::Operator::LoopFlip < Evilution::Mutator::Base
+  def visit_while_node(node)
+    add_mutation(
+      offset: node.keyword_loc.start_offset,
+      length: node.keyword_loc.length,
+      replacement: "until",
+      node: node
+    )
+
+    super
+  end
+
+  def visit_until_node(node)
+    add_mutation(
+      offset: node.keyword_loc.start_offset,
+      length: node.keyword_loc.length,
+      replacement: "while",
+      node: node
+    )
+
+    super
+  end
+end

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

@@ -3,14 +3,18 @@
 require_relative "../operator"
 
 class Evilution::Mutator::Operator::MethodBodyReplacement < Evilution::Mutator::Base
+  REPLACEMENTS = %w[nil self super].freeze
+
   def visit_def_node(node)
     if node.body
-      add_mutation(
-        offset: node.body.location.start_offset,
-        length: node.body.location.length,
-        replacement: "nil",
-        node: node
-      )
+      REPLACEMENTS.each do |replacement|
+        add_mutation(
+          offset: node.body.location.start_offset,
+          length: node.body.location.length,
+          replacement: replacement,
+          node: node
+        )
+      end
     end
 
     super

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+class Evilution::Mutator::Operator::PredicateReplacement < Evilution::Mutator::Base
+  def visit_call_node(node)
+    if node.name.to_s.end_with?("?")
+      loc = node.location
+
+      add_mutation(
+        offset: loc.start_offset,
+        length: loc.length,
+        replacement: "true",
+        node: node
+      )
+
+      add_mutation(
+        offset: loc.start_offset,
+        length: loc.length,
+        replacement: "false",
+        node: node
+      )
+    end
+
+    super
+  end
+end