saboteur 0.9.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 30c6af46486b9fc1138b568c45934cc895f786a79ea5215607f493a5a7d5af68
-  data.tar.gz: a7a8038afc6166347fac807028cf7f45acecbb7e4c27e32f8917c4167b805bac
+  metadata.gz: e7d127c4a50466eb11e40c8f1f8ac92b013621d76ddfd3f122823ec85f0ff726
+  data.tar.gz: 8768ae6add39713a3ffb0222609c096ddb8e71e7edcb174f83e0ce3719c6296f
 SHA512:
-  metadata.gz: 66817191adf235c1fb6adb41d3218704557d2d3305fab299f17cc38bb3b392733f0a52615d84aadb5e4fd940046db9336de9efa178b205d58cc8e1c61374c25a
-  data.tar.gz: 132649f6b81d5ee312341a032df36b890af481704deee6c4b5cd4a013736c857ddc7887b27318409a1db05ea2621cbc8b2791ff4d0c40d3509810a6e13f7a405
+  metadata.gz: eb07cd559cf3b12dadd0e7b1a148f04e2e6aada3e961f9dfcd249f05da69cd7f59bc8a43335450df86ae4b6406be013ca7e737357ac3e07023169f6f9d434e52
+  data.tar.gz: 1cb27f6614903b63907f1ddf54872bdcfa1e1ab2c288bd40f4ed3ce9e247bed320105afb33fcb03e845a03887f7343250c36d2b82f35a1c7da61227dd83f0244

data/CHANGELOG.md

@@ -6,6 +6,28 @@ All notable changes are documented here. The format follows
 
 ## [Unreleased]
 
