evilution 0.11.2 → 0.13.0

data/lib/evilution/reporter/suggestion.rb

@@ -23,11 +23,281 @@ module Evilution
         "return_value_removal" => "Add a test that uses the return value of this method",
         "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"
+        "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)"
+      }.freeze
+
+      CONCRETE_TEMPLATES = {
+        "comparison_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 'returns the correct result at the comparison boundary in ##{method_name}' do
+              # Test with values where the original operator and mutated operator
+              # produce different results (e.g., equal values for > vs >=)
+              result = subject.#{method_name}(boundary_value)
+              expect(result).to eq(expected)
+            end
+          RSPEC
+        },
+        "arithmetic_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 'computes the correct arithmetic result in ##{method_name}' do
+              # Assert the exact numeric result, not just truthiness or sign
+              result = subject.#{method_name}(input_value)
+              expect(result).to eq(expected)
+            end
+          RSPEC
+        },
+        "boolean_operator_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 'returns the correct result when one condition is true and one is false in ##{method_name}' do
+              # Use inputs where only one operand is truthy to distinguish && from ||
+              result = subject.#{method_name}(input_value)
+              expect(result).to eq(expected)
+            end
+          RSPEC
+        },
+        "boolean_literal_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 'returns the expected boolean value from ##{method_name}' do
+              # Assert the exact true/false/nil value, not just truthiness
+              result = subject.#{method_name}(input_value)
+              expect(result).to eq(expected)
+            end
+          RSPEC
+        },
+        "negation_insertion" => 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 'returns the correct boolean from the predicate in ##{method_name}' do
+              # Assert the exact true/false result, not just truthiness
+              result = subject.#{method_name}(input_value)
+              expect(result).to eq(true).or eq(false)
+            end
+          RSPEC
+        },
+        "integer_literal" => 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 'returns the exact integer value from ##{method_name}' do
+              # Assert the exact numeric value, not just > 0 or truthy
+              result = subject.#{method_name}(input_value)
+              expect(result).to eq(expected)
+            end
+          RSPEC
+        },
+        "float_literal" => 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 'returns the exact float value from ##{method_name}' do
+              # Assert the exact floating-point result
+              result = subject.#{method_name}(input_value)
+              expect(result).to eq(expected)
+            end
+          RSPEC
+        },
+        "string_literal" => 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 'returns the exact string content from ##{method_name}' do
+              # Assert the exact string value, not just presence or non-empty
+              result = subject.#{method_name}(input_value)
+              expect(result).to eq(expected)
+            end
+          RSPEC
+        },
+        "symbol_literal" => 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 'returns the exact symbol from ##{method_name}' do
+              # Assert the exact symbol value, not just that it is a Symbol
+              result = subject.#{method_name}(input_value)
+              expect(result).to eq(expected)
+            end
+          RSPEC
+        },
+        "array_literal" => 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 'returns the expected array contents from ##{method_name}' do
+              # Assert the exact array elements, not just non-empty or truthy
+              result = subject.#{method_name}(input_value)
+              expect(result).to eq(expected)
+            end
+          RSPEC
+        },
+        "hash_literal" => 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 'returns the expected hash contents from ##{method_name}' do
+              # Assert the exact keys and values, not just non-empty or truthy
+              result = subject.#{method_name}(input_value)
+              expect(result).to eq(expected)
+            end
+          RSPEC
+        },
+        "collection_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 'uses the return value of the collection operation in ##{method_name}' do
+              # Assert the return value of the collection method, not just side effects
+              result = subject.#{method_name}(input_value)
+              expect(result).to eq(expected)
+            end
+          RSPEC
+        },
+        "conditional_negation" => 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 'exercises both branches of the conditional in ##{method_name}' do
+              # Test with inputs that make the condition true AND false
+              result = subject.#{method_name}(input_value)
+              expect(result).to eq(expected)
+            end
+          RSPEC
+        },
+        "conditional_branch" => 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 'exercises the removed branch of the conditional in ##{method_name}' do
+              # Test with inputs that trigger the branch removed by this mutation
+              result = subject.#{method_name}(input_value)
+              expect(result).to eq(expected)
+            end
+          RSPEC
+        },
+        "statement_deletion" => lambda { |mutation|
+          method_name = parse_method_name(mutation.subject.name)
+          original_line, _mutated_line = extract_diff_lines(mutation.diff)
+          <<~RSPEC.strip
+            # Mutation: deleted `#{original_line}` in #{mutation.subject.name}
+            # #{mutation.file_path}:#{mutation.line}
+            it 'depends on the side effect of the deleted statement in ##{method_name}' do
+              # Assert a side effect or return value that changes when this statement is removed
+              subject.#{method_name}(input_value)
+              expect(observable_side_effect).to eq(expected)
+            end
+          RSPEC
+        },
+        "method_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 return value or side effects of ##{method_name}' do
+              # Assert the method produces a meaningful result, not just nil
+              result = subject.#{method_name}(input_value)
+              expect(result).to eq(expected)
+            end
+          RSPEC
+        },
+        "return_value_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 'uses the return value of ##{method_name}' do
+              # Assert the caller depends on the return value, not just side effects
+              result = subject.#{method_name}(input_value)
+              expect(result).to eq(expected)
+            end
+          RSPEC
+        },
+        "method_call_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 'depends on the return value or side effect of the call in ##{method_name}' do
+              # Assert the method call's effect is observable
+              result = subject.#{method_name}(input_value)
+              expect(result).to eq(expected)
+            end
+          RSPEC
+        },
+        "compound_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 compound assignment side effect in ##{method_name}' do
+              # Assert the accumulated value after the compound assignment
+              # The mutation changes the operator, so the final value will differ
+              subject.#{method_name}(input_value)
+              expect(observable_side_effect).to eq(expected)
+            end
+          RSPEC
+        },
+        "nil_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 'asserts the nil return value from ##{method_name}' do
+              # Assert the method returns nil, not a substituted value
+              result = subject.#{method_name}(input_value)
+              expect(result).to be_nil
+            end
+          RSPEC
+        }
       }.freeze
 
       DEFAULT_SUGGESTION = "Add a more specific test that detects this mutation"
 
