saboteur 0.11.1 → 0.12.0

data/lib/saboteur/engine/subject_selection.rb

@@ -169,6 +169,11 @@ module Saboteur
           return missed.map { |pattern| missed_pattern_message(pattern) }.join("; ")
         end
 
+        if @config["since"]
+          return "--subject #{missed.join(', ')} matches no subject in the --since #{@config['since']} " \
+                 "diff scope (the scope limits the search to changed files; drop --since or pass --all)"
+        end
+
         "--subject #{missed.join(', ')} matches no subject (patterns are names like " \
           "Klass, Klass#meth or Klass.meth, not globs)"
       end
@@ -180,6 +185,11 @@ module Saboteur
         macro = attribute_macro_for(pattern)
         return "--subject #{pattern} is defined by #{macro} and has no body to mutate" if macro
 
+        if @config["since"]
+          return "--subject #{pattern} matches no subject in the --since #{@config['since']} diff scope " \
+                 "(the scope limits the search to changed files)"
+        end
+
         "fix the --subject pattern \"#{pattern}\": it matches no subject (patterns are names like " \
           "Klass, Klass#meth or Klass.meth, not globs)"
       end

data/lib/saboteur/engine.rb

@@ -4,6 +4,7 @@
 require "fileutils"
 require "json"
 require_relative "replay"
+require_relative "text"
 require_relative "mutation_source/hazard_guard"
 require_relative "baseline/run_evidence"
 require_relative "engine/early_stop_recording"
@@ -116,6 +117,24 @@ module Saboteur
       warnings + map.duplicate_keys(path).map { |key| "duplicate custom map key #{key}: Ruby keeps the last" }
     end
 
+    # The map this run selected tests from: survivor presentation compares
+    # it against the cached whole-suite map (review C1).
+    def run_coverage_map
+      @coverage_store&.fetched_map
+    end
+
+    # The cached whole-suite map on this tree, for survivor presentation
+    # in scoped runs; nil when caching is off or no full build ran (review C1).
+    def whole_suite_coverage_map
+      @coverage_store&.whole_suite_map
+    end
+
+    # False when caching is off, where no coverage build can ever leave a
+    # whole-suite map to consult, so advising one would be wrong (review C1).
+    def whole_suite_map_lookup?
+      config["cache"] ? true : false
+    end
+
     private
 
     # Inferred test selection, the default since 0.7.0: scope the run to the
@@ -180,7 +199,8 @@ module Saboteur
                  matrix: config["matrix"], inline_suppressions: @diagnostics.inline_suppressions,
                  operator_policy: config.operator_policy, discovery_failures: @diagnostics.discovery_failures,
                  test_command: config["test_command"], reuse_label: reuse_label, since: config["since"],
-                 shard: @shard, memory: @memory_report, referenced: @guessed_referenced || {})
+                 shard: @shard, memory: @memory_report, referenced: @guessed_referenced || {},
+                 phase_timings: @phase_timings)
     end
 
     def complete_evidence(results, subjects)
@@ -207,14 +227,13 @@ module Saboteur
 
     def mutate(subjects, files, integration, scope, ignore_list, load_lines: {}, load_methods: {})
       store = coverage_store(integration, load_lines, load_methods)
-      full_passes = config["baseline_passes"] + (store.reusable?(files) ? 0 : 1)
-      warn_unscoped(integration, full_passes)
-      announce_quiet_start(store, files)
-      check_baseline(integration, full_passes)
+      map_reusable = store.reusable?(files)
+      full_passes = config["baseline_passes"] + (map_reusable ? 0 : 1)
+      baseline_preflight(store, integration, files, full_passes)
       refuse_unaffordable_coverage_build(store, files)
       return [] if abandon_for_budget?(subjects)
 
-      map = store.fetch(files)
+      map, map_seconds = timed_map_fetch(store, files)
       inform_about_run(subjects, map)
       cache = result_cache(map, files)
       scheduler = scheduler_for(map, integration, cache)
@@ -227,13 +246,41 @@ module Saboteur
       # mutant when serial. Pack the heap now that the map and candidates
       # are retained, to reduce later copying of shared pages.
       Execution::ForkReadiness.prepare_heap
-      results = run_and_confirm(runnable_subjects, runnable_lists, scheduler, cache, ignore_list)
+      results = run_and_confirm_timed(runnable_subjects, runnable_lists, scheduler, cache, ignore_list,
+                                      map_cached: map_reusable, map_seconds:)
       cache&.save
       results
     rescue BudgetPhaseTimeout => e
       budget_phase_stop(e, subjects)
     end
 
