evilution 0.18.0 → 0.20.0

data/README.md

@@ -51,7 +51,8 @@ evilution [command] [options] [files...]
 | `-f`, `--format FORMAT`      | String  | `text`       | Output format: `text`, `json`, or `html`.         |
 | `--target EXPR`              | String  | _(none)_     | Only mutate matching methods. Supports method name (`Foo::Bar#calculate`), class (`Foo`), namespace wildcards (`Foo::Bar*`), method-type selectors (`Foo#`, `Foo.`), descendants (`descendants:Foo`), and source globs (`source:lib/**/*.rb`). |
 | `--min-score FLOAT`          | Float   | 0.0          | Minimum mutation score (0.0–1.0) to pass.         |
-| `--spec FILES`               | Array   | _(none)_     | Spec files to run (comma-separated). Defaults to `spec/`. |
+| `--spec FILES`               | Array   | _(none)_     | Spec files to run (comma-separated). Defaults to auto-detection via `SpecResolver`. |
+| `--spec-dir DIR`             | String  | _(none)_     | Include all `*_spec.rb` files in DIR recursively. Composable with `--spec`. |
 | `-j`, `--jobs N`             | Integer | 1            | Number of parallel workers. Uses demand-driven work distribution with pipe-based IPC. |
 | `--no-baseline`              | Boolean | _(enabled)_  | Skip baseline test suite check. By default, a baseline run detects pre-existing failures and marks those mutations as `neutral`. |
 | `--fail-fast [N]`            | Integer | _(none)_     | Stop after N surviving mutants (default 1 if no value given). |
@@ -147,6 +148,16 @@ Use `--format json` for machine-readable output. Schema:
       "suggestion": "string — actionable hint for surviving mutants (survived only)"
     }
   ],
+  "coverage_gaps": [
+    {
+      "file": "string       — relative path to source file",
+      "subject": "string    — method name (e.g. 'Foo#bar')",
+      "line": "integer      — line number",
+      "operators": ["string — operator names involved"],
+      "count": "integer     — number of survived mutations in this gap",
+      "mutations": ["... same shape as survived entries ..."]
+    }
+  ],
   "killed": ["... same shape as survived entries ..."],
   "timed_out": ["... same shape as survived entries ..."],
   "errors": ["... same shape as survived entries ..."]
@@ -155,7 +166,7 @@ Use `--format json` for machine-readable output. Schema:
 
 **Key metric**: `summary.score` — the mutation score. Higher is better. 1.0 means all mutations were caught.
 
-## Mutation Operators (60 total)
+## Mutation Operators (69 total)
 
 Each operator name is stable and appears in JSON output under `survived[].operator`.
 
@@ -176,7 +187,7 @@ Each operator name is stable and appears in JSON output under `survived[].operat
 | `conditional_branch` | Remove if/else branch | Deletes branch body |
 | `conditional_flip` | Flip `if` to `unless` and vice versa | `if cond` -> `unless cond` |
 | `statement_deletion` | Remove statements from method bodies | Deletes a statement |
-| `method_body_replacement` | Replace entire method body with `nil` | Method body -> `nil` |
+| `method_body_replacement` | Replace entire method body | Method body -> `nil`, `self`, `super` |
 | `negation_insertion` | Negate predicate methods | `x.empty?` -> `!x.empty?` |
 | `return_value_removal` | Strip return values | `return x` -> `return` |
 | `collection_replacement` | Swap collection methods | `map` -> `each`, `select` <-> `reject` |
@@ -221,6 +232,15 @@ Each operator name is stable and appears in JSON output under `survived[].operat
 | `splat_operator` | Remove splat/double-splat | `foo(*args)` -> `foo(args)` |
 | `defined_check` | Replace `defined?` with `true` | `defined?(x)` -> `true` |
 | `regex_capture` | Swap or nil-ify capture refs | `$1` -> `$2`, `$1` -> `nil` |
+| `loop_flip` | Swap while/until loops | `while cond` -> `until cond` |
+| `string_interpolation` | Replace interpolation content with nil | `"hello #{name}"` -> `"hello #{nil}"` |
+| `retry_removal` | Remove retry statements | `retry` -> `nil` |
+| `case_when` | Remove/replace case/when branches | Remove `when` branch, body -> `nil`, remove `else` |
+| `predicate_replacement` | Replace predicate calls with booleans | `x.empty?` -> `true`, `x.empty?` -> `false` |
+| `equality_to_identity` | Replace equality with identity check | `a == b` -> `a.equal?(b)` |
+| `lambda_body` | Replace lambda body with nil | `-> { expr }` -> `-> { nil }` |
+| `begin_unwrap` | Remove begin/end wrapper | `begin; expr; end` -> `expr` |
+| `block_param_removal` | Remove explicit block parameter | `def foo(&block)` -> `def foo` |
 
 ## MCP Server (AI Agent Integration)
 
