mutation_tester 1.6.0 → 1.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b33e53b5e67f12380151690883608e8bc76ab3915d4771baa6d5293e5cedd94c
-  data.tar.gz: 24fda20aa66c67f0a828c44fd3cd064a586c8ea40f6c9fe2f8263518ef6318be
+  metadata.gz: 69175984fb4d2e1fd2859a58bf8ef935c0866743bdcb3e712b4f0c7c5b4b3853
+  data.tar.gz: c0b7f471d708e0e9102de7fd73fb2cbd1b476f983bef5b61f2c6bb0656072cb6
 SHA512:
-  metadata.gz: 76f242526719139f3e78ba2a32e145671db00486f7a017d75011330c6c390c8b12e91ff142e779270d2f05711da36970747831cf1af9aadd06735f604010cfa8
-  data.tar.gz: 58d9d64c6344dfcee881455109b9638e9e380233a7e3a4be826879e14f8b4ca21de201f79978b9eb07fbcd0376a30b9e9b71cc440bb1c033fc92804062c6770a
+  metadata.gz: e804c052438a3e3f4e7e8dae1d0b9eee24bd169df0cfc7ffb81db4bc63adba70420c67d5d83539a4431db91c25d355bf2dc1a58229b1d6fa3f81358650a7bbd9
+  data.tar.gz: 241a515a2b594221a48af68a001660b5df09453ab985271eca43b14f72e673ad5ef24934e5c16f89b1395081addfba64280c7ffcacd125121545ab747b0db390

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## [1.7.0] - 2026-09-19
+
+- Behavior change: two new default operators generate additional mutants, so the mutation score of a file can drop after the upgrade without any change to your code, and a run that sat just above `minimum_score` can start failing. Only files that contain ranges or calls with two or more hash pairs are affected. The new survivors point at options and bounds no test checks; a mutant that cannot be killed (see below) is excluded with `# mutation_tester:disable` on its line. There is no new configuration, no new reported type and no JSON schema change: both operators belong to existing families and are switched off together with them (`argument`, `comparison`). Mutant ids shift in affected files.
+- Added removal of a single hash pair from a call argument, reported as `argument` (`Remove pair <key> from <method>`): keyword options (`validates :role, presence: true, inclusion: ROLES` yields one mutant without `presence:` and one without `inclusion:`), braced hashes, and option hashes nested as a pair value (`uniqueness: { scope: :account_id, case_sensitive: false }`). Until now the only mutants of such a call removed or replaced the whole option list, which usually fails while the class loads, so every test of the file killed them and none could tell tests apart in the kill matrix. A single removed option leaves the code loadable, so only the test that checks that option kills it. The mutant is reported on the line of the removed pair, so each pair of a multi-line call can be annotated separately. Left alone: a lone brace-free keyword that ends the call (that is the existing last-argument removal), hashes carrying a double splat (`**opts` or an anonymous `**`), hash literals that are not call arguments, and any pair whose removal would cut into a heredoc. A pair that only repeats the callee's own default (`async: false` when `async` already defaults to `false`) yields a mutant no test can kill, the same limitation the last-argument removal has.
+- Added the range boundary swap, reported as `comparison` (`Change .. to ...` and back): the range form of `<=` versus `<` on the upper bound, killed only by a test that uses the bound itself (the last element, the last character kept by `text[0...limit]`). Endless ranges (`1..`, `1..nil`, `text[1..]`) and ranges ending at `Float::INFINITY` are skipped because both forms hold the same values there; flip-flops are untouched.
+
 ## [1.6.0] - 2026-09-19
 
 - Added an opt-in kill matrix (`--kill-matrix`, `config.kill_matrix = true`) that records which tests kill each mutant, so the JSON report can be used to find redundant tests and not only missing ones. In this mode every mutant runs the full test file (no stop at the first failing test and no RSpec test selection), for RSpec and Minitest on all three runners, serial and parallel. The JSON report gains three additive fields, so `schema_version` stays at 1: `kill_matrix: true`, `tests[]` (every test of the baseline run with `id`, `name`, `line` and `status`) and `mutations[].killed_by` (the sorted ids of every test that failed under the mutant). An empty `killed_by` on a `killed` or `timeout` mutant means the killers are unknown (every timeout, and a mutated file that no longer loads), so a test must never be called redundant because of such a mutant. `--kill-matrix` together with `--fail-fast` is a usage error (exit code `2`), and a baseline that records no test aborts the run instead of reporting an empty matrix. The README has a new "Finding redundant tests" section with `jq` recipes, and `examples/github_actions/redundant_tests.yml` ships a scheduled audit workflow.

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    mutation_tester (1.6.0)
+    mutation_tester (1.7.0)
       parallel (~> 1.20)
       parser (~> 3.3)
       rainbow (~> 3.0)