+## [0.10.0] - 2026-10-21
+
+### Added
+
+- Survivor labels in the terminal: surviving mutants carry a label and
+  the findings collapse per statement, ignored mutants are reported with
+  their reasons, and external-runner runs emit the `tool_limit` label
+  (#1065, #1071).
+- Pins covering the terminal collapse, the `--all-mutants` wiring, and
+  the phase1 end-to-end default (#1065).
+
+### Changed
+
+- The terminal disambiguates the two no-coverage skip counts (#1087).
+- `test_selection = :all` is gone: the 17 mirror-breaking files are
+  mapped explicitly instead (#1077).
+
+### Fixed
+
+- The `element_removal` help text shows that any array literal works
+  (#1086).
+
 ## [0.9.0] - 2026-10-20
 
 ### Added

data/README.md

@@ -89,7 +89,8 @@ killed 8  survived 2  timeout 0  resource limit 0  error 0  score 80.0 %
 Each survivor comes with its diff, the tests that ran, and a triage label
 (`likely_equivalent`, `arid`, `missing_test`) to sort what to read first.
 The labels are heuristics for reading order, never a diagnosis, and they
-never change the score.
+never change the score. The terminal prints one finding per statement with
+the label mix and mutant count; `--all-mutants` lists every mutant.
 
 A run on a tree with uncommitted changes opens with a warning that splits
 the count into changes inside the mutation scope, outside it, and

data/lib/saboteur/cli/output_options.rb

@@ -21,6 +21,8 @@ module Saboteur
         opts.on("--[no-]color", "Colour the text report (default: on for a terminal unless NO_COLOR is set)") do |v|
           @color = v ? :always : :never
         end
+        opts.on("--all-mutants", "Text report: list every survived mutant;",
+                "default: one finding per statement, with the label mix") { set(:all_mutants, true) }
       end
     end
   end

data/lib/saboteur/cli/run_reporting.rb

@@ -13,7 +13,8 @@ module Saboteur
       def text_run(report, engine)
         @err.puts
         Reporter::Terminal.new(@out, verbose: @verbose || false, color: @color || :auto,
-                                     replay_command: survivor_replay_command(report, engine)).call(report)
+                                     replay_command: survivor_replay_command(report, engine),
+                                     all_mutants: options[:all_mutants] || false).call(report)
         Reporter::Replay.new(@out).call(report) if options[:id]
         code = exit_code(report)
         # The JSON carries the exit cause an outer harness trusts, so it is

data/lib/saboteur/cli.rb

@@ -131,7 +131,7 @@ module Saboteur
 
     def agent_requested? = self.class.agent_requested?(@argv)
 
-    def overrides = options.except(:config, :id, :suite, :list_operators, :dry_run)
+    def overrides = options.except(:config, :id, :suite, :list_operators, :dry_run, :all_mutants)
 
     def add_subject(expr) = (options[:subjects] ||= []) << expr
 

data/lib/saboteur/engine/coverage_store.rb

@@ -393,11 +393,10 @@ module Saboteur
 
       def preloaded_message(files)
         names = Text.name_list(files.map { |file| file.delete_prefix("#{@root}/") })
-        "#{names} loaded before saboteur started coverage (a require ran before the " \
-          "executable's Coverage.start - commonly the gemspec requiring the library while bundler/setup " \
-          "evaluates it, or RUBYOPT -r), so no test can ever cover #{files.size > 1 ? 'them' : 'it'}. " \
-          "Let the test suite load these " \
-          "files; a gemspec should require only its version file."
+        "#{names} can never be covered: loaded before saboteur started coverage\n  " \
+          "a require ran before the executable's Coverage.start, commonly the gemspec requiring the " \
+          "library while bundler/setup evaluates it, or RUBYOPT -r\n  " \
+          "Let the test suite load these files; a gemspec should require only its version file."
       end
 
       # Bootsnap is named only when it is loaded: blaming a library the app

data/lib/saboteur/mutation_source/builtin.rb

@@ -4,6 +4,7 @@
 require "prism"
 require_relative "base"
 require_relative "filter_replacement"
+require_relative "copy_replacement"
 require_relative "literal_replacement"
 require_relative "argument_removal"
 require_relative "argument_swap"
@@ -21,6 +22,7 @@ require_relative "interpolation_removal"
 require_relative "jump_value"
 require_relative "regex_replacement"
 require_relative "rescue_removal"
+require_relative "ensure_removal"
 require_relative "when_removal"
 require_relative "unary_removal"
 
@@ -76,10 +78,10 @@ module Saboteur
       SCOPE_NODES = [Prism::DefNode, Prism::ClassNode, Prism::ModuleNode, Prism::SingletonClassNode].freeze
       # The single-purpose sources, in the order they run after the shared walk.
       DELEGATED = [
-        FilterReplacement, LiteralReplacement, ArgumentRemoval, PairRemoval, ElementRemoval, ChainRemoval,
-        EndpointReplacement, RangeReplacement, OperatorAssignment, ConditionNegation, MethodSwap,
+        FilterReplacement, CopyReplacement, LiteralReplacement, ArgumentRemoval, PairRemoval, ElementRemoval,
+        ChainRemoval, EndpointReplacement, RangeReplacement, OperatorAssignment, ConditionNegation, MethodSwap,
         OperandReplacement, InterpolationRemoval, RegexReplacement, ArgumentSwap, JumpValue, RescueRemoval,
-        WhenRemoval, UnaryRemoval
+        EnsureRemoval, WhenRemoval, UnaryRemoval
       ].freeze
 
       def initialize(arid: DEFAULT_ARID, operators: [], exclude_operators: [])

data/lib/saboteur/mutation_source/copy_replacement.rb

@@ -0,0 +1,72 @@
+# SPDX-License-Identifier: MIT
+# frozen_string_literal: true
+
+require "prism"
+require_relative "base"
+
+module Saboteur
+  module MutationSource
+    # Drops a defensive copy (x.dup, x.clone becomes x) or makes a deep copy
+    # shallow (x.deep_dup becomes x.dup). Both let a caller and a callee share
+    # state that the original code kept apart.
+    class CopyReplacement < Base
+      DROPPED = %i[dup clone].freeze
+      SHALLOWER = { deep_dup: "dup" }.freeze
+      SCOPE_NODES = [Prism::DefNode, Prism::ClassNode, Prism::ModuleNode, Prism::SingletonClassNode].freeze
+
+      # Base inherits Object's empty initializer; there is no parent state to set.
+      def initialize(arid: []) # rubocop:disable Lint/MissingSuper
+        @arid = arid.map { |pattern| Regexp.new(pattern) }
+      end
+
+      def name
+        "copy_replacement"
+      end
+
+      def mutations_for(subject)
+        found = []
+        visit(subject.body_node, subject, found)
+        found
+      end
+
+      private
+
+      def visit(node, subject, found)
+        return if node.nil? || SCOPE_NODES.any? { |scope| node.is_a?(scope) }
+
+        if node.is_a?(Prism::StatementsNode)
+          node.body.each { |statement| visit(statement, subject, found) unless arid?(statement) }
+          return
+        end
+
+        replace_copy(node, subject, found) if node.is_a?(Prism::CallNode)
+        node.compact_child_nodes.each { |child| visit(child, subject, found) }
+        nil
+      end
+
+      def replace_copy(node, subject, found)
+        return unless node.receiver && node.block.nil? && node.arguments.nil?
+
+        edit = DROPPED.include?(node.name) ? drop(node, subject) : shallow(node, subject)
+        found << Mutation.new(subject_id: subject.id, operator: name, edits: [edit], source: name) if edit
+      end
+
+      # Receiver stays; the dot (or &.) through the end of the call goes.
+      def drop(node, subject)
+        Edit.new(file: subject.file, start_byte: node.call_operator_loc.start_offset,
+                 end_byte: node.end_offset, replacement: "")
+      end
+
+      def shallow(node, subject)
+        replacement = SHALLOWER[node.name] or return
+        location = node.message_loc
+        Edit.new(file: subject.file, start_byte: location.start_offset, end_byte: location.end_offset,
+                 replacement: replacement)
+      end
+
+      def arid?(node)
+        @arid.any? { |pattern| pattern.match?(node.slice) }
+      end
+    end
+  end
+end

data/lib/saboteur/mutation_source/ensure_removal.rb

@@ -0,0 +1,49 @@
+# SPDX-License-Identifier: MIT
+# frozen_string_literal: true
+
+require "prism"
+require_relative "base"
+require_relative "operator_visit"
+
+module Saboteur
+  module MutationSource
+    # Deletes the `ensure` clause of a begin block, method body or do block, so
+    # the cleanup it runs is skipped: `begin; x; ensure; y; end` becomes
+    # `begin; x; end`. A test that never checks the cleanup cannot tell the
+    # clause from no clause. Removing the clause's statements is
+    # statement_removal's job; this removes the clause itself. A rescue or
+    # else clause beside it stays.
+    class EnsureRemoval < Base
+      include OperatorVisit
+
+      # Base inherits Object's empty initializer; there is no parent state to set.
+      def initialize(arid: []) # rubocop:disable Lint/MissingSuper
+        @arid = arid.map { |pattern| Regexp.new(pattern) }
+      end
+
+      def name
+        "ensure_removal"
+      end
+
+      private
+
+      def mutate_node(node, subject, found)
+        return unless node.is_a?(Prism::BeginNode)
+
+        clause = node.ensure_clause
+        return if clause.nil? || heredoc?(clause)
+
+        # The clause's location runs through the closing `end`, which stays.
+        edit = Edit.new(file: subject.file, start_byte: clause.start_offset,
+                        end_byte: clause.end_keyword_loc.start_offset, replacement: "")
+        found << Mutation.new(subject_id: subject.id, operator: name, edits: [edit], source: name)
+      end
+
+      # A heredoc's body lives on later lines: cutting the clause that opens
+      # one would leave the body behind.
+      def heredoc?(node)
+        node.slice.start_with?("<<") || node.compact_child_nodes.any? { |child| heredoc?(child) }
+      end
+    end
+  end
+end

data/lib/saboteur/mutation_source/operator_examples.rb

@@ -20,6 +20,7 @@ module Saboteur
         "and_assign" => "x &&= y -> x = y",
         "safe_navigation" => "x&.name -> x.name",
         "statement_removal" => "check; value -> nil; value",
+        "copy_replacement" => "x.dup -> x",
         "filter_replacement" => "xs.select { |x| x } -> xs.reject { |x| x }",
         "literal_string" => "\"hello\" -> \"\"",
         "literal_boolean" => "true -> false",
@@ -37,6 +38,7 @@ module Saboteur
         "interpolation_removal" => "\"hi \#{name}\" -> \"hi \"",
         "jump_value" => "return total -> return nil",
         "rescue_removal" => "begin; x; rescue; y; end -> begin; x; end",
+        "ensure_removal" => "begin; x; ensure; y; end -> begin; x; end",
         "when_removal" => "case x; when 1 then a; when 2 then b; end -> case x; when 2 then b; end",
         "unary_removal" => "-x -> x",
         "regex_replacement" => "/\\A\\d+\\z/ -> /\\d+\\z/"

data/lib/saboteur/mutation_source/operator_registry.rb

@@ -28,12 +28,13 @@ module Saboteur
         "safe_navigation" => "Replace safe navigation with a regular call",
         "statement_removal" => "Replace a statement with nil",
         "filter_replacement" => "Swap select and reject",
+        "copy_replacement" => "Drop a dup or clone, or make deep_dup shallow",
         "literal_string" => "Empty a string literal",
         "literal_boolean" => "Swap a boolean literal",
         "argument_swap" => "Swap two positional call arguments",
         "argument_removal" => "Remove a call argument",
         "pair_removal" => "Remove a hash pair",
-        "element_removal" => "Remove an element of a constant array literal",
+        "element_removal" => "Remove an element of an array literal",
         "endpoint_replacement" => "Swap explicit no-argument first and last",
         "chain_removal" => "Remove one call from a method chain",
         "method_swap" => "Swap a method with its semantic opposite",
@@ -41,6 +42,7 @@ module Saboteur
         "interpolation_removal" => "Remove part of an interpolated string",
         "jump_value" => "Replace the value of return, next or break with nil",
         "rescue_removal" => "Remove an exception handler so the error propagates",
+        "ensure_removal" => "Remove an ensure clause so its cleanup is skipped",
         "when_removal" => "Remove one when branch of a case",
         "unary_removal" => "Drop a unary minus or bitwise complement",
         "regex_replacement" => "Drop a regex anchor or swap a regex quantifier"

data/lib/saboteur/reporter/survivor_classification.rb

@@ -26,9 +26,10 @@ module Saboteur
     #     covering list is only the PLANNED coverage: whole-body (coarse)
     #     mutants carry method-level guesses, so they never get this
     #     label, and neither does anything without real coverage.
-    #   tool_limit   - reserved for survivors saboteur could not observe
-    #     faithfully (re-eval refusal, external runner without coverage). No
-    #     result records that signal yet, so the label is never emitted.
+    #   tool_limit   - survivors saboteur could not observe faithfully: an
+    #     external-runner run records only the pseudo-test id, never real
+    #     coverage (#1071). A re-eval refusal records no signal on the
+    #     result yet, so that half of the reservation is still unemitted.
     #
     # A survivor with no matching signal stays unlabeled.
     module SurvivorClassification
@@ -39,6 +40,7 @@ module Saboteur
           return nil unless result.status == :survived
           return "likely_equivalent" if equivalent?(result)
           return "arid" if arid?(result, arid)
+          return "tool_limit" if tool_limited?(result)
           return "missing_test" if possible_test_gap?(result)
 
           nil
@@ -62,6 +64,13 @@ module Saboteur
                                                       frozen_string_literal: subject.frozen_literals)
         end
 
+        # An external runner reports one pseudo id for every mutant and no
+        # coverage map, so a survivor there was never observed against real
+        # tests. Pseudo id next to a real id keeps missing_test (#305).
+        def tool_limited?(result)
+          result.covered_by.any? && result.covered_by.all? { |id| id == Execution::ExternalRunner::PSEUDO_TEST }
+        end
+
         # covered_by is a PLANNED covering list, not a verdict about what
         # the suite asserts: coarse (whole-body) mutants carry method-level
         # guesses, and a --test-command run records only the pseudo-test id

data/lib/saboteur/reporter/survivor_hints.rb

@@ -26,8 +26,10 @@ module Saboteur
         "endpoint_replacement" => "try a collection with 2 or more elements, to tell first from last",
         "jump_value" => "try asserting the value this early exit returns",
         "rescue_removal" => "try an example where the guarded code raises, and assert what the handler returns",
+        "ensure_removal" => "try asserting the cleanup effect of the ensure clause",
         "when_removal" => "try a value that only this when branch matches, and assert its result",
         "unary_removal" => "try a value where the sign or complement changes the result",
+        "copy_replacement" => "try changing the result after the call and check the original is untouched",
         "filter_replacement" => "try items that match and items that do not, to tell select from reject"
       }.freeze
 

data/lib/saboteur/reporter/survivor_list.rb

@@ -3,6 +3,7 @@
 
 require_relative "mutation_text"
 require_relative "survivor_hints"
+require_relative "survivor_classification"
 
 module Saboteur
   module Reporter
@@ -12,9 +13,11 @@ module Saboteur
     class SurvivorList
       MAX_PASSING_TESTS = 5
 
-      def initialize(out, palette)
+      def initialize(out, palette, all_mutants: false, classifier: SurvivorClassification)
         @out = out
         @palette = palette
+        @all_mutants = all_mutants
+        @classifier = classifier
       end
 
       # Every survivor, in report order; the grouping keeps them readable.
@@ -43,10 +46,33 @@ module Saboteur
           first = on_line.first
           @out.puts "    #{path}:#{line} in #{first.subject.id}"
           @out.puts "      #{@palette.paint(:dim, "#{line}:")} #{source_line(first, line)}"
-          evidence_groups(report, on_line).each { |group| evidence_group(report, path, group) }
+          if @all_mutants
+            evidence_groups(report, on_line).each { |group| evidence_group(report, path, group) }
+          else
+            live, ignored = on_line.partition { |result| result.ignored.nil? }
+            statement_finding(live) unless live.empty?
+            ignored.each { |result| mutation(result) }
+          end
         end
       end
 
+      # Default view (#1065): one finding per statement - how many mutants
+      # survive here and the mix of their classification labels, with the
+      # covering tests once. --all-mutants restores the per-mutant list.
+      def statement_finding(on_line)
+        count = "#{on_line.size} #{on_line.one? ? 'mutant' : 'mutants'}"
+        mix = on_line.group_by { |result| @classifier.label(result) || "unlabeled" }
+                     .sort_by { |label, _| label }
+                     .map { |label, group| "#{group.size} #{label}" }
+                     .join(", ")
+        @out.puts "      #{@palette.paint(:red, '-')} #{count}: #{mix}"
+        tests_line(on_line.flat_map(&:covered_by).uniq, on_line.first.reused?)
+        digests = on_line.map(&:digest)
+        more = digests.size - 3
+        suffix = " (+#{more} more in the JSON report)" if more.positive?
+        @out.puts "        #{digests.first(3).join(' ')}#{suffix}"
+      end
+
       # Mutants on one line share the printed evidence when it names the
       # same tests: the covering-test list is compared as a set (#502), so
       # one line's mutants no longer reprint an identical block only because
@@ -79,6 +105,8 @@ module Saboteur
                  end
         text = "      #{@palette.paint(:red, '-')} #{result.mutation.operator} " \
                "#{change} #{result.digest}"
+        label = @classifier.label(result)
+        text += @palette.paint(:cyan, " [#{label}]") if label
         text += " (ignored: #{result.ignored})" if result.ignored
         @out.puts text
         hint(result)
@@ -100,20 +128,20 @@ module Saboteur
       # killers first, the order the run used. Line coverage can overstate which
       # tests exercise the line, so the list is a lead, not proof.
       def passing_tests(result)
-        tests = result.covered_by
+        tests_line(result.covered_by, result.reused?)
+      end
+
+      def tests_line(tests, reused)
         return if tests.empty?
 
         @out.puts "      #{tests.size} #{tests.one? ? 'test' : 'tests'} covered this line and " \
-                  "#{passed_phrase(result)} (the missing check may belong in one of them):"
+                  "#{reused ? 'passed in an earlier run (--incremental)' : 'still passed'} " \
+                  "(the missing check may belong in one of them):"
         tests.first(MAX_PASSING_TESTS).each { |name| @out.puts "        #{name}" }
         more = tests.size - MAX_PASSING_TESTS
         @out.puts "        ... #{more} more in the JSON report (coveredBy)" if more.positive?
       end
 
-      def passed_phrase(result)
-        result.reused? ? "passed in an earlier run (--incremental)" : "still passed"
-      end
-
       # In diff mode: the changed lines this mutant touches.
       def changed_lines(report, path, result)
         lines = report.changed_lines_for(result)

data/lib/saboteur/reporter/terminal.rb

@@ -18,8 +18,9 @@ module Saboteur
       MAX_ERRORS = 10
       MAX_PASSING_TESTS = SurvivorList::MAX_PASSING_TESTS
 
-      def initialize(out, verbose: false, color: :auto, replay_command: nil)
+      def initialize(out, verbose: false, color: :auto, replay_command: nil, all_mutants: false)
         @out = SafeOut.new(out)
+        @all_mutants = all_mutants
         @verbose = verbose
         @palette = Palette.for(out, mode: color)
         @score_table = ScoreTable.new(@out, @palette)
@@ -149,7 +150,7 @@ module Saboteur
                            'errors, resource limits and skips excluded'
                        end}"
         end
-        report.skip_reasons.each { |reason, count| @out.puts "skipped: #{reason}: #{count}" }
+        report.skip_reasons.each { |reason, count| @out.puts skip_reason_line(reason, count) }
         reused = report.results.count(&:reused?)
         @out.puts "reused #{reused} of #{report.results.size} verdicts from earlier runs (--incremental)" if
           reused.positive?
@@ -237,10 +238,19 @@ module Saboteur
         end
       end
 
+      # "no coverage" names two different things (#1070): subjects no test
+      # runs at all, and mutant locations inside covered methods that no
+      # test reaches. Say which is which; every other reason prints as-is.
+      def skip_reason_line(reason, count)
+        reason == "no coverage" ? "mutant locations not reached: #{count}" : "skipped: #{reason}: #{count}"
+      end
+
+      def skipped_subject_line(reason, count)
+        reason == "no coverage" ? "methods never run by tests: #{count}" : "skipped subjects: #{reason}: #{count}"
+      end
+
       def skipped_subjects(report)
-        report.skipped_subjects.values.tally.each do |reason, count|
-          @out.puts "skipped subjects: #{reason}: #{count}"
-        end
+        report.skipped_subjects.values.tally.each { |reason, count| @out.puts skipped_subject_line(reason, count) }
         report.skipped_subjects.each do |subject, reason|
           @out.puts "  #{subject.id} #{relative(subject.file, report.root)}:#{subject.start_line}: #{reason}"
         end
@@ -350,7 +360,7 @@ module Saboteur
       end
 
       def survivors(report)
-        SurvivorList.new(@out, @palette).call(report, ranked_survivors(report))
+        SurvivorList.new(@out, @palette, all_mutants: @all_mutants).call(report, ranked_survivors(report))
         @out.puts unless report.survivors.empty?
       end
 

data/lib/saboteur/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module Saboteur
-  VERSION = "0.9.0"
+  VERSION = "0.10.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: saboteur
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.10.0
 platform: ruby
 authors:
 - Vamsi Pavan Mahesh Gunturu
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-10-20 00:00:00.000000000 Z
+date: 2026-10-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: prism
@@ -183,9 +183,11 @@ files:
 - lib/saboteur/mutation_source/chain_removal.rb
 - lib/saboteur/mutation_source/condition_negation.rb
 - lib/saboteur/mutation_source/constant_literals.rb
+- lib/saboteur/mutation_source/copy_replacement.rb
 - lib/saboteur/mutation_source/edit.rb
 - lib/saboteur/mutation_source/element_removal.rb
 - lib/saboteur/mutation_source/endpoint_replacement.rb
+- lib/saboteur/mutation_source/ensure_removal.rb
 - lib/saboteur/mutation_source/entry_edits.rb
 - lib/saboteur/mutation_source/filter_replacement.rb
 - lib/saboteur/mutation_source/hazard_guard.rb