evilution 0.18.0 → 0.20.0

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

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

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

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

@@ -29,7 +29,14 @@ class Evilution::Mutator::Operator::SendMutation < Evilution::Mutator::Base
     to_i: [:to_s],
     to_f: [:to_i],
     to_a: [:to_h],
-    to_h: [:to_a]
+    to_h: [:to_a],
+    downcase: [:upcase],
+    upcase: [:downcase],
+    strip: %i[lstrip rstrip],
+    lstrip: [:strip],
+    rstrip: [:strip],
+    chomp: [:chop],
+    chop: [:chomp]
   }.freeze
 
   def visit_call_node(node)

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+class Evilution::Mutator::Operator::StringInterpolation < Evilution::Mutator::Base
+  def visit_interpolated_string_node(node)
+    mutate_embedded_statements(node)
+    super
+  end
+
+  def visit_interpolated_symbol_node(node)
+    mutate_embedded_statements(node)
+    super
+  end
+
+  private
+
+  def mutate_embedded_statements(node)
+    node.parts.each do |part|
+      next unless part.is_a?(Prism::EmbeddedStatementsNode)
+      next if part.statements.nil? || part.statements.body.empty?
+
+      stmt = part.statements
+      add_mutation(
+        offset: stmt.location.start_offset,
+        length: stmt.location.length,
+        replacement: "nil",
+        node: part
+      )
+    end
+  end
+end

data/lib/evilution/mutator/registry.rb

@@ -65,7 +65,16 @@ class Evilution::Mutator::Registry
       Evilution::Mutator::Operator::YieldStatement,
       Evilution::Mutator::Operator::SplatOperator,
       Evilution::Mutator::Operator::DefinedCheck,
-      Evilution::Mutator::Operator::RegexCapture
+      Evilution::Mutator::Operator::RegexCapture,
+      Evilution::Mutator::Operator::LoopFlip,
+      Evilution::Mutator::Operator::StringInterpolation,
+      Evilution::Mutator::Operator::RetryRemoval,
+      Evilution::Mutator::Operator::CaseWhen,
+      Evilution::Mutator::Operator::PredicateReplacement,
+      Evilution::Mutator::Operator::EqualityToIdentity,
+      Evilution::Mutator::Operator::LambdaBody,
+      Evilution::Mutator::Operator::BeginUnwrap,
+      Evilution::Mutator::Operator::BlockParamRemoval
     ].each { |op| registry.register(op) }
     registry
   end

data/lib/evilution/parallel/pool.rb

@@ -3,8 +3,8 @@
 require_relative "work_queue"
 
 class Evilution::Parallel::Pool
-  def initialize(size:, hooks: nil)
-    @queue = Evilution::Parallel::WorkQueue.new(size: size, hooks: hooks)
+  def initialize(size:, hooks: nil, item_timeout: nil)
+    @queue = Evilution::Parallel::WorkQueue.new(size: size, hooks: hooks, item_timeout: item_timeout)
   end
 
   def map(items, &)

data/lib/evilution/parallel/work_queue.rb

@@ -7,6 +7,8 @@ class Evilution::Parallel::WorkQueue
 
   STATS = :__stats__
 
+  TIMING_GRACE_PERIOD = 5
+
   WorkerStat = Struct.new(:pid, :items_completed, :busy_time, :wall_time) do
     def idle_time
       wall_time - busy_time
@@ -19,13 +21,17 @@ class Evilution::Parallel::WorkQueue
     end
   end
 
-  def initialize(size:, hooks: nil, prefetch: 1)
+  def initialize(size:, hooks: nil, prefetch: 1, item_timeout: nil)
     raise ArgumentError, "pool size must be a positive integer, got #{size.inspect}" unless size.is_a?(Integer) && size >= 1
     raise ArgumentError, "prefetch must be a positive integer, got #{prefetch.inspect}" unless prefetch.is_a?(Integer) && prefetch >= 1