+    # The map phase's monotonic split, for the speed footer.
+    def timed_map_fetch(store, files)
+      started = monotonic
+      [store.fetch(files), monotonic - started]
+    end
+
+    # Baseline phase: announce, then verify the unchanged tree passes.
+    def baseline_preflight(store, integration, files, full_passes)
+      warn_unscoped(integration, full_passes)
+      announce_quiet_start(store, files)
+      check_baseline(integration, full_passes)
+    end
+
+    # The mutant phase plus the run's three disjoint timing intervals
+    # (baseline inside check_baseline, map build, mutants) and the worker
+    # count, recorded for the terminal's speed footer.
+    def run_and_confirm_timed(subjects, lists, scheduler, cache, ignore_list, map_cached:, map_seconds:)
+      started = monotonic
+      results = run_and_confirm(subjects, lists, scheduler, cache, ignore_list)
+      # @baseline_elapsed is a Float from initialize on, so no fallback is needed.
+      @phase_timings = PhaseTimings.new(baseline_seconds: @baseline_elapsed,
+                                        map_seconds:, map_cached:,
+                                        mutants_seconds: monotonic - started,
+                                        jobs: config["jobs"])
+      results
+    end
+
     # The candidate run plus the opt-in post-run confirmation pass (#1063):
     # confirmation runs after the last result, before the verdict cache is
     # written, so a confirmed kill overwrites the survivor verdict the run
@@ -312,16 +359,27 @@ module Saboteur
                                     tests: map.tests.size, cached: @map_cached)
         @diagnostics.quiet_inference(@quiet_spec_count)
       else
-        @diagnostics.inform("#{subjects.size} subjects, #{map.tests.size} tests in coverage map")
+        @diagnostics.inform("#{Text.counted(subjects.size, 'subject')}, " \
+                            "#{Text.counted(map.tests.size, 'test')} in coverage map")
       end
       ThreadWarnings.warn(@diagnostics, rails: config["rails"])
     end
 
+    # This run's map is the whole-suite map only when nothing scoped it:
+    # no --since, no subjects, and tests either unset or inferred over every
+    # included file (never an explicit --test list) (review C1).
+    def whole_suite_run?
+      config["since"].nil? && config["subjects"].empty? &&
+        (config["tests"].empty? || !@guessed_tests.nil?)
+    end
+
     def coverage_store(integration, load_lines, load_methods = {})
-      CoverageStore.new(config: config, integration: integration, hooks: hooks, load_lines:, load_methods:,
-                        supervisor: supervisor(memory_factor: 4), diagnostics: @diagnostics,
-                        timeout_cap: method(:budget_capped_timeout),
-                        parts: config["coverage_parts"])
+      @coverage_store ||=
+        CoverageStore.new(config: config, integration: integration, hooks: hooks, load_lines:, load_methods:,
+                          whole_suite_run: whole_suite_run?,
+                          supervisor: supervisor(memory_factor: 4), diagnostics: @diagnostics,
+                          timeout_cap: method(:budget_capped_timeout),
+                          parts: config["coverage_parts"])
     end
 
     def check_baseline(integration, full_passes)

data/lib/saboteur/help.rb

@@ -152,6 +152,17 @@ module Saboteur
                    ["Diff, replay command and ignore template for one mutant",
                     "saboteur survivors .saboteur/report.json --show 1a2b3c4d5e6f7a8b"]]
       ),