data/docs/mutation-types.md

@@ -36,6 +36,12 @@ mutating them mostly yields always-killed `NoMethodError` garbage rather than a
 - `==` → `!=`, `>`, `<`
 - `!=` → `==`, `>`, `<`
 - `<=>` → `==`
+- Range boundary: `a..b` → `a...b` and `a...b` → `a..b`, the range form of `<=` versus `<` on the upper bound. Only
+  a test that uses the upper bound itself (the last element, the last character kept by `text[0...limit]`) kills it.
+  An endless range (`1..`, `1..nil`, `text[1..]`) and a range ending at `Float::INFINITY` are left alone, because both
+  forms hold the same values there; beginless ranges (`..5`) are mutated, and flip-flops are not ranges and are
+  untouched. Reported with `type: comparison`, `original` and `mutated` being the two operators (e.g.
+  `Change .. to ...`). Numeric literal bounds still get their own `number` mutants.
 
 ## Strict Equality Mutations (opt-in)
 
@@ -130,6 +136,21 @@ mutating them mostly yields always-killed `NoMethodError` garbage rather than a
   unless the argument is already the `nil` literal. A test that never verifies the effect of an argument (say, an
   exception message asserted only by class, or a constructor field no spec reads) lets these mutants survive even when
   the argument is not a literal.
+- Removes one pair of a hash passed as a call argument, each pair in its own mutant: keyword options
+  (`validates :role, presence: true, inclusion: ROLES` → `validates :role, inclusion: ROLES` and
+  `validates :role, presence: true`), braced hashes, and option hashes nested as a pair value
+  (`uniqueness: { scope: :account_id, case_sensitive: false }` → `uniqueness: { case_sensitive: false }`). Unlike
+  removing or nil-ing the whole argument, the call usually still loads and runs, so only a test that checks that one
+  option kills the mutant. A braced hash with a single pair becomes `{}`; a lone brace-free keyword that ends the call
+  (`m(a, k: 1)`) is left to the last-argument removal, which produces the same code, and is removed here only when a
+  block pass follows it (`m(a, k: 1, &blk)` → `m(a, &blk)`). Hashes that carry a double splat (`**opts` or an anonymous
+  `**`) and hash literals that are not call arguments (`PRICES = { ... }`) are not touched, and a pair is kept when
+  removing it would cut into a heredoc (the pair opens one, or a heredoc body lies between the pair and its neighbor).
+  Reported with the description `Remove pair <key> from <method>` on the line of the removed pair, so in a multi-line
+  call each pair can be annotated on its own line; when the removed text spans a line break, `mutated_line` is the
+  marker `(pair removed)` and `mutated` still holds the whole call after the mutation. As with last-argument removal, a
+  pair that only repeats the callee's own default (`notify(user, async: false)` when `async` already defaults to
+  `false`) yields a mutant no test can kill; annotate the line of that pair with `# mutation_tester:disable`.
 - Exclusions: operator sends (`+`, `==`, `[]`, `[]=`, `<<`, setters, ...), require-like calls (`require`,
   `require_relative`, `load`, `autoload`), block-pass arguments (`&blk`), splats (`*args`), double splats (`**opts`),
   and safe-navigation calls are not mutated by this family. A candidate whose code would no longer parse is dropped at