@@ -367,7 +387,7 @@ Tests 4 paths (InProcess isolation, Fork isolation, mutation generation + stripp
 1. **Parse** — Prism parses Ruby files into ASTs with exact byte offsets
 2. **Extract** — Methods are identified as mutation subjects
 3. **Filter** — Disable comments, Sorbet `sig` blocks, and AST ignore patterns exclude mutations before execution
-4. **Mutate** — 60 operators produce text replacements at precise byte offsets (source-level surgery, no AST unparsing)
+4. **Mutate** — 69 operators produce text replacements at precise byte offsets (source-level surgery, no AST unparsing)
 5. **Isolate** — Default isolation is in-process; `--isolation fork` uses forked child processes. Parallel mode (`--jobs N`) always uses in-process isolation inside pool workers to avoid double forking
 6. **Test** — RSpec executes against the mutated source
 7. **Collect** — Source strings and AST nodes are released after use to minimize memory retention

data/lib/evilution/baseline.rb

@@ -93,6 +93,14 @@ class Evilution::Baseline
   private
 
   def resolve_unique_spec_files(subjects)
-    subjects.map { |s| @spec_resolver.call(s.file_path) || "spec" }.uniq
+    warned = Set.new
+    subjects.map do |s|
+      resolved = @spec_resolver.call(s.file_path)
+      if resolved.nil? && warned.add?(s.file_path)
+        warn "[evilution] No matching spec found for #{s.file_path}, running full suite. " \
+             "Use --spec to specify the spec file."
+      end
+      resolved || "spec"
+    end.uniq
   end
 end

data/lib/evilution/cli.rb

@@ -53,6 +53,16 @@ class Evilution::CLI
     0
   end
 
+  def expand_spec_dir(dir)
+    unless File.directory?(dir)
+      warn("Error: #{dir} is not a directory")
+      return
+    end
+
+    specs = Dir.glob(File.join(dir, "**/*_spec.rb"))
+    @options[:spec_files] = Array(@options[:spec_files]) + specs
+  end
+
   def run_subcommand_error(message)
     warn("Error: #{message}")
     2
@@ -224,6 +234,7 @@ class Evilution::CLI
   def add_filter_options(opts)
     opts.on("--min-score FLOAT", Float, "Minimum mutation score to pass") { |s| @options[:min_score] = s }
     opts.on("--spec FILES", Array, "Spec files to run (comma-separated)") { |f| @options[:spec_files] = f }
+    opts.on("--spec-dir DIR", "Include all specs in DIR") { |d| expand_spec_dir(d) }
     opts.on("--target EXPR",
             "Filter: method (Foo#bar), type (Foo#/Foo.), namespace (Foo*),",
             "class (Foo), glob (source:**/*.rb), hierarchy (descendants:Foo)") do |m|

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,9 @@ require "fileutils"
 require "stringio"
 require "tmpdir"
 require_relative "base"
+require_relative "crash_detector"
 require_relative "../spec_resolver"
+require_relative "../related_spec_heuristic"
 
 require_relative "../integration"
 
@@ -12,6 +14,10 @@ class Evilution::Integration::RSpec < Evilution::Integration::Base
   def initialize(test_files: nil, hooks: nil)
     @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
 
@@ -37,6 +43,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
@@ -98,9 +105,14 @@ class Evilution::Integration::RSpec < Evilution::Integration::Base
     # process exits after each run.
     #
     # This integration can also be invoked directly (e.g. in specs or alternative
-    # runners) without fork isolation. RSpec.reset is called here as
-    # defense-in-depth to clear RSpec state between mutation runs in those cases.
-    ::RSpec.reset
+    # 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
 
     out = StringIO.new
     err = StringIO.new
@@ -108,11 +120,81 @@ 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
+    release_rspec_state(eg_before)
+  end
+
+  def snapshot_example_groups
+    groups = Set.new
+    ObjectSpace.each_object(Class) do |klass|
+      groups << klass.object_id if klass < ::RSpec::Core::ExampleGroup
+    rescue TypeError # rubocop:disable Lint/SuppressedException
+    end
+    groups
+  end
+
+  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
+
+  def release_example_groups(eg_before)
+    return unless eg_before
+
+    ObjectSpace.each_object(Class) do |klass|
+      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
+      end
+
+      klass.instance_variables.each do |ivar|
+        klass.remove_instance_variable(ivar)
+      end
+    rescue TypeError # rubocop:disable Lint/SuppressedException
+    end
+  end
+
+  def release_world_example_groups
+    world = ::RSpec.world
+    world.instance_variable_get(:@example_groups).clear if world.instance_variable_defined?(:@example_groups)
+    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)
@@ -123,7 +205,21 @@ class Evilution::Integration::RSpec < Evilution::Integration::Base
   def resolve_test_files(mutation)
     return test_files if test_files
 
