evilution 0.19.0 → 0.20.0

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/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/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) },
@@ -81,6 +82,19 @@ class Evilution::Reporter::JSON
     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/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

data/lib/evilution/session/store.rb

@@ -65,6 +65,7 @@ class Evilution::Session::Store
       git: git_context,
       summary: build_summary(summary),
       survived: summary.survived_results.map { |r| build_mutation_detail(r) },
+      coverage_gaps: build_coverage_gaps(summary),
       killed_count: summary.killed,
       timed_out_count: summary.timed_out,
       error_count: summary.errors,
@@ -101,6 +102,18 @@ class Evilution::Session::Store
     }
   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
+      }
+    end
+  end
+
   def git_context
     sha = `git rev-parse HEAD 2>/dev/null`.strip
     branch = `git rev-parse --abbrev-ref HEAD 2>/dev/null`.strip

data/lib/evilution/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Evilution
-  VERSION = "0.19.0"
+  VERSION = "0.20.0"
 end

data/lib/evilution.rb

@@ -81,6 +81,15 @@ require_relative "evilution/mutator/operator/yield_statement"
 require_relative "evilution/mutator/operator/splat_operator"
 require_relative "evilution/mutator/operator/defined_check"
 require_relative "evilution/mutator/operator/regex_capture"
+require_relative "evilution/mutator/operator/loop_flip"
+require_relative "evilution/mutator/operator/string_interpolation"
+require_relative "evilution/mutator/operator/retry_removal"
+require_relative "evilution/mutator/operator/case_when"
+require_relative "evilution/mutator/operator/predicate_replacement"
+require_relative "evilution/mutator/operator/equality_to_identity"
+require_relative "evilution/mutator/operator/lambda_body"
+require_relative "evilution/mutator/operator/begin_unwrap"
+require_relative "evilution/mutator/operator/block_param_removal"
 require_relative "evilution/mutator/registry"
 require_relative "evilution/equivalent"
 require_relative "evilution/equivalent/heuristic"