data/lib/mutation_tester/mutator.rb

@@ -41,6 +41,10 @@ module MutationTester
 
     NON_MUTABLE_ARGUMENT_TYPES = %i[block_pass splat kwsplat].freeze
 
+    HASH_NODE_TYPES = %i[hash kwargs].freeze
+
+    RANGE_OPERATOR_SWAPS = { irange: '...', erange: '..' }.freeze
+
     DISABLE_ANNOTATION = /mutation_tester:disable\b/.freeze
 
     def self.disabled_lines(content)
@@ -71,6 +75,7 @@ module MutationTester
       @disabled_lines = self.class.disabled_lines(@original_content)
       @in_memory_safe_context = false
       @class_body_block_depth = 0
+      @heredoc_ranges = heredoc_ranges(ast)
       mutations = collect_mutations(ast)
       mutations = filter_mutations(mutations)
       report_skipped(mutations.size) if @skipped_count.positive?
@@ -144,6 +149,8 @@ module MutationTester
         mutations += mutate_logical_and(ast) if enabled?(:logical)
       when :or
         mutations += mutate_logical_or(ast) if enabled?(:logical)
+      when :irange, :erange
+        mutations += mutate_range_node(ast) if enabled?(:comparison)
       end
 
       mutations.each do |mutation|
@@ -282,7 +289,9 @@ module MutationTester
       return [] unless PLAIN_METHOD_NAME.match?(method_name.to_s)
       return [] if REQUIRE_METHODS.include?(method_name)
 
-      build_last_argument_removal(node, arguments) + build_argument_nil_mutations(node, arguments)
+      build_last_argument_removal(node, arguments) +
+        build_argument_nil_mutations(node, arguments) +
+        build_pair_removal_mutations(node, arguments)
     rescue => e
       warn_skipped(:argument, node, e)
       []
@@ -290,7 +299,7 @@ module MutationTester
 
     def mutable_argument?(argument)
       return false if NON_MUTABLE_ARGUMENT_TYPES.include?(argument.type)
-      return false if %i[kwargs hash].include?(argument.type) &&
+      return false if HASH_NODE_TYPES.include?(argument.type) &&
                       argument.children.any? { |child| child.is_a?(Parser::AST::Node) && child.type == :kwsplat }
 
       true
@@ -328,7 +337,77 @@ module MutationTester
       end
     end
 
