evilution 0.14.0 → 0.16.0

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

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+class Evilution::Mutator::Operator::RescueBodyReplacement < Evilution::Mutator::Base
+  def visit_rescue_node(node)
+    generate_nil_replacement(node)
+    generate_raise_replacement(node)
+
+    super
+  end
+
+  private
+
+  def generate_nil_replacement(node)
+    return if node.statements.nil?
+
+    body_loc = node.statements.location
+    indent = " " * indentation_of(body_loc.start_offset)
+
+    add_mutation(
+      offset: body_loc.start_offset,
+      length: body_loc.length,
+      replacement: "#{indent}nil".lstrip,
+      node: node
+    )
+  end
+
+  def generate_raise_replacement(node)
+    return if bare_raise?(node)
+
+    if node.statements.nil?
+      insert_raise_into_empty(node)
+    else
+      replace_body_with_raise(node)
+    end
+  end
+
+  def replace_body_with_raise(node)
+    body_loc = node.statements.location
+    indent = " " * indentation_of(body_loc.start_offset)
+
+    add_mutation(
+      offset: body_loc.start_offset,
+      length: body_loc.length,
+      replacement: "#{indent}raise".lstrip,
+      node: node
+    )
+  end
+
+  def insert_raise_into_empty(node)
+    insert_offset = rescue_line_end(node)
+    indent = " " * (indentation_of(node.keyword_loc.start_offset) + 2)
+
+    add_mutation(
+      offset: insert_offset,
+      length: 0,
+      replacement: "\n#{indent}raise",
+      node: node
+    )
+  end
+
+  def bare_raise?(node)
+    return false if node.statements.nil?
+
+    body = node.statements.body
+    body.length == 1 &&
+      body.first.is_a?(Prism::CallNode) &&
+      body.first.name == :raise &&
+      body.first.arguments.nil? &&
+      body.first.receiver.nil?
+  end
+
+  def rescue_line_end(node)
+    if node.reference
+      node.reference.location.start_offset + node.reference.location.length
+    elsif node.exceptions.any?
+      last_exc = node.exceptions.last
+      last_exc.location.start_offset + last_exc.location.length
+    else
+      node.keyword_loc.start_offset + node.keyword_loc.length
+    end
+  end
+
+  def indentation_of(offset)
+    pos = offset - 1
+    col = 0
+    while pos >= 0 && @file_source[pos] != "\n"
+      col += 1
+      pos -= 1
+    end
+    col
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+class Evilution::Mutator::Operator::RescueRemoval < Evilution::Mutator::Base
+  def visit_rescue_node(node)
+    remove_start = line_start_before(node.keyword_loc.start_offset)
+    remove_end = rescue_end_offset(node)
+
+    add_mutation(
+      offset: remove_start,
+      length: remove_end - remove_start,
+      replacement: "",
+      node: node
+    )
+
+    super
+  end
+
+  private
+
+  def rescue_end_offset(node)
+    if node.subsequent
+      line_start_before(node.subsequent.keyword_loc.start_offset)
+    elsif node.statements
+      node.statements.location.start_offset + node.statements.location.length
+    else
+      node.keyword_loc.start_offset + node.keyword_loc.length
+    end
+  end
+
+  def line_start_before(offset)
+    pos = offset - 1
+    pos -= 1 while pos.positive? && @file_source[pos] != "\n"
+    pos
+  end
+end

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

@@ -14,13 +14,22 @@ class Evilution::Mutator::Operator::SendMutation < Evilution::Mutator::Base
     detect: [:find],
     find: [:detect],
     each_with_object: [:inject],
-    inject: [:each_with_object],
+    inject: %i[each_with_object sum],
     reverse_each: [:each],
     each: [:reverse_each],
     length: [:size],
     size: [:length],
     values_at: [:fetch_values],
