evilution 0.15.0 → 0.16.1

data/lib/evilution/reporter/suggestion.rb

@@ -26,7 +26,23 @@ class Evilution::Reporter::Suggestion
     "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)",
     "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"
+    "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 = {
@@ -305,6 +321,58 @@ class Evilution::Reporter::Suggestion
         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)
@@ -317,6 +385,162 @@ class Evilution::Reporter::Suggestion
           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
 

data/lib/evilution/runner.rb

@@ -201,11 +201,14 @@ class Evilution::Runner
   end
 
   def run_mutations(mutations, baseline_result = nil)
-    if config.jobs > 1
-      run_mutations_parallel(mutations, baseline_result)
-    else
-      run_mutations_sequential(mutations, baseline_result)
-    end
+    @progress_bar = build_progress_bar(mutations.length)
+    result = if config.jobs > 1
+               run_mutations_parallel(mutations, baseline_result)
+             else
+               run_mutations_sequential(mutations, baseline_result)
+             end
+    @progress_bar&.finish
+    result
   end
 
   def run_mutations_sequential(mutations, baseline_result = nil)
@@ -224,9 +227,7 @@ class Evilution::Runner
       result = neutralize_if_baseline_failed(result, baseline_result, spec_resolver)
       results << result
       survived_count += 1 if result.survived?
-      on_result&.call(result)
-      log_progress(index + 1, result.status)
-      log_mutation_diagnostics(result)
+      notify_result(result, index + 1)
 
       if config.fail_fast? && survived_count >= config.fail_fast
         truncated = true
@@ -281,9 +282,7 @@ class Evilution::Runner
       state[:results] << result
       state[:survived_count] += 1 if result.survived?
       state[:completed] += 1
-      on_result&.call(result)
-      log_progress(state[:completed], result.status)
-      log_mutation_diagnostics(result)
+      notify_result(result, state[:completed])
     end
 
     log_memory("after batch", "#{state[:completed]} complete")
@@ -447,6 +446,19 @@ class Evilution::Runner
     warn "[evilution] failed to save session: #{e.message}" unless config.quiet
   end
 
+  def notify_result(result, index)
+    on_result&.call(result)
+    @progress_bar&.tick(status: result.status)
+    log_progress(index, result.status)
+    log_mutation_diagnostics(result)
+  end
+
+  def build_progress_bar(total)
+    return nil if !config.progress? || config.quiet || config.verbose || !config.text? || !$stderr.tty?
+
+    Evilution::Reporter::ProgressBar.new(total: total, output: $stderr)
+  end
+
   def build_reporter
     case config.format
     when :json

data/lib/evilution/version.rb

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

data/lib/evilution.rb

@@ -44,6 +44,22 @@ require_relative "evilution/mutator/operator/argument_nil_substitution"
 require_relative "evilution/mutator/operator/compound_assignment"
 require_relative "evilution/mutator/operator/mixin_removal"
 require_relative "evilution/mutator/operator/superclass_removal"
+require_relative "evilution/mutator/operator/local_variable_assignment"
+require_relative "evilution/mutator/operator/instance_variable_write"
+require_relative "evilution/mutator/operator/class_variable_write"
+require_relative "evilution/mutator/operator/global_variable_write"
+require_relative "evilution/mutator/operator/rescue_removal"
+require_relative "evilution/mutator/operator/rescue_body_replacement"
+require_relative "evilution/mutator/operator/inline_rescue"
+require_relative "evilution/mutator/operator/ensure_removal"
+require_relative "evilution/mutator/operator/break_statement"
+require_relative "evilution/mutator/operator/next_statement"
+require_relative "evilution/mutator/operator/redo_statement"
+require_relative "evilution/mutator/operator/bang_method"
+require_relative "evilution/mutator/operator/bitwise_replacement"
+require_relative "evilution/mutator/operator/bitwise_complement"
+require_relative "evilution/mutator/operator/zsuper_removal"
+require_relative "evilution/mutator/operator/explicit_super_mutation"
 require_relative "evilution/mutator/registry"
 require_relative "evilution/equivalent"
 require_relative "evilution/equivalent/heuristic"