-    def build_argument_mutation(node, range_begin, range_end, replacement, description)
+    def build_pair_removal_mutations(node, arguments)
+      arguments.flat_map do |argument|
+        next [] unless HASH_NODE_TYPES.include?(argument.type)
+
+        build_hash_pair_removals(node, argument, arguments)
+      end
+    rescue => e
+      warn_skipped(:argument, node, e)
+      []
+    end
+
+    def build_hash_pair_removals(node, hash, arguments)
+      pairs = hash.children
+      return [] unless pairs.all? { |child| child.type == :pair }
+
+      nested = pairs.flat_map do |pair|
+        value = pair.children[1]
+        value.type == :hash ? build_hash_pair_removals(node, value, arguments) : []
+      end
+
+      pairs.each_index.filter_map { |index| build_pair_removal(node, hash, index, arguments) } + nested
+    end
+
+    def build_pair_removal(node, hash, index, arguments)
+      range_begin, range_end = pair_removal_range(hash, index, arguments)
+      return nil unless range_begin
+      return nil if overlaps_heredoc?(range_begin, range_end)
+
+      pair = hash.children[index]
+      key = pair.children[0].loc.expression
+      mutation = build_argument_mutation(
+        node, range_begin, range_end, '',
+        "Remove pair #{source_slice(key.begin_pos, key.end_pos)} from #{node.children[1]}",
+        line: pair.loc.line
+      )
+      mutation[:mutated_line] = '(pair removed)' if mutation && source_slice(range_begin, range_end).include?("\n")
+      mutation
+    end
+
+    def pair_removal_range(hash, index, arguments)
+      pairs = hash.children
+      pair = pairs[index].loc.expression
+
+      if pairs.size > 1 && index < pairs.size - 1
+        [pair.begin_pos, pairs[index + 1].loc.expression.begin_pos]
+      elsif pairs.size > 1
+        [pairs[index - 1].loc.expression.end_pos, pair.end_pos]
+      elsif hash.loc.begin
+        [hash.loc.begin.end_pos, hash.loc.end.begin_pos]
+      else
+        following = arguments[arguments.index { |argument| argument.equal?(hash) } + 1]
+        following && [pair.begin_pos, following.loc.expression.begin_pos]
+      end
+    end
+
+    def heredoc_ranges(node, ranges = [])
+      return ranges unless node.is_a?(Parser::AST::Node)
+
+      if heredoc_node?(node)
+        ranges << [node.loc.expression.begin_pos, node.loc.expression.end_pos]
+        ranges << [node.loc.heredoc_body.begin_pos, node.loc.heredoc_end.end_pos]
+      end
+      node.children.each { |child| heredoc_ranges(child, ranges) }
+      ranges
+    end
+
+    def overlaps_heredoc?(range_begin, range_end)
+      @heredoc_ranges.any? { |heredoc_begin, heredoc_end| range_begin < heredoc_end && heredoc_begin < range_end }
+    end
+
+    def build_argument_mutation(node, range_begin, range_end, replacement, description, line: node.loc.line)
       mutated_code = splice_source(range_begin, range_end, replacement)
       return nil if mutated_code == @original_content
       return nil unless parses_cleanly?(mutated_code)
@@ -338,12 +417,12 @@ module MutationTester
       {
         id: next_mutation_id,
         type: :argument,
-        line: node.loc.line,
+        line: line,
         original: source_slice(call.begin_pos, call.end_pos),
         mutated: mutated_code[call.begin_pos...(call.end_pos + offset)],
         code: mutated_code,
-        source_line: extract_source_line(node.loc.line),
-        mutated_line: extract_mutated_line(mutated_code, node.loc.line),
+        source_line: extract_source_line(line),
+        mutated_line: extract_mutated_line(mutated_code, line),
         description: description
       }
     end
@@ -670,6 +749,35 @@ module MutationTester
       []
     end
 
+    def mutate_range_node(node)
+      upper_bound = node.children[1]
+      return [] if upper_bound.nil? || upper_bound.type == :nil || infinity_constant?(upper_bound)
+
+      operator = node.loc.operator
+      replacement = RANGE_OPERATOR_SWAPS.fetch(node.type)
+      mutated_code = splice_source(operator.begin_pos, operator.end_pos, replacement)
+      return [] unless parses_cleanly?(mutated_code)
+
+      [{
+        id: next_mutation_id,
+        type: :comparison,
+        line: operator.line,
+        original: operator.source,
+        mutated: replacement,
+        code: mutated_code,
+        source_line: extract_source_line(operator.line),
+        mutated_line: extract_mutated_line(mutated_code, operator.line),
+        description: "Change #{operator.source} to #{replacement}"
+      }]
+    rescue => e
+      warn_skipped(:comparison, node, e)
+      []
+    end
+
+    def infinity_constant?(node)
+      node.type == :const && node.children[1] == :INFINITY
+    end
+
     def parses_cleanly?(code)
       buffer = Parser::Source::Buffer.new('(mutant-candidate)')
       buffer.source = code

data/lib/mutation_tester/version.rb

@@ -1,3 +1,3 @@
 module MutationTester
-  VERSION = '1.6.0'.freeze
+  VERSION = '1.7.0'.freeze
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mutation_tester
 version: !ruby/object:Gem::Version
-  version: 1.6.0
+  version: 1.7.0
 platform: ruby
 authors:
 - Kamil Dzierbicki