-    fetch_values: [:values_at]
+    fetch_values: [:values_at],
+    sum: [:inject],
+    count: [:size],
+    select: [:filter],
+    filter: [:select],
+    to_s: [:to_i],
+    to_i: [:to_s],
+    to_f: [:to_i],
+    to_a: [:to_h],
+    to_h: [:to_a]
   }.freeze
 
   def visit_call_node(node)

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require "prism"
+
+require_relative "../operator"
+
+class Evilution::Mutator::Operator::SuperclassRemoval < Evilution::Mutator::Base
+  def call(subject)
+    @subject = subject
+    @file_source = File.read(subject.file_path)
+    @mutations = []
+
+    tree = self.class.parsed_tree_for(subject.file_path, @file_source)
+    enclosing = find_enclosing_class(tree, subject.line_number)
+    return @mutations unless enclosing
+    return @mutations unless enclosing.superclass
+
+    first_method_line = find_first_method_line(enclosing)
+    return @mutations unless first_method_line == subject.line_number
+
+    name_end = enclosing.constant_path.location.start_offset + enclosing.constant_path.location.length
+    superclass_end = enclosing.superclass.location.start_offset + enclosing.superclass.location.length
+
+    add_mutation(
+      offset: name_end,
+      length: superclass_end - name_end,
+      replacement: "",
+      node: enclosing
+    )
+
+    @mutations
+  end
+
+  private
+
+  def find_enclosing_class(tree, target_line)
+    finder = ClassFinder.new(target_line)
+    finder.visit(tree)
+    finder.result
+  end
+
+  def find_first_method_line(class_node)
+    return nil unless class_node.body
+
+    class_node.body.body.each do |node|
+      return node.location.start_line if node.is_a?(Prism::DefNode)
+    end
+    nil
+  end
+
+  # Visitor to find the ClassNode enclosing a given line number.
+  class ClassFinder < Prism::Visitor
+    attr_reader :result
+
+    def initialize(target_line)
+      @target_line = target_line
+      @result = nil
+    end
+
+    def visit_class_node(node)
+      @result = node if @target_line.between?(node.location.start_line, node.location.end_line)
+      super
+    end
+  end
+end

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

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

data/lib/evilution/mutator/registry.rb

@@ -33,7 +33,25 @@ class Evilution::Mutator::Registry
       Evilution::Mutator::Operator::ReceiverReplacement,
       Evilution::Mutator::Operator::SendMutation,
       Evilution::Mutator::Operator::ArgumentNilSubstitution,
-      Evilution::Mutator::Operator::CompoundAssignment
+      Evilution::Mutator::Operator::CompoundAssignment,
+      Evilution::Mutator::Operator::MixinRemoval,
+      Evilution::Mutator::Operator::SuperclassRemoval,
+      Evilution::Mutator::Operator::LocalVariableAssignment,
+      Evilution::Mutator::Operator::InstanceVariableWrite,
+      Evilution::Mutator::Operator::ClassVariableWrite,
+      Evilution::Mutator::Operator::GlobalVariableWrite,
+      Evilution::Mutator::Operator::RescueRemoval,
+      Evilution::Mutator::Operator::RescueBodyReplacement,
+      Evilution::Mutator::Operator::InlineRescue,
+      Evilution::Mutator::Operator::EnsureRemoval,
+      Evilution::Mutator::Operator::BreakStatement,
+      Evilution::Mutator::Operator::NextStatement,
+      Evilution::Mutator::Operator::RedoStatement,
+      Evilution::Mutator::Operator::BangMethod,
+      Evilution::Mutator::Operator::BitwiseReplacement,
+      Evilution::Mutator::Operator::BitwiseComplement,
+      Evilution::Mutator::Operator::ZsuperRemoval,
+      Evilution::Mutator::Operator::ExplicitSuperMutation
     ].each { |op| registry.register(op) }
     registry
   end