@@ -66,6 +82,7 @@ require_relative "evilution/reporter/json"
 require_relative "evilution/reporter/cli"
 require_relative "evilution/reporter/html"
 require_relative "evilution/reporter/suggestion"
+require_relative "evilution/reporter/progress_bar"
 require_relative "evilution/spec_resolver"
 require_relative "evilution/baseline"
 require_relative "evilution/cache"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: evilution
 version: !ruby/object:Gem::Version
-  version: 0.15.0
+  version: 0.16.1
 platform: ruby
 authors:
 - Denis Kiselev
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-03-28 00:00:00.000000000 Z
+date: 2026-03-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: diff-lcs
@@ -119,32 +119,48 @@ files:
 - lib/evilution/mutator/operator/argument_removal.rb
 - lib/evilution/mutator/operator/arithmetic_replacement.rb
 - lib/evilution/mutator/operator/array_literal.rb
+- lib/evilution/mutator/operator/bang_method.rb
+- lib/evilution/mutator/operator/bitwise_complement.rb
+- lib/evilution/mutator/operator/bitwise_replacement.rb
 - lib/evilution/mutator/operator/block_removal.rb
 - lib/evilution/mutator/operator/boolean_literal_replacement.rb
 - lib/evilution/mutator/operator/boolean_operator_replacement.rb
+- lib/evilution/mutator/operator/break_statement.rb
+- lib/evilution/mutator/operator/class_variable_write.rb
 - lib/evilution/mutator/operator/collection_replacement.rb
 - lib/evilution/mutator/operator/comparison_replacement.rb
 - lib/evilution/mutator/operator/compound_assignment.rb
 - lib/evilution/mutator/operator/conditional_branch.rb
 - lib/evilution/mutator/operator/conditional_flip.rb
 - lib/evilution/mutator/operator/conditional_negation.rb
+- lib/evilution/mutator/operator/ensure_removal.rb
+- lib/evilution/mutator/operator/explicit_super_mutation.rb
 - lib/evilution/mutator/operator/float_literal.rb
+- lib/evilution/mutator/operator/global_variable_write.rb
 - lib/evilution/mutator/operator/hash_literal.rb
+- lib/evilution/mutator/operator/inline_rescue.rb
+- lib/evilution/mutator/operator/instance_variable_write.rb
 - lib/evilution/mutator/operator/integer_literal.rb
+- lib/evilution/mutator/operator/local_variable_assignment.rb
 - lib/evilution/mutator/operator/method_body_replacement.rb
 - lib/evilution/mutator/operator/method_call_removal.rb
 - lib/evilution/mutator/operator/mixin_removal.rb
 - lib/evilution/mutator/operator/negation_insertion.rb
+- lib/evilution/mutator/operator/next_statement.rb
 - lib/evilution/mutator/operator/nil_replacement.rb
 - lib/evilution/mutator/operator/range_replacement.rb
 - lib/evilution/mutator/operator/receiver_replacement.rb
+- lib/evilution/mutator/operator/redo_statement.rb
 - lib/evilution/mutator/operator/regexp_mutation.rb
+- lib/evilution/mutator/operator/rescue_body_replacement.rb
+- lib/evilution/mutator/operator/rescue_removal.rb
 - lib/evilution/mutator/operator/return_value_removal.rb
 - lib/evilution/mutator/operator/send_mutation.rb
 - lib/evilution/mutator/operator/statement_deletion.rb
 - lib/evilution/mutator/operator/string_literal.rb
 - lib/evilution/mutator/operator/superclass_removal.rb
 - lib/evilution/mutator/operator/symbol_literal.rb
+- lib/evilution/mutator/operator/zsuper_removal.rb
 - lib/evilution/mutator/registry.rb
 - lib/evilution/parallel.rb
 - lib/evilution/parallel/pool.rb
@@ -152,6 +168,7 @@ files:
 - lib/evilution/reporter/cli.rb
 - lib/evilution/reporter/html.rb
 - lib/evilution/reporter/json.rb
+- lib/evilution/reporter/progress_bar.rb
 - lib/evilution/reporter/suggestion.rb
 - lib/evilution/result.rb
 - lib/evilution/result/mutation_result.rb