+      Command.new(
+        name: "explain",
+        summary: "Explain one mutation operator: definition, example and kill guidance",
+        description: "Prints what one operator does, a before/after example of the mutation, the test " \
+                     "shapes that let it survive, and the assertion that kills it. Covers every operator " \
+                     "the registry can emit.",
+        takes_options: false,
+        exit_codes: { 0 => "Explanation printed.",
+                      2 => "Unknown or missing operator name; the valid names are listed." },
+        examples: [["Why did this mutant survive?", "saboteur explain operand_replacement"]]
+      ),
       Command.new(
         name: "badge",
         summary: "Print a shields.io endpoint badge over the opt-in score history",

data/lib/saboteur/ignore_list.rb

@@ -125,7 +125,7 @@ module Saboteur
     # unscoped_digests (subject id => every digest generated before a diff
     # scope cut) keeps a scoped run from calling a scoped-out entry stale
     # (#284).
-    def apply(results, unscoped_digests: nil)
+    def apply(results, subjects: nil, unscoped_digests: nil, full_run: false)
       seen = {}
       results.each do |result|
         key = [result.subject.id, result.digest]
@@ -139,7 +139,8 @@ module Saboteur
         result.triage_reason = entry.reason
         result.ignored = entry.reason if entry.state != "todo"
       end
-      duplicate_warnings + stale_warnings(results, seen, unscoped_digests)
+      duplicate_warnings + stale_warnings(results, seen, unscoped_digests) +
+        missing_subject_warnings(results, subjects, full_run: full_run)
     end
 
     private
@@ -159,6 +160,25 @@ module Saboteur
              .map { |(subject, mutation), _| "duplicate ignore entry #{subject} #{mutation}: the last entry wins" }
     end
 
+    # A full run examines every in-scope subject, so an entry whose subject
+    # never appears points at code that was renamed or removed - say so, but
+    # only then: a scoped (--since/--subject) run cannot tell "renamed" from
+    # "not in this diff" (#1206). The run's subject list is the source of
+    # truth when given: an examined subject with no results (uncovered, or
+    # nothing mutable left) is not missing.
+    def missing_subject_warnings(results, subjects, full_run:)
+      return [] unless full_run
+
+      examined = (subjects || results).to_set { |item| item.respond_to?(:id) ? item.id : item.subject.id }
+      entries.reject { |entry| examined.include?(entry.subject) }
+             .map { |entry| missing_subject_message(entry) }
+    end
+
+    def missing_subject_message(entry)
+      "stale ignore entry #{entry.subject} #{entry.mutation}: subject not found " \
+        "(renamed, removed, or its file is excluded?) - remove the entry or fix the subject name"
+    end
+
     def stale_message(entry)
       "stale ignore entry #{entry.subject} #{entry.mutation}: no such mutation " \
         "- remove the entry or refresh its digest (saboteur survivors --show)"

data/lib/saboteur/mutation_source/builtin.rb

@@ -13,6 +13,7 @@ require_relative "pair_removal"
 require_relative "element_removal"
 require_relative "endpoint_replacement"
 require_relative "operator_registry"
+require_relative "operator_explain"
 require_relative "range_replacement"
 require_relative "operator_assignment"
 require_relative "condition_negation"

data/lib/saboteur/mutation_source/operator_explain.rb

@@ -0,0 +1,181 @@
+# SPDX-License-Identifier: MIT
+# frozen_string_literal: true
+
+require_relative "operator_examples"
+require_relative "operator_registry"
+
+module Saboteur
+  module MutationSource
+    # Curated text behind `saboteur explain NAME`. The definition and the
+    # example stay shared with --list-operators (one wording source); the
+    # survival and kill hints below are the only text owned here. Every
+    # registry operator needs an entry: the coverage spec fails the build
+    # when one ships without it.
+    module OperatorExplain
+      Entry = Data.define(:name, :definition, :example, :survives, :kill)
+
+      GUIDANCE = {
+        "body_nil" => {
+          survives: "the method is called for side effects and no test asserts the return value.",
+          kill: "an assertion on the exact return value, or on a caller behaviour that depends on it."
+        },
+        "body_true" => {
+          survives: "tests never check the predicate outcome, or only take the path true already forces.",
+          kill: "an example whose input makes the predicate false, asserting that path is taken."
+        },
+        "body_false" => {
+          survives: "tests never check the predicate outcome, or only take the path false already forces.",
+          kill: "an example whose input makes the predicate true, asserting that path is taken."
+        },
+        "body_raise" => {
+          survives: "tests stub or skip the method, or wrap the call in a broad rescue.",
+          kill: "any test that calls the method and lets it complete; the raise fails that example."
+        },
+        "comparison" => {
+          survives: "tests never use values at the boundary the change moves, such as equal values for < vs <=.",
+          kill: "a boundary example: the equal case, or the two values just either side of the operator."
+        },
+        "arithmetic" => {
+          survives: "tests assert the result loosely (type, presence, sign) instead of its exact value.",
+          kill: "an assertion on the exact computed value with operands where the two operators differ."
+        },
+        "boolean_logic" => {
+          survives: "tests never exercise the dropped operand deciding the outcome on its own.",
+          kill: "one example per operand where that operand alone flips the result, asserting each outcome."
+        },
+        "condition_true" => {
+          survives: "tests only exercise the branch the forced condition takes.",
+          kill: "an example with a falsy input, asserting the else branch still runs."
+        },
+        "condition_false" => {
+          survives: "tests only exercise the branch the forced condition takes.",
+          kill: "an example with a truthy input, asserting the then branch still runs."
+        },
+        "negation_removal" => {
+          survives: "tests assert loosely, or never cover the input the negation inverts.",
+          kill: "assert the behaviour for both a truthy and a falsy input through the public API."
+        },
+        "literal_number" => {
+          survives: "the literal flows into nothing a test asserts, or every fixture value works for both.",
+          kill: "an assertion on the exact value the literal feeds (a total, a limit, an index)."
+        },
+        "or_assign" => {
+          survives: "tests only cover the nil or false case, where both forms assign.",
+          kill: "an example where the variable is already truthy and must keep its value."
+        },
+        "and_assign" => {
+          survives: "tests only cover the truthy case, where both forms assign.",
+          kill: "an example where the variable is falsy and must stay untouched."
+        },
+        "safe_navigation" => {
+          survives: "the receiver is never nil in any covering test.",
+          kill: "an example with a nil receiver asserting nil comes back instead of NoMethodError."
+        },
+        "statement_removal" => {
+          survives: "the removed statement's effect is never observed: an unasserted side effect or return.",
+          kill: "assert the side effect (a spy, a state change) or the value the statement produced."
+        },
+        "copy_replacement" => {
+          survives: "tests never mutate the returned object, so the aliasing goes unnoticed.",
+          kill: "mutate what the method returns and assert the original is unchanged (or assert a copy)."
+        },
+        "filter_replacement" => {
+          survives: "tests assert loosely, or the fixture collection is empty or all one kind.",
+          kill: "assert the exact surviving elements of a mixed collection, in order."
+        },
+        "literal_string" => {
+          survives: "no test asserts the string's content, only that something was returned.",
+          kill: "an exact string equality assertion on the value that carries the literal."
+        },
+        "literal_boolean" => {
+          survives: "the boolean is never asserted, or both values pass the covering assertions.",
+          kill: "an example whose expected behaviour flips with the boolean."
+        },
+        "argument_swap" => {
+          survives: "tests use equal or interchangeable arguments, or assert the result loosely.",
+          kill: "asymmetric arguments with an assertion on the exact result order."
+        },
+        "argument_removal" => {
+          survives: "the removed argument changes nothing the covering tests observe.",
+          kill: "a case where that argument changes the result, asserted exactly."
+        },
+        "pair_removal" => {
+          survives: "tests never read the removed key, directly or through a consumer.",
+          kill: "assert the value stored under the removed key, or the whole hash."
+        },
+        "element_removal" => {
+          survives: "tests never exercise the removed element of the array.",
+          kill: "an example per element whose behaviour changes when that element is missing."
+        },
+        "endpoint_replacement" => {
+          survives: "fixture collections have one element, or the wrong end is never asserted.",
+          kill: "a multi-element collection with an assertion on exactly which end comes back."
+        },
+        "chain_removal" => {
+          survives: "in every tested case the skipped call returns an equivalent value.",
+          kill: "a case where the removed call changes the value, asserted exactly."
+        },
+        "range" => {
+          survives: "tests never use the endpoint the exclusive range drops.",
+          kill: "an example whose input is the boundary value, asserting it is included."
+        },
+        "operator_assignment" => {
+          survives: "tests check the variable changed, not its exact new value.",
+          kill: "assert the exact value after the assignment, where += and -= disagree."
+        },
+        "condition_negation" => {
+          survives: "tests only cover the side of the predicate the negation keeps.",
+          kill: "assert both branches with inputs on each side of the predicate."
+        },
+        "method_swap" => {
+          survives: "tests assert loosely, or min and max coincide in every fixture.",
+          kill: "a fixture where the two methods differ, asserting the exact expected one."
+        },
+        "operand_replacement" => {
+          survives: "tests assert the result loosely (present, positive, non-nil) or never exercise " \
+                    "the removed operand.",
+          kill: "an assertion on the exact value through the public API, with inputs where the " \
+                "removed operand changes the result."
+        },
+        "interpolation_removal" => {
+          survives: "no test asserts the full interpolated content of the string.",
+          kill: "an exact string assertion with a known value in the interpolation."
+        },
+        "jump_value" => {
+          survives: "callers ignore the returned value, or tests never take that return path.",
+          kill: "an example that takes the early return and asserts the exact value it hands back."
+        },
+        "rescue_removal" => {
+          survives: "tests never raise the error the handler rescues.",
+          kill: "an example raising that error, asserting the handler's fallback behaviour."
+        },
+        "ensure_removal" => {
+          survives: "the cleanup's effect is never observed on the tested paths.",
+          kill: "assert the cleanup ran (resource released, flag reset), including on the error path."
+        },
+        "when_removal" => {
+          survives: "tests never hit the removed branch of the case.",
+          kill: "one example per when branch, asserting its exact outcome."
+        },
+        "unary_removal" => {
+          survives: "fixtures use zero or symmetric values, or tests assert loosely.",
+          kill: "an assertion on the exact signed or complemented value with a non-trivial input."
+        },
+        "regex_replacement" => {
+          survives: "every test input matches under both the original and the loosened regex.",
+          kill: "an input the anchor or quantifier excludes, asserting it is rejected."
+        }
+      }.freeze
+
+      # nil for an unknown name; the command turns that into the exit-2 error.
+      def self.for(name)
+        return unless OperatorRegistry::DESCRIPTIONS.key?(name)
+
+        guidance = GUIDANCE.fetch(name)
+        Entry.new(name:, definition: OperatorRegistry::DESCRIPTIONS.fetch(name),
+                  example: OperatorExamples::EXAMPLES.fetch(name),
+                  survives: guidance.fetch(:survives), kill: guidance.fetch(:kill))
+      end
+    end
+  end
+end

data/lib/saboteur/reporter/agent_commands.rb

@@ -45,14 +45,30 @@ module Saboteur
 
           # Replay one survivor by digest in the same selection. capped: false
           # skips the protocol byte cap, for callers that print to a terminal.
-          def replay(provenance, digest, capped: true)
-            words = ["saboteur", "run", "--id", digest, *selection(provenance, replay: true), "--seed",
-                     provenance.seed.to_s]
+          # report: narrows the replay to the mutant's covering spec files
+          # instead of the run's full inferred list (#1148).
+          def replay(provenance, digest, capped: true, report: nil)
+            words = ["saboteur", "run", "--id", digest,
+                     *selection(provenance, replay: true, tests: report && covering_files(report, digest)),
+                     "--seed", provenance.seed.to_s]
             finish(words, provenance, capped: capped)
           end
 
           private
 
+          # A replay needs only the specs that cover the mutant, not every
+          # inferred file (#1148): covered_by holds RSpec ids like
+          # "./spec/fee_spec.rb[1:2]", so strip the example suffix. nil when
+          # the survivor has no covering ids - then the whole selection
+          # stays, since dropping it would widen the replay to inference.
+          def covering_files(report, digest)
+            result = report.results.find { |entry| entry.digest == digest }
+            return unless result
+
+            files = result.covered_by.filter_map { |id| id[%r{\A\.?/?(.+?\.rb)\[}, 1] }.uniq
+            files unless files.empty?
+          end
+
           def finish(words, provenance, capped: true)
             words += ["--", *provenance.sources] unless provenance.sources.empty?
             command = Shellwords.join(words)
@@ -93,13 +109,14 @@ module Saboteur
 
           # Whole-suite scope is a bare --all, only when no tests resolved;
           # --all never combines with --test.
-          def selection(provenance, replay: false)
+          def selection(provenance, replay: false, tests: nil)
+            tests ||= provenance.tests
             words = []
             words.push("--config", provenance.config_path) if provenance.config_path
             words.push("--since", provenance.ref) if provenance.ref
             provenance.subjects.each { |subject| words.push("--subject", subject) }
-            words << "--all" if provenance.settings[:all] && provenance.tests.empty?
-            words.push(*test_words(provenance.tests))
+            words << "--all" if provenance.settings[:all] && tests.empty?
+            words.push(*test_words(tests))
             words.concat(setting_words(provenance, replay: replay))
             words.concat(mode_words(provenance))
             words.push("--id", provenance.digest) if provenance.digest && !replay

data/lib/saboteur/reporter/agent_incomplete.rb

@@ -40,8 +40,7 @@ module Saboteur
             add(reasons, "mutant_cap", omitted_by_cap(report), "mutants omitted by max_mutants_per_method")
             add(reasons, "errors", report.counts[:error], "mutants errored; their verdict did not hold up")
             add(reasons, "resource_limit", report.counts[:resource_limit], "mutants hit the memory or process cap")
-            add(reasons, "unverified", report.counts[:unverified],
-                "mutants the --max-duration budget left unverified; their kills are not confirmed")
+            unverified_reasons(reasons, report)
             discovery_failures(reasons, report)
             early_stop_reason(reasons, report)
             inline_scope(reasons, report)
@@ -70,6 +69,14 @@ module Saboteur
                 "included untracked files could not be read; their subjects were not covered")
           end
 
+          def unverified_reasons(reasons, report)
+            flaky = report.results.count(&:flaky?)
+            add(reasons, "unverified", report.counts[:unverified] - flaky,
+                "mutants the --max-duration budget left unverified; their kills are not confirmed")
+            add(reasons, "flaky", flaky,
+                "mutants gave a different verdict on the --flaky-check reordered rerun; they are unverified")
+          end
+
           def early_stop_reason(reasons, report)
             stop = report.early_stop
             return unless stop

data/lib/saboteur/reporter/agent_summary.rb

@@ -123,7 +123,8 @@ module Saboteur
             steps = {}
             add_command(steps, :rerun, Commands.rerun(provenance))
             first = Findings.build(report)[:survivors].first
-            add_command(steps, :replay, Commands.replay(provenance, first[:digest])) if first
+            # report: narrows the replay to covering specs, as on the run screen (#1148).
+            add_command(steps, :replay, Commands.replay(provenance, first[:digest], report: report)) if first
             steps[:fullReport] = provenance.json_report if short_path?(provenance.json_report)
             steps
           end

data/lib/saboteur/reporter/default_findings.rb

@@ -0,0 +1,83 @@
+# SPDX-License-Identifier: MIT
+# frozen_string_literal: true
+
+require_relative "mutation_text"
+require_relative "survivor_classification"
+require_relative "survivor_list"
+
+module Saboteur
+  module Reporter
+    # Default whole-project findings (D1): the one-line-per-finding list the
+    # --quiet report popularised, then full blocks for the top
+    # SurvivorRanking picks only, then a dim closer naming the rest. A
+    # --since run or --details keeps the full block list.
+    class DefaultFindings
+      # Blocks a default run expands; the closer counts what is left out.
+      TOP_BLOCKS = 3
+
+      # Two lines: the fixed text alone is 87 columns at rest; keep it inside 80.
+      CLOSER = "... %<more>d more %<findings>s - saboteur survivors .saboteur/report.json,\nor re-run with --details"
+
+      def initialize(out, palette, all_mutants: false, details: false,
+                     whole_suite_map: SurvivorList::NO_WHOLE_SUITE_LOOKUP, run_map: nil)
+        @out = out
+        @palette = palette
+        @all_mutants = all_mutants
+        @details = details
+        @whole_suite_map = whole_suite_map
+        @run_map = run_map
+      end
+
+      def call(report, ranked)
+        live = ranked.select(&:unignored_survivor?)
+        return full(report, ranked) if @details || report.diff? || live.empty?
+
+        @out.puts(list_lines(report, live))
+        @out.puts
+        SurvivorList.new(@out, @palette, all_mutants: @all_mutants, limit: TOP_BLOCKS,
+                                         whole_suite_map: @whole_suite_map, run_map: @run_map).call(report, ranked)
+        more = finding_count(report, live) - TOP_BLOCKS
+        findings = "finding#{'s' unless more == 1}"
+        @out.puts @palette.paint(:dim, format(CLOSER, more:, findings:)) if more.positive?
+        @out.puts
+      end
+
+      private
+
+      # --details and --since runs: every finding expanded, exactly the
+      # pre-D1 default.
+      def full(report, ranked)
+        SurvivorList.new(@out, @palette, all_mutants: @all_mutants,
+                                         whole_suite_map: @whole_suite_map, run_map: @run_map).call(report, ranked)
+        @out.puts unless report.survivors.empty?
+      end
+
+      # The quiet list's line shape: path:line subject, label and digest,
+      # sibling mutants on the statement collapsed to a count (#1126/#1133).
+      def list_lines(report, live)
+        groups(report, live).map do |(path, line, subject_id), results|
+          first, *rest = results
+          label = SurvivorClassification.label(first)
+          text = "#{path}:#{line} #{subject_id}#{" [#{label}]" if label} - #{first.digest}"
+          rest.any? ? "#{text} (+#{rest.size} more)" : text
+        end
+      end
+
+      # --all-mutants gives every survivor its own block, so the closer
+      # counts mutants rather than statements.
+      def finding_count(report, live)
+        @all_mutants ? live.size : groups(report, live).size
+      end
+
+      def groups(report, live)
+        live.group_by do |result|
+          [relative(result.subject.file, report.root), MutationText.line(result), result.subject.id]
+        end
+      end
+
+      def relative(file, root)
+        file.delete_prefix("#{root}/")
+      end
+    end
+  end
+end