data/lib/evilution/reporter/progress_bar.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require_relative "../reporter"
+
+class Evilution::Reporter::ProgressBar
+  attr_reader :total, :width, :completed, :killed, :survived
+
+  def initialize(total:, output: $stdout, width: 30)
+    @total = total
+    @output = output
+    @width = width
+    @completed = 0
+    @killed = 0
+    @survived = 0
+    @tty = self.class.tty?(output)
+    @start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+  end
+
+  def tick(status:)
+    @completed += 1
+    @killed += 1 if status == :killed
+    @survived += 1 if status == :survived
+    render
+  end
+
+  def render
+    line = "#{bar_string} #{stats_string} | #{time_string}"
+    if @tty
+      @output.print("\r#{line}")
+    else
+      @output.puts(line)
+    end
+  end
+
+  def finish
+    render
+    @output.print("\n") if @tty
+  end
+
+  def self.tty?(io)
+    io.respond_to?(:tty?) && io.tty?
+  end
+
+  private
+
+  def bar_string
+    fraction = @total.positive? ? @completed.to_f / @total : 0
+    raw_filled = (fraction * @width).to_i
+    filled = raw_filled.clamp(0, @width)
+
+    interior = if filled <= 0
+                 " " * @width
+               elsif filled >= @width
+                 "#{"=" * (@width - 1)}>"
+               else
+                 "#{"=" * (filled - 1)}>#{" " * (@width - filled)}"
+               end
+
+    "[#{interior}]"
+  end
+
+  def stats_string
+    "#{@completed}/#{@total} mutations | #{@killed} killed | #{@survived} survived"
+  end
+
+  def time_string
+    elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - @start_time
+    remaining = estimate_remaining(elapsed)
+    "#{format_time(elapsed)} elapsed | ~#{format_time(remaining)} remaining"
+  end
+
+  def estimate_remaining(elapsed)
+    return 0 unless @completed.positive?
+
+    remaining = (@total - @completed) * (elapsed / @completed)
+    [remaining, 0].max
+  end
+
+  def format_time(seconds)
+    mins = (seconds / 60).to_i
+    secs = (seconds % 60).to_i
+    format("%<mins>02d:%<secs>02d", mins: mins, secs: secs)
+  end
+end

data/lib/evilution/reporter/suggestion.rb

@@ -24,7 +24,25 @@ class Evilution::Reporter::Suggestion
     "collection_replacement" => "Add a test that checks the return value of the collection operation, not just side effects",
     "method_call_removal" => "Add a test that depends on the return value or side effect of this method call",
     "argument_removal" => "Add a test that verifies the correct arguments are passed to this method call",