+    unless item_timeout.nil? || (item_timeout.is_a?(Numeric) && item_timeout.positive?)
+      raise ArgumentError, "item_timeout must be nil or a positive number, got #{item_timeout.inspect}"
+    end
 
     @size = size
     @hooks = hooks
     @prefetch = prefetch
+    @item_timeout = item_timeout
     @worker_stats = []
   end
 
@@ -63,7 +69,7 @@ class Evilution::Parallel::WorkQueue
       cmd_read.close
       res_write.close
 
-      { pid: pid, cmd_write: cmd_write, res_read: res_read, items_completed: 0 }
+      { pid: pid, cmd_write: cmd_write, res_read: res_read, items_completed: 0, pending: 0 }
     end
   end
 
@@ -120,8 +126,18 @@ class Evilution::Parallel::WorkQueue
     result_ios = io_to_worker.keys
 
     while state.in_flight.positive?
-      readable, = IO.select(result_ios)
-      readable.each { |io| handle_result(io, io_to_worker[io], items, state) }
+      readable, = IO.select(result_ios, nil, nil, @item_timeout)
+
+      if readable.nil?
+        terminate_stuck_workers(workers)
+        state.first_error = Evilution::Error.new("worker timed out after #{@item_timeout}s") if state.first_error.nil?
+        break
+      end
+
+      readable.each do |io|
+        alive = handle_result(io, io_to_worker[io], items, state)
+        result_ios.delete(io) unless alive
+      end
     end
   end
 
@@ -130,23 +146,27 @@ class Evilution::Parallel::WorkQueue
 
     if message.nil?
       state.first_error = Evilution::Error.new("worker process exited unexpectedly") if state.first_error.nil?
-      state.in_flight -= 1
-      return
+      state.in_flight -= worker[:pending]
+      worker[:pending] = 0
+      return false
     end
 
     index, status, value = message
     state.first_error = value if status == :error && state.first_error.nil?
     state.results[index] = value if status == :ok
     state.in_flight -= 1
+    worker[:pending] -= 1
     worker[:items_completed] += 1
 
     send_item(worker, items, state) if state.next_index < items.length && state.first_error.nil?
+    true
   end
 
   def send_item(worker, items, state)
     write_message(worker[:cmd_write], [state.next_index, items[state.next_index]])
     state.next_index += 1
     state.in_flight += 1
+    worker[:pending] += 1
   end
 
   def build_worker_stats(workers)
@@ -155,6 +175,14 @@ class Evilution::Parallel::WorkQueue
     end
   end
 
+  def terminate_stuck_workers(workers)
+    workers.each do |worker|
+      Process.kill("KILL", worker[:pid])
+    rescue Errno::ESRCH
+      nil # Already exited
+    end
+  end
+
   def shutdown_workers(workers)
     workers.each do |worker|
       write_message(worker[:cmd_write], SHUTDOWN)
@@ -174,18 +202,31 @@ class Evilution::Parallel::WorkQueue
   end
 
   def collect_worker_timing(workers)
-    workers.each do |worker|
-      message = read_result(worker[:res_read])
-      next if message.nil?
+    io_to_worker = workers.reject { |w| w[:res_read].closed? }.to_h { |w| [w[:res_read], w] }
+    deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + TIMING_GRACE_PERIOD
 
-      tag, busy_time, wall_time = message
-      next unless tag == STATS
+    until io_to_worker.empty?
+      remaining = deadline - Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      break if remaining <= 0
 
-      worker[:busy_time] = busy_time
-      worker[:wall_time] = wall_time
+      readable, = IO.select(io_to_worker.keys, nil, nil, remaining)
+      break unless readable
+
+      readable.each { |io| apply_worker_timing(io_to_worker.delete(io), io) }
     end
   end
 
+  def apply_worker_timing(worker, io)
+    message = read_result(io)
+    return if message.nil?
+
+    tag, busy_time, wall_time = message
+    return unless tag == STATS
+
+    worker[:busy_time] = busy_time
+    worker[:wall_time] = wall_time
+  end
+
   def write_message(io, data)
     payload = Marshal.dump(data)
     io.write([payload.bytesize].pack("N"))