+      def initialize(suggest_tests: false)
+        @suggest_tests = suggest_tests
+      end
+
       # Generate suggestions for survived mutations.
       #
       # @param summary [Result::Summary]
@@ -46,8 +316,26 @@ module Evilution
       # @param mutation [Mutation]
       # @return [String]
       def suggestion_for(mutation)
+        if @suggest_tests
+          concrete = CONCRETE_TEMPLATES[mutation.operator_name]
+          return concrete.call(mutation) if concrete
+        end
+
         TEMPLATES.fetch(mutation.operator_name, DEFAULT_SUGGESTION)
       end
+
+      class << self
+        def parse_method_name(subject_name)
+          subject_name.split(/[#.]/).last
+        end
+
+        def extract_diff_lines(diff)
+          lines = diff.split("\n")
+          original = lines.find { |l| l.start_with?("- ") }
+          mutated = lines.find { |l| l.start_with?("+ ") }
+          [original&.sub(/^- /, "")&.strip, mutated&.sub(/^\+ /, "")&.strip]
+        end
+      end
     end
   end
 end

data/lib/evilution/version.rb

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

data/lib/evilution.rb

@@ -35,6 +35,7 @@ require_relative "evilution/mutator/operator/regexp_mutation"
 require_relative "evilution/mutator/operator/receiver_replacement"
 require_relative "evilution/mutator/operator/send_mutation"
 require_relative "evilution/mutator/operator/argument_nil_substitution"
+require_relative "evilution/mutator/operator/compound_assignment"
 require_relative "evilution/mutator/registry"
 require_relative "evilution/equivalent/detector"
 require_relative "evilution/isolation/fork"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: evilution
 version: !ruby/object:Gem::Version
-  version: 0.11.2
+  version: 0.13.0
 platform: ruby
 authors:
 - Denis Kiselev
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-03-21 00:00:00.000000000 Z
+date: 2026-03-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: diff-lcs
@@ -109,6 +109,7 @@ files:
 - lib/evilution/mutator/operator/boolean_operator_replacement.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