-    resolved = Evilution::SpecResolver.new.call(mutation.file_path)
-    resolved ? [resolved] : ["spec"]
+    resolved = @spec_resolver.call(mutation.file_path)
+    unless resolved
+      warn_unresolved_spec(mutation.file_path)
+      return ["spec"]
+    end
+
+    related = @related_spec_heuristic.call(mutation)
+    ([resolved] + related).uniq
+  end
+
+  def warn_unresolved_spec(file_path)
+    return if @warned_files.include?(file_path)
+
+    @warned_files << file_path
+    warn "[evilution] No matching spec found for #{file_path}, running full suite. " \
+         "Use --spec to specify the spec file."
   end
 end

data/lib/evilution/isolation/fork.rb

@@ -16,6 +16,7 @@ class Evilution::Isolation::Fork
   def call(mutation:, test_command:, timeout:)
     sandbox_dir = Dir.mktmpdir("evilution-run")
     start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    parent_rss = Evilution::Memory.rss_kb
     read_io, write_io = IO.pipe
 
     pid = ::Process.fork do
@@ -33,7 +34,7 @@ class Evilution::Isolation::Fork
     result = wait_for_result(pid, read_io, timeout)
     duration = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time
 
-    build_mutation_result(mutation, result, duration)
+    build_mutation_result(mutation, result, duration, parent_rss)
   ensure
     read_io&.close
     write_io&.close
@@ -67,10 +68,12 @@ class Evilution::Isolation::Fork
     if read_io.wait_readable(timeout)
       data = read_io.read
       ::Process.wait(pid)
-      return { timeout: false }.merge(Marshal.load(data)) unless data.empty? # rubocop:disable Security/MarshalLoad
 
-      ::Process.wait(pid) rescue nil # rubocop:disable Style/RescueModifier
-      { timeout: false, passed: false, error: "empty result from child" }
+      if data.empty?
+        { timeout: false, passed: false, error: "empty result from child" }
+      else
+        { timeout: false }.merge(Marshal.load(data)) # rubocop:disable Security/MarshalLoad
+      end
     else
       terminate_child(pid)
       { timeout: true }
@@ -90,7 +93,7 @@ class Evilution::Isolation::Fork
     ::Process.wait(pid) rescue nil # rubocop:disable Style/RescueModifier
   end
 
-  def build_mutation_result(mutation, result, duration)
+  def build_mutation_result(mutation, result, duration, parent_rss_kb)
     status = if result[:timeout]
                :timeout
              elsif result[:error]
@@ -106,7 +109,8 @@ class Evilution::Isolation::Fork
       status: status,
       duration: duration,
       test_command: result[:test_command],
-      child_rss_kb: result[:child_rss_kb]
+      child_rss_kb: result[:child_rss_kb],
+      parent_rss_kb: parent_rss_kb
     )
   end
 end

data/lib/evilution/isolation/in_process.rb

@@ -7,6 +7,13 @@ require_relative "../result/mutation_result"
 require_relative "../isolation"
 
 class Evilution::Isolation::InProcess
+  @null_out = File.open(File::NULL, "w")
+  @null_err = File.open(File::NULL, "w")
+
+  class << self
+    attr_reader :null_out, :null_err
+  end
+
   def call(mutation:, test_command:, timeout:)
     start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
     rss_before = Evilution::Memory.rss_kb
@@ -15,7 +22,7 @@ class Evilution::Isolation::InProcess
     duration = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time
     delta = compute_memory_delta(rss_before, rss_after, result)
 
-    build_mutation_result(mutation, result, duration, rss_after, delta)
+    build_mutation_result(mutation, result, duration, rss_before, rss_after, delta)
   end
 
   private
@@ -34,13 +41,9 @@ class Evilution::Isolation::InProcess
   def suppress_output
     saved_stdout = $stdout
     saved_stderr = $stderr
-    File.open(File::NULL, "w") do |null_out|
-      File.open(File::NULL, "w") do |null_err|
-        $stdout = null_out
-        $stderr = null_err
-        yield
-      end
-    end
+    $stdout = self.class.null_out
+    $stderr = self.class.null_err
+    yield
   ensure
     $stdout = saved_stdout
     $stderr = saved_stderr
@@ -53,7 +56,7 @@ class Evilution::Isolation::InProcess
     rss_after - rss_before
   end
 
-  def build_mutation_result(mutation, result, duration, rss_after, memory_delta_kb)
+  def build_mutation_result(mutation, result, duration, rss_before, rss_after, memory_delta_kb)
     status = if result[:timeout]
                :timeout
              elsif result[:error]
@@ -70,7 +73,8 @@ class Evilution::Isolation::InProcess
       duration: duration,
       test_command: result[:test_command],
       child_rss_kb: rss_after,
-      memory_delta_kb: memory_delta_kb
+      memory_delta_kb: memory_delta_kb,
+      parent_rss_kb: rss_before
     )
   end
 end

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