data/lib/evilution/related_spec_heuristic.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+class Evilution::RelatedSpecHeuristic
+  RELATED_SPEC_DIRS = %w[
+    spec/requests
+    spec/integration
+    spec/features
+    spec/system
+  ].freeze
+
+  INCLUDES_PATTERN = /\bincludes\(/
+
+  def call(mutation)
+    return [] unless includes_mutation?(mutation)
+
+    domain = extract_domain(mutation.file_path)
+    return [] unless domain
+
+    find_related_specs(domain)
+  end
+
+  private
+
+  def includes_mutation?(mutation)
+    diff = mutation.diff
+    return false unless diff
+
+    diff.split("\n").any? { |line| line.start_with?("- ") && line.match?(INCLUDES_PATTERN) }
+  end
+
+  def extract_domain(file_path)
+    normalized = normalize_path(file_path)
+
+    # Strip common prefixes and get the relative path under app/ or lib/
+    relative = normalized
+               .delete_prefix("app/controllers/")
+               .delete_prefix("app/models/")
+               .delete_prefix("app/")
+               .delete_prefix("lib/")
+
+    # Remove .rb extension and _controller suffix
+    basename = relative.sub(/\.rb\z/, "")
+    basename = basename.sub(/_controller\z/, "")
+
+    basename.empty? ? nil : basename
+  end
+
+  def normalize_path(path)
+    path = path.delete_prefix("./")
+    path = path.delete_prefix("#{Dir.pwd}/") if path.start_with?("/")
+    path
+  end
+
+  def find_related_specs(domain)
+    RELATED_SPEC_DIRS.flat_map { |dir| find_specs_in_dir(dir, domain) }.sort
+  end
+
+  def find_specs_in_dir(dir, domain)
+    return [] unless Dir.exist?(dir)
+
+    Dir.glob(File.join(dir, "**", "#{domain}_spec.rb"))
+  end
+end

data/lib/evilution/reporter/cli.rb

@@ -30,11 +30,12 @@ class Evilution::Reporter::CLI
   private
 
   def append_survived(lines, summary)
-    return unless summary.survived_results.any?
+    gaps = summary.coverage_gaps
+    return unless gaps.any?
 
     lines << ""
-    lines << "Survived mutations:"
-    summary.survived_results.each { |result| lines << format_survived(result) }
+    lines << "Survived mutations (#{gaps.length} coverage gap#{"s" unless gaps.length == 1}):"
+    gaps.each { |gap| lines << format_coverage_gap(gap) }
   end
 
   def append_neutral(lines, summary)
@@ -90,11 +91,16 @@ class Evilution::Reporter::CLI
     "Efficiency: #{pct} killtime, #{rate} mutations/s"
   end
 
-  def format_survived(result)
-    mutation = result.mutation
-    location = "#{mutation.file_path}:#{mutation.line}"
-    diff_lines = mutation.diff.split("\n").map { |l| "    #{l}" }.join("\n")
-    "  #{mutation.operator_name}: #{location} (#{mutation.subject.name})\n#{diff_lines}"
+  def format_coverage_gap(gap)
+    location = "#{gap.file_path}:#{gap.line}"
+    header = if gap.single?
+               "  #{gap.primary_operator}: #{location} (#{gap.subject_name})"
+             else
+               operators = gap.operator_names.join(", ")
+               "  #{location} (#{gap.subject_name}) [#{gap.count} mutations: #{operators}]"
+             end
+    diff_lines = gap.primary_diff.split("\n").map { |l| "    #{l}" }.join("\n")
+    "#{header}\n#{diff_lines}"
   end
 
   def format_neutral(result)

data/lib/evilution/reporter/html.rb

@@ -4,6 +4,7 @@ require "cgi"
 require_relative "suggestion"
 
 require_relative "../reporter"
+require_relative "../result/coverage_gap_grouper"
 
 class Evilution::Reporter::HTML
   def initialize(baseline: nil)
@@ -156,15 +157,39 @@ class Evilution::Reporter::HTML
   def build_survived_details(survived)
     return "" if survived.empty?
 
-    entries = survived.map { |r| build_survived_entry(r) }.join("\n")
+    gaps = Evilution::Result::CoverageGapGrouper.new.call(survived)
+    entries = gaps.map { |gap| build_gap_entry(gap) }.join("\n")
     <<~HTML
       <div class="survived-details">
-        <h3>Survived Mutations</h3>
+        <h3>Coverage Gaps (#{gaps.length})</h3>
         #{entries}
       </div>
     HTML
   end
 
+  def build_gap_entry(gap)
+    if gap.single?
+      build_survived_entry(gap.mutation_results.first)
+    else
+      build_grouped_gap_entry(gap)
+    end
+  end
+
+  def build_grouped_gap_entry(gap)
+    operator_tags = gap.operator_names.map { |op| %(<span class="operator-tag">#{h(op)}</span>) }.join(" ")
+    entries_html = gap.mutation_results.map { |r| build_survived_entry(r) }.join("\n")
+    <<~HTML
+      <div class="coverage-gap">
+        <div class="gap-header">
+          <span class="location">#{h(gap.file_path)}:#{gap.line} (#{h(gap.subject_name)})</span>
+          <span class="gap-count">#{gap.count} mutations</span>
+          #{operator_tags}
+        </div>
+        #{entries_html}
+      </div>
+    HTML
+  end
+
   def build_survived_entry(result)
     mutation = result.mutation
     suggestion_text = @suggestion.suggestion_for(mutation)
@@ -307,6 +332,11 @@ class Evilution::Reporter::HTML
         .diff-removed { color: #f85149; display: block; }
         .diff-added { color: #3fb950; display: block; }
         .suggestion { color: #d29922; font-size: 0.8rem; margin-top: 0.5rem; font-style: italic; }
+        .coverage-gap { border: 1px solid #30363d; border-radius: 6px; padding: 0.75rem; margin-bottom: 0.75rem; background: #161b22; }
+        .gap-header { display: flex; align-items: center; gap: 0.75rem; margin-bottom: 0.5rem; font-size: 0.85rem; padding-bottom: 0.5rem; border-bottom: 1px solid #21262d; }
+        .gap-header .location { color: #58a6ff; font-family: monospace; }
+        .gap-count { background: #4a1a1a; color: #f85149; font-size: 0.7rem; padding: 0.1rem 0.5rem; border-radius: 10px; font-weight: bold; }
+        .operator-tag { background: #21262d; color: #8b949e; font-size: 0.7rem; padding: 0.1rem 0.4rem; border-radius: 4px; font-family: monospace; }
         .empty { color: #8b949e; text-align: center; padding: 2rem; }
         .baseline-comparison { background: #161b22; border: 1px solid #30363d; border-radius: 8px; padding: 1rem; margin-bottom: 2rem; }
         .baseline-comparison h2 { font-size: 1rem; color: #f0f6fc; margin-bottom: 0.75rem; }

data/lib/evilution/reporter/json.rb

@@ -24,6 +24,7 @@ class Evilution::Reporter::JSON
       timestamp: Time.now.iso8601,
       summary: build_summary(summary),
       survived: summary.survived_results.map { |r| build_mutation_detail(r) },
+      coverage_gaps: build_coverage_gaps(summary),
       killed: summary.killed_results.map { |r| build_mutation_detail(r) },
       neutral: summary.neutral_results.map { |r| build_mutation_detail(r) },
       timed_out: summary.results.select(&:timeout?).map { |r| build_mutation_detail(r) },
@@ -75,11 +76,25 @@ class Evilution::Reporter::JSON
     }
     detail[:suggestion] = @suggestion.suggestion_for(mutation) if result.status == :survived
     detail[:test_command] = result.test_command if result.test_command
+    detail[:parent_rss_kb] = result.parent_rss_kb if result.parent_rss_kb
     detail[:child_rss_kb] = result.child_rss_kb if result.child_rss_kb
     detail[:memory_delta_kb] = result.memory_delta_kb if result.memory_delta_kb
     detail
   end
 
+  def build_coverage_gaps(summary)
+    summary.coverage_gaps.map do |gap|
+      {
+        file: gap.file_path,
+        subject: gap.subject_name,
+        line: gap.line,
+        operators: gap.operator_names,
+        count: gap.count,
+        mutations: gap.mutation_results.map { |r| build_mutation_detail(r) }
+      }
+    end
+  end
+
   def build_disabled_detail(mutation)
     {
       operator: mutation.operator_name,

data/lib/evilution/result/coverage_gap.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative "../result"
+
+class Evilution::Result::CoverageGap
+  attr_reader :file_path, :subject_name, :line, :mutation_results
+
+  def initialize(file_path:, subject_name:, line:, mutation_results:)
+    @file_path = file_path
+    @subject_name = subject_name
+    @line = line
+    @mutation_results = mutation_results.dup.freeze
+    freeze
+  end
+
+  def operator_names
+    mutation_results.map { |r| r.mutation.operator_name }.uniq
+  end
+
+  def primary_operator
+    mutation_results.first.mutation.operator_name
+  end
+
+  def primary_diff
+    mutation_results.first.mutation.diff
+  end
+
+  def count
+    mutation_results.length
+  end
+
+  def single?
+    count == 1
+  end
+end

data/lib/evilution/result/coverage_gap_grouper.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative "coverage_gap"
+
+class Evilution::Result::CoverageGapGrouper
+  def call(survived_results)
+    grouped = survived_results.group_by do |r|
+      [r.mutation.file_path, r.mutation.subject.name, r.mutation.line]
+    end
+
+    gaps = grouped.map do |(file_path, subject_name, line), results|
+      Evilution::Result::CoverageGap.new(
+        file_path: file_path,
+        subject_name: subject_name,
+        line: line,
+        mutation_results: results
+      )
+    end
+
+    gaps.sort_by { |gap| [gap.file_path, gap.line, gap.subject_name] }
+  end
+end

data/lib/evilution/result/mutation_result.rb

@@ -6,9 +6,11 @@ class Evilution::Result::MutationResult
   STATUSES = %i[killed survived timeout error neutral equivalent].freeze
 
   attr_reader :mutation, :status, :duration, :killing_test, :test_command,
-              :child_rss_kb, :memory_delta_kb
+              :child_rss_kb, :memory_delta_kb, :parent_rss_kb
 
-  def initialize(mutation:, status:, duration: 0.0, killing_test: nil, test_command: nil, child_rss_kb: nil, memory_delta_kb: nil)
+  def initialize(mutation:, status:, duration: 0.0, killing_test: nil,
+                 test_command: nil, child_rss_kb: nil, memory_delta_kb: nil,
+                 parent_rss_kb: nil)
     raise ArgumentError, "invalid status: #{status}" unless STATUSES.include?(status)
 
     @mutation = mutation
@@ -18,6 +20,7 @@ class Evilution::Result::MutationResult
     @test_command = test_command
     @child_rss_kb = child_rss_kb
     @memory_delta_kb = memory_delta_kb
+    @parent_rss_kb = parent_rss_kb
     freeze
   end
 

data/lib/evilution/result/summary.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "../result"
+require_relative "coverage_gap_grouper"
 
 class Evilution::Result::Summary
   attr_reader :results, :duration, :skipped, :disabled_mutations
@@ -73,6 +74,10 @@ class Evilution::Result::Summary
     results.select(&:equivalent?)
   end
 
+  def coverage_gaps
+    Evilution::Result::CoverageGapGrouper.new.call(survived_results)
+  end
+
   def killtime
     results.sum(0.0, &:duration)
   end