-    "compound_assignment" => "Add a test that verifies the side effect of this compound assignment (the accumulated value matters)"
+    "compound_assignment" => "Add a test that verifies the side effect of this compound assignment (the accumulated value matters)",
+    "superclass_removal" => "Add a test that exercises inherited behavior from the superclass",
+    "mixin_removal" => "Add a test that exercises behavior provided by the included/extended module",
+    "local_variable_assignment" => "Add a test that depends on the assigned variable being stored, not just the value expression",
+    "instance_variable_write" => "Add a test that verifies the instance variable is set correctly, not just the return value",
+    "class_variable_write" => "Add a test that verifies the class variable is set correctly and affects shared state",
+    "global_variable_write" => "Add a test that verifies the global variable is set correctly, not just the value expression",
+    "rescue_removal" => "Add a test that triggers the rescued exception and verifies the rescue handler behavior",
+    "rescue_body_replacement" => "Add a test that triggers the rescued exception and verifies the rescue body produces the correct result",
+    "inline_rescue" => "Add a test that triggers the inline rescue and verifies the fallback value is used correctly",
+    "ensure_removal" => "Add a test that verifies the ensure cleanup code runs and its side effects are observable",
+    "break_statement" => "Add a test that verifies the break condition and the value returned when the loop exits early",
+    "next_statement" => "Add a test that verifies the next condition and the value yielded when the iteration skips",
+    "redo_statement" => "Add a test that verifies the redo restarts the iteration and the retry logic is necessary",
+    "bang_method" => "Add a test that distinguishes in-place mutation from copy semantics (bang vs non-bang)",
+    "bitwise_replacement" => "Add a test that checks the exact bitwise result to distinguish &, |, and ^ operators",
+    "bitwise_complement" => "Add a test that verifies the bitwise complement (~) result, not just the sign or magnitude",
+    "zsuper_removal" => "Add a test that verifies inherited behavior from super is needed, not just the subclass logic",
+    "explicit_super_mutation" => "Add a test that verifies the correct arguments are passed to super and the inherited result matters"
   }.freeze
 
   CONCRETE_TEMPLATES = {
@@ -289,6 +307,240 @@ class Evilution::Reporter::Suggestion
           expect(result).to be_nil
         end
       RSPEC
+    },
+    "superclass_removal" => lambda { |mutation|
+      method_name = parse_method_name(mutation.subject.name)
+      original_line, _mutated_line = extract_diff_lines(mutation.diff)
+      <<~RSPEC.strip
+        # Mutation: removed superclass from `#{original_line}` in #{mutation.subject.name}
+        # #{mutation.file_path}:#{mutation.line}
+        it 'depends on inherited behavior in ##{method_name}' do
+          # Assert behavior that comes from the superclass
+          result = subject.#{method_name}(input_value)
+          expect(result).to eq(expected)
+        end
+      RSPEC
+    },
+    "local_variable_assignment" => lambda { |mutation|
+      method_name = parse_method_name(mutation.subject.name)
+      original_line, mutated_line = extract_diff_lines(mutation.diff)
+      <<~RSPEC.strip
+        # Mutation: changed `#{original_line}` to `#{mutated_line}` in #{mutation.subject.name}
+        # #{mutation.file_path}:#{mutation.line}
+        it 'verifies the local variable assignment is used in ##{method_name}' do
+          # Assert that the assigned variable is read later, not just the value expression
+          result = subject.#{method_name}(input_value)
+          expect(result).to eq(expected)
+        end
+      RSPEC
+    },
+    "instance_variable_write" => lambda { |mutation|
+      method_name = parse_method_name(mutation.subject.name)
+      original_line, mutated_line = extract_diff_lines(mutation.diff)
+      <<~RSPEC.strip
+        # Mutation: changed `#{original_line}` to `#{mutated_line}` in #{mutation.subject.name}
+        # #{mutation.file_path}:#{mutation.line}
+        it 'verifies the instance variable @state is set correctly in ##{method_name}' do
+          # Assert that the instance variable holds the expected value after the method runs
+          subject.#{method_name}(input_value)
+          expect(subject.instance_variable_get(:@variable)).to eq(expected)
+        end
+      RSPEC
+    },
+    "class_variable_write" => lambda { |mutation|
+      method_name = parse_method_name(mutation.subject.name)
+      original_line, mutated_line = extract_diff_lines(mutation.diff)
+      <<~RSPEC.strip
+        # Mutation: changed `#{original_line}` to `#{mutated_line}` in #{mutation.subject.name}
+        # #{mutation.file_path}:#{mutation.line}
+        it 'verifies the class variable @@shared state is set correctly in ##{method_name}' do
+          # Assert that the class variable holds the expected value and affects shared state
+          subject.#{method_name}(input_value)
+          expect(described_class.class_variable_get(:@@variable)).to eq(expected)
+        end
+      RSPEC
+    },
+    "global_variable_write" => lambda { |mutation|
+      method_name = parse_method_name(mutation.subject.name)
+      original_line, mutated_line = extract_diff_lines(mutation.diff)
+      <<~RSPEC.strip
+        # Mutation: changed `#{original_line}` to `#{mutated_line}` in #{mutation.subject.name}
+        # #{mutation.file_path}:#{mutation.line}
+        it 'verifies the global variable $state is set correctly in ##{method_name}' do
+          # Assert that the global variable holds the expected value after the method runs
+          subject.#{method_name}(input_value)
+          expect($variable).to eq(expected)
+        end
+      RSPEC
+    },
+    "mixin_removal" => lambda { |mutation|
+      method_name = parse_method_name(mutation.subject.name)
+      original_line, _mutated_line = extract_diff_lines(mutation.diff)
+      <<~RSPEC.strip
+        # Mutation: removed `#{original_line}` in #{mutation.subject.name}
+        # #{mutation.file_path}:#{mutation.line}
+        it 'depends on behavior from the included module in ##{method_name}' do
+          # Assert behavior provided by the mixin
+          result = subject.#{method_name}(input_value)
+          expect(result).to eq(expected)
+        end
+      RSPEC
+    },
+    "rescue_removal" => lambda { |mutation|
+      method_name = parse_method_name(mutation.subject.name)
+      original_line, _mutated_line = extract_diff_lines(mutation.diff)
+      <<~RSPEC.strip
+        # Mutation: removed `#{original_line}` in #{mutation.subject.name}
+        # #{mutation.file_path}:#{mutation.line}
+        it 'verifies the rescue handler is needed in ##{method_name}' do
+          # Trigger the rescued exception and assert the handler's effect
+          result = subject.#{method_name}(input_that_raises)
+          expect(result).to eq(expected)
+        end
+      RSPEC
+    },
+    "rescue_body_replacement" => lambda { |mutation|
+      method_name = parse_method_name(mutation.subject.name)
+      original_line, mutated_line = extract_diff_lines(mutation.diff)
+      <<~RSPEC.strip
+        # Mutation: changed `#{original_line}` to `#{mutated_line}` in #{mutation.subject.name}
+        # #{mutation.file_path}:#{mutation.line}
+        it 'verifies the rescue handler produces the correct result in ##{method_name}' do
+          # Trigger the exception and assert the rescue body's return value or side effect
+          result = subject.#{method_name}(input_that_raises)
+          expect(result).to eq(expected)
+        end
+      RSPEC
+    },
+    "inline_rescue" => lambda { |mutation|
+      method_name = parse_method_name(mutation.subject.name)
+      original_line, mutated_line = extract_diff_lines(mutation.diff)
+      <<~RSPEC.strip
+        # Mutation: changed `#{original_line}` to `#{mutated_line}` in #{mutation.subject.name}
+        # #{mutation.file_path}:#{mutation.line}
+        it 'verifies the inline rescue fallback value in ##{method_name}' do
+          # Trigger the exception and assert the fallback value is correct
+          result = subject.#{method_name}(input_that_raises)
+          expect(result).to eq(expected)
+        end
+      RSPEC
+    },
+    "ensure_removal" => lambda { |mutation|
+      method_name = parse_method_name(mutation.subject.name)
+      original_line, _mutated_line = extract_diff_lines(mutation.diff)
+      <<~RSPEC.strip
+        # Mutation: removed ensure block `#{original_line}` in #{mutation.subject.name}
+        # #{mutation.file_path}:#{mutation.line}
+        it 'verifies the ensure cleanup runs in ##{method_name}' do
+          # Assert that the cleanup side effect is observable after the method runs
+          subject.#{method_name}(input_value)
+          expect(observable_cleanup_effect).to eq(expected)
+        end
+      RSPEC
+    },
+    "break_statement" => lambda { |mutation|
+      method_name = parse_method_name(mutation.subject.name)
+      original_line, mutated_line = extract_diff_lines(mutation.diff)
+      <<~RSPEC.strip
+        # Mutation: changed `#{original_line}` to `#{mutated_line}` in #{mutation.subject.name}
+        # #{mutation.file_path}:#{mutation.line}
+        it 'verifies the break exits the loop correctly in ##{method_name}' do
+          # Assert the loop exits early and returns the expected value
+          result = subject.#{method_name}(input_value)
+          expect(result).to eq(expected)
+        end
+      RSPEC
+    },
+    "next_statement" => lambda { |mutation|
+      method_name = parse_method_name(mutation.subject.name)
+      original_line, mutated_line = extract_diff_lines(mutation.diff)
+      <<~RSPEC.strip
+        # Mutation: changed `#{original_line}` to `#{mutated_line}` in #{mutation.subject.name}
+        # #{mutation.file_path}:#{mutation.line}
+        it 'verifies the next skips the iteration correctly in ##{method_name}' do
+          # Assert the iteration is skipped and the expected value is yielded
+          result = subject.#{method_name}(input_value)
+          expect(result).to eq(expected)
+        end
+      RSPEC
+    },
+    "redo_statement" => lambda { |mutation|
+      method_name = parse_method_name(mutation.subject.name)
+      original_line, mutated_line = extract_diff_lines(mutation.diff)
+      <<~RSPEC.strip
+        # Mutation: changed `#{original_line}` to `#{mutated_line}` in #{mutation.subject.name}
+        # #{mutation.file_path}:#{mutation.line}
+        it 'verifies the redo retry logic is necessary in ##{method_name}' do
+          # Assert the iteration restart changes the outcome
+          result = subject.#{method_name}(input_value)
+          expect(result).to eq(expected)
+        end
+      RSPEC
+    },
+    "bitwise_replacement" => lambda { |mutation|
+      method_name = parse_method_name(mutation.subject.name)
+      original_line, mutated_line = extract_diff_lines(mutation.diff)
+      <<~RSPEC.strip
+        # Mutation: changed `#{original_line}` to `#{mutated_line}` in #{mutation.subject.name}
+        # #{mutation.file_path}:#{mutation.line}
+        it 'verifies the exact bitwise result in ##{method_name}' do
+          # Assert the exact bit-level result to distinguish &, |, and ^ operators
+          result = subject.#{method_name}(input_value)
+          expect(result).to eq(expected)
+        end
+      RSPEC
+    },
+    "bitwise_complement" => lambda { |mutation|
+      method_name = parse_method_name(mutation.subject.name)
+      original_line, mutated_line = extract_diff_lines(mutation.diff)
+      <<~RSPEC.strip
+        # Mutation: changed `#{original_line}` to `#{mutated_line}` in #{mutation.subject.name}
+        # #{mutation.file_path}:#{mutation.line}
+        it 'verifies the bitwise complement result in ##{method_name}' do
+          # Assert the exact complement (~) value, not just sign or magnitude
+          result = subject.#{method_name}(input_value)
+          expect(result).to eq(expected)
+        end
+      RSPEC
+    },
+    "bang_method" => lambda { |mutation|
+      method_name = parse_method_name(mutation.subject.name)
+      original_line, mutated_line = extract_diff_lines(mutation.diff)
+      <<~RSPEC.strip
+        # Mutation: changed `#{original_line}` to `#{mutated_line}` in #{mutation.subject.name}
+        # #{mutation.file_path}:#{mutation.line}
+        it 'verifies in-place vs copy semantics matter in ##{method_name}' do
+          # Assert that the original object is or is not modified
+          result = subject.#{method_name}(input_value)
+          expect(result).to eq(expected)
+        end
+      RSPEC
+    },
+    "zsuper_removal" => lambda { |mutation|
+      method_name = parse_method_name(mutation.subject.name)
+      original_line, mutated_line = extract_diff_lines(mutation.diff)
+      <<~RSPEC.strip
+        # Mutation: changed `#{original_line}` to `#{mutated_line}` in #{mutation.subject.name}
+        # #{mutation.file_path}:#{mutation.line}
+        it 'verifies inherited behavior from super is needed in ##{method_name}' do
+          # Assert that the result depends on the superclass implementation
+          result = subject.#{method_name}(input_value)
+          expect(result).to eq(expected)
+        end
+      RSPEC
+    },
+    "explicit_super_mutation" => lambda { |mutation|
+      method_name = parse_method_name(mutation.subject.name)
+      original_line, mutated_line = extract_diff_lines(mutation.diff)
+      <<~RSPEC.strip
+        # Mutation: changed `#{original_line}` to `#{mutated_line}` in #{mutation.subject.name}
+        # #{mutation.file_path}:#{mutation.line}
+        it 'verifies the correct arguments are passed to super in ##{method_name}' do
+          # Assert the inherited method receives the expected arguments
+          result = subject.#{method_name}(input_value)
+          expect(result).to eq(expected)
+        end
+      RSPEC
     }
   }.freeze