saboteur 0.4.0 → 0.6.0

data/lib/saboteur/reporter/score_table.rb

@@ -0,0 +1,57 @@
+# SPDX-License-Identifier: MIT
+# frozen_string_literal: true
+
+require_relative "../score"
+
+module Saboteur
+  module Reporter
+    # One row per source file, worst score first, with survivor counts, and a
+    # one-line legend for the statuses in the summary.
+    class ScoreTable
+      MAX_ROWS = 15
+      LEGEND = ["killed: a test failed  survived: every selected test passed",
+                "timeout: exceeded its deadline",
+                "error, resource limit, skipped and the other statuses: not scored"].freeze
+
+      def initialize(out, palette)
+        @out = out
+        @palette = palette
+      end
+
+      def call(report)
+        rows = rows(report)
+        return if rows.size < 2
+
+        @out.puts "\nScore by file (worst first):"
+        width = rows.first(MAX_ROWS).map { |row| row[:path].length }.max
+        rows.first(MAX_ROWS).each { |row| @out.puts line(row, width) }
+        @out.puts "  ... #{rows.size - MAX_ROWS} more files" if rows.size > MAX_ROWS
+      end
+
+      def legend
+        LEGEND.each_with_index.map do |text, index|
+          @palette.paint(:dim, "#{index.zero? ? 'legend: ' : '        '}#{text}")
+        end.join("\n")
+      end
+
+      private
+
+      def rows(report)
+        by_file = report.results.group_by { |result| result.subject.file }
+        rows = by_file.map { |file, results| row(report, file, results) }
+        rows.reject { |row| row[:tested].zero? }.sort_by { |row| [row[:value], -row[:survivors], row[:path]] }
+      end
+
+      def row(report, file, results)
+        breakdown = Score.of(results)
+        { path: file.delete_prefix("#{report.root}/"), value: breakdown.value,
+          survivors: results.count(&:unignored_survivor?), tested: breakdown.tested }
+      end
+
+      def line(row, width)
+        score = format("%5.1f %%", row[:value] * 100)
+        "  #{row[:path].ljust(width)}  #{score}  #{row[:survivors]} survivor#{'s' unless row[:survivors] == 1}"
+      end
+    end
+  end
+end

data/lib/saboteur/reporter/stryker.rb

@@ -35,20 +35,32 @@ module Saboteur
           files: files,
           testFiles: test_files(test_ids),
           skippedSubjects: skipped_subjects(report),
+          earlyStop: early_stop(report),
           rejectedKills: report.rejected_kills,
           warnings: report.warnings,
           framework: { name: "saboteur", version: VERSION },
-          saboteur: { findings: Findings.build(report), scores: scores(report) }
-                     .merge(exit_cause ? { exitCause: exit_cause } : {})
+          saboteur: { findings: Findings.build(report), scores: scores(report),
+                      inlineSuppressions: inline_audit(report) }
+                     .merge(operatorPolicy: report.operator_policy).merge(exit_cause ? { exitCause: exit_cause } : {})
         }.merge(report.seed ? { config: { seed: report.seed } } : {})
       end
 
+      def self.inline_audit(report)
+        report.inline_suppressions.map { |entry| entry.merge(file: relative(entry[:file], report.root)) }
+      end
+
       # Score with its assertion and crash shares, for all mutants and without
       # the whole-body ones (body_nil, body_true, body_false, body_raise).
       def self.scores(report)
         { all: report.score_breakdown.to_h, withoutWholeBodyMutants: report.fine_score_breakdown.to_h }
       end
 
+      # nil for a run that covered its whole selection.
+      def self.early_stop(report)
+        stop = report.early_stop
+        stop && { reason: stop.reason, unreachedSubjects: stop.unreached }
+      end
+
       def self.skipped_subjects(report)
         report.skipped_subjects.map do |subject, reason|
           { subject: subject.id, file: relative(subject.file, report.root), line: subject.start_line, reason: reason }
@@ -101,7 +113,10 @@ module Saboteur
         when :survived then "Survived"
         when :timeout then "Timeout"
         when :error, :resource_limit then "RuntimeError"
-        when :skipped then result.reason == "no coverage" ? "NoCoverage" : "Ignored"
+        when :skipped then result.reason&.start_with?("no coverage") ? "NoCoverage" : "Ignored"
+        # The schema has no status for "ran, but no test can observe a
+        # change here". Ignored with the reason is the honest mapping.
+        when :ran_at_load, :unreachable then "Ignored"
         end
       end
 

data/lib/saboteur/reporter/survivor_hints.rb

@@ -0,0 +1,68 @@
+# SPDX-License-Identifier: MIT
+# frozen_string_literal: true
+
+module Saboteur
+  module Reporter
+    # Suggests a check that might kill a surviving mutant, by operator. It does
+    # not say what is missing: the survivor can also be an equivalent mutant.
+    module SurvivorHints
+      BY_OPERATOR = {
+        "comparison" => "try an example at the boundary: equal values, or values one apart",
+        "arithmetic" => "try asserting the exact computed number",
+        "boolean_logic" => "try an example where each side of the condition alone decides the result",
+        "negation_removal" => "try an example where the negated value changes the result",
+        "literal_number" => "try asserting something that depends on this number",
+        "literal_boolean" => "try an example that depends on this true/false value",
+        "literal_string" => "try asserting on this text",
+        "statement_removal" => "try asserting the effect of this statement",
+        "or_assign" => "try an example where the variable is already set (||= vs =)",
+        "safe_navigation" => "try an example where the receiver is nil",
+        "argument_removal" => "try have_received(...).with(...), or assert a result that depends on this argument",
+        "pair_removal" => "try have_received(...).with(...), or assert the hash content under this key",
+        "endpoint_replacement" => "try a collection with 2 or more elements, to tell first from last",
+        "filter_replacement" => "try items that match and items that do not, to tell select from reject"
+      }.freeze
+
+      COARSE = "try asserting this method's result or its effect"
+
+      # Printed once after the survivors: a hint is a place to look, not a diagnosis.
+      CAVEAT = "Hints are suggestions, not diagnoses: a survivor can also be an equivalent mutant, or a change " \
+               "the selected tests cannot observe."
+
+      # Comparison operator swaps where the two operators give the same answer
+      # except in one named case, so a test that hits that case can tell them
+      # apart. Anything else gets the plain text hint.
+      EQUAL_CASE = [%w[< <=], %w[> >=]].map(&:to_set).freeze
+      UNEQUAL_CASE = [%w[< >], %w[<= >=]].map(&:to_set).freeze
+
+      module_function
+
+      def for(operator, coarse: false)
+        BY_OPERATOR.fetch(operator) { coarse ? COARSE : nil }
+      end
+
+      # The hint as data for `--agent`: { kind:, text: } and, for a comparison
+      # swap, case: the relation between the two operands that separates the
+      # original from the mutant ("left == right"). It is where to look, not a
+      # promise that a test there will kill the mutant. nil when there is none.
+      def structured(operator:, original:, replacement:, coarse: false)
+        text = self.for(operator, coarse: coarse)
+        return unless text
+
+        operands = boundary_case(operator, original, replacement)
+        return { kind: "boundary", case: operands, text: text } if operands
+
+        { kind: coarse ? "method_result" : "assertion", text: text }
+      end
+
+      def boundary_case(operator, original, replacement)
+        return unless operator == "comparison"
+
+        pair = Set[original, replacement]
+        return "left == right" if EQUAL_CASE.include?(pair)
+
+        "left != right" if UNEQUAL_CASE.include?(pair)
+      end
+    end
+  end
+end

data/lib/saboteur/reporter/survivor_list.rb

@@ -0,0 +1,126 @@
+# SPDX-License-Identifier: MIT
+# frozen_string_literal: true
+
+require_relative "mutation_text"
+require_relative "survivor_hints"
+
+module Saboteur
+  module Reporter
+    # Survivors grouped by file, then method, then line. The source line and
+    # the tests that covered it are printed once; each mutation is one compact
+    # line: operator, original -> replacement, digest.
+    class SurvivorList
+      MAX_PASSING_TESTS = 5
+
+      def initialize(out, palette)
+        @out = out
+        @palette = palette
+      end
+
+      # Every survivor, in report order; the grouping keeps them readable.
+      def call(report, survivors)
+        return if survivors.empty?
+
+        @out.puts "Survivors (#{survivors.size}):"
+        survivors.group_by { |result| result.subject.file }.sort_by { |file, _| file }.each do |file, in_file|
+          file_section(report, relative(file, report.root), in_file)
+        end
+        @out.puts "\n#{@palette.paint(:dim, SurvivorHints::CAVEAT)}" if survivors.any? { |result| hint_for(result) }
+      end
+
+      private
+
+      def file_section(report, path, in_file)
+        @out.puts "\n#{@palette.paint(:bold, path)}"
+        in_file.group_by { |result| result.subject.id }.each do |subject_id, in_subject|
+          @out.puts "  #{subject_id}"
+          lines(report, path, in_subject)
+        end
+      end
+
+      def lines(report, path, in_subject)
+        in_subject.group_by { |result| MutationText.line(result) }.sort.each do |line, on_line|
+          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) }
+        end
+      end
+
+      # Mutants on one line share the printed evidence only when it is the
+      # same for all of them: covering tests (in order), reuse and changed
+      # lines can each differ per mutant, so each run of neighbours with the
+      # same tuple is one group and shares evidence above its own mutations.
+      # Evidence that repeats after another group is printed again, which
+      # keeps the ranked order.
+      def evidence_groups(report, on_line)
+        on_line.chunk { |result| [result.covered_by, result.reused?, report.changed_lines_for(result)] }
+               .map(&:last)
+      end
+
+      def evidence_group(report, path, group)
+        first = group.first
+        changed_lines(report, path, first)
+        passing_tests(first)
+        group.each { |result| mutation(result) }
+      end
+
+      def source_line(result, line)
+        result.subject.file_source.lines[line - 1].to_s.strip
+      end
+
+      def mutation(result)
+        text = "      #{@palette.paint(:red, '-')} #{result.mutation.operator} " \
+               "#{MutationText.original(result)} -> #{@palette.paint(:green, MutationText.replacement(result))} " \
+               "#{result.digest}"
+        text += " (ignored: #{result.ignored})" if result.ignored
+        @out.puts text
+        hint(result)
+      end
+
+      def hint(result)
+        text = hint_for(result)
+        @out.puts "        #{@palette.paint(:cyan, 'hint:')} #{text}" if text
+      end
+
+      def hint_for(result)
+        return nil if result.ignored
+
+        SurvivorHints.for(result.mutation.operator, coarse: result.mutation.coarse)
+      end
+
+      # The tests that ran with the mutant applied and still passed: the
+      # missing assertion belongs in one of them. They are listed likeliest
+      # 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
+        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):"
+        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)
+        return if lines.empty?
+
+        shown = lines.first(3).map { |line| "#{path}:#{line}" }.join(", ")
+        more = lines.size - 3
+        @out.puts "      changed #{lines.one? ? 'line' : 'lines'}: #{shown}#{" (+#{more} more)" if more.positive?}"
+      end
+
+      def relative(file, root)
+        file.delete_prefix("#{root}/")
+      end
+    end
+  end
+end

data/lib/saboteur/reporter/survivor_ranking.rb

@@ -0,0 +1,34 @@
+# SPDX-License-Identifier: MIT
+# frozen_string_literal: true
+
+module Saboteur
+  module Reporter
+    # Review priority, not a claim that a survivor is a real defect.
+    module SurvivorRanking
+      ORDERING = "coarse first, then more covering tests, larger edited-line span, " \
+                 "nearer changed lines, then file, line and digest"
+
+      def self.ordered(report, results)
+        results.sort_by { |result| key(report, result) }
+      end
+
+      def self.key(report, result)
+        [result.mutation.coarse ? 0 : 1, -result.covered_by.uniq.size, -edited_lines(result).size,
+         report.changed_line_distance(result) || Float::INFINITY,
+         result.subject.file.delete_prefix("#{report.root}/"), first_line(result), result.digest]
+      end
+
+      def self.first_line(result)
+        result.subject.line_of(result.mutation.edits.map(&:start_byte).min)
+      end
+
+      def self.edited_lines(result)
+        result.mutation.edits.flat_map do |edit|
+          first = result.subject.line_of(edit.start_byte)
+          last = result.subject.line_of([edit.end_byte - 1, edit.start_byte].max)
+          (first..last).to_a
+        end.uniq
+      end
+    end
+  end
+end

data/lib/saboteur/reporter/terminal.rb

@@ -1,35 +1,101 @@
 # SPDX-License-Identifier: MIT
 # frozen_string_literal: true
 
+require_relative "next_steps"
+require_relative "survivor_ranking"
+require_relative "palette"
+require_relative "score_table"
+require_relative "survivor_list"
+require_relative "test_matrix"
+
 module Saboteur
   module Reporter
-    # Plain-text summary: counts per status, score, timings, skip reasons,
-    # errors, then a unified diff for each survivor.
+    # Plain-text report: survivors first (grouped by file, method and line),
+    # then errors and notes, then a short summary last so it stays on screen.
+    # Debug statistics (score split, timings, kill causes) need verbose.
     class Terminal
       MAX_ERRORS = 10
-      MAX_PASSING_TESTS = 5
-      MAX_CHANGED_LINES = 3
+      MAX_PASSING_TESTS = SurvivorList::MAX_PASSING_TESTS
 
-      def initialize(out)
+      def initialize(out, verbose: false, color: :auto)
         @out = out
+        @verbose = verbose
+        @palette = Palette.for(out, mode: color)
+        @score_table = ScoreTable.new(out, @palette)
+        @next_steps = NextSteps.new(out, @palette)
       end
 
       def call(report)
-        summary(report)
+        survivors(report)
+        errors(report)
         skipped_subjects(report)
+        outside_the_score(report)
+        inline_suppressions(report)
         warnings(report)
-        errors(report)
-        survivors(report)
+        early_stop(report)
+        test_matrix(report)
+        operator_policy(report)
+        summary(report)
       end
 
       private
 
+      def operator_policy(report)
+        policy = report.operator_policy
+        return unless policy && policy["excluded"].any?
+
+        @out.puts("Excluded operators: #{policy['excluded'].join(', ')} " \
+                  "(policy #{policy['version']}; #{policy['effective'].size} enabled)")
+      end
+
+      def test_matrix(report)
+        return unless report.matrix?
+
+        matrix = TestMatrix.new(report.results)
+        @out.puts "test matrix: #{matrix.tests.size} tests ran against mutants"
+        incomplete_matrix_note(matrix)
+        matrix_list("blind (covered mutants, killed none)", matrix.blind) do |test|
+          "#{matrix.mutants_covered(test)} covered"
+        end
+        matrix_list("redundant (every kill had another killer)", matrix.redundant) do |test|
+          "#{matrix.mutants_killed(test)} kills"
+        end
+      end
+
+      def incomplete_matrix_note(matrix)
+        return if matrix.incomplete.zero?
+
+        @out.puts "  #{matrix.incomplete} mutants stopped before every covering test ran (incomplete): " \
+                  "their tests get no blind or redundant verdict"
+      end
+
+      def matrix_list(title, tests)
+        @out.puts "  #{title}: #{tests.size}"
+        tests.first(TestMatrix::MAX_LISTED).each { |test| @out.puts "    #{test}  #{yield(test)}" }
+        more = tests.size - TestMatrix::MAX_LISTED
+        @out.puts "    ... #{more} more" if more.positive?
+      end
+
+      def inline_suppressions(report)
+        return if report.inline_suppressions.empty?
+
+        @out.puts("Inline suppressions: #{report.inline_suppressions.size} (outside the score)")
+        report.inline_suppressions.each do |entry|
+          path = entry[:file].delete_prefix("#{report.root}/")
+          @out.puts("  #{path}:#{entry[:line]} #{entry[:subject]} #{entry[:operator]} " \
+                    "#{entry[:digest]}: #{entry[:reason]}")
+        end
+      end
+
       def summary(report)
         seed = report.seed && ", seed #{report.seed} (repeat with --seed #{report.seed})"
         @out.puts "saboteur #{VERSION}: #{report.subjects.size} subjects, #{report.results.size} mutants, " \
                   "wall #{format('%.2f', report.wall_time)} s#{seed}"
         @out.puts status_line(report)
         details(report)
+        @score_table.call(report)
+        @out.puts @score_table.legend
+        @next_steps.call(report)
       end
 
       def status_line(report)
@@ -37,23 +103,43 @@ module Saboteur
         survived = "survived #{c[:survived]}"
         ignored = report.survivors.size - report.unignored_survivors.size
         survived += " (#{ignored} ignored)" if ignored.positive?
-        "killed #{c[:killed]}  #{survived}  timeout #{c[:timeout]}  resource limit #{c[:resource_limit]}  " \
-          "error #{c[:error]}  skipped #{c[:skipped]}"
+        line = "#{@palette.paint(:green,
+                                 "killed #{c[:killed]}")}  #{@palette.paint(:red,
+                                                                            survived)}  timeout #{c[:timeout]}  " \
+               "resource limit #{c[:resource_limit]}  error #{c[:error]}  skipped #{c[:skipped]}"
+        line += "  ran at load #{c[:ran_at_load]}" if c[:ran_at_load].positive?
+        line += "  unreachable #{c[:unreachable]}" if c[:unreachable].positive?
+        line
+      end
+
+      def hazard_suppressions(report)
+        return unless report.hazard_suppressions.positive?
+
+        @out.puts "hazardous mutations suppressed: #{report.hazard_suppressions} " \
+                  "(--allow-hazardous runs them anyway; the canary still watches the tree)"
       end
 
       def details(report)
         breakdown = report.score_breakdown
-        @out.puts "score #{percent(breakdown.value)}#{score_split(breakdown)} " \
-                  "(killed+timeout)/(killed+survived+timeout); errors, resource limits and skips excluded"
-        whole_body_score(report)
-        mean = report.mean_runtime
-        @out.puts "mean time per executed mutant #{format('%.3f', mean)} s" if mean
-        @out.puts "invalid mutations dropped (did not parse): #{report.invalid_mutations}" if
-          report.invalid_mutations.positive?
+        @out.puts "score #{percent(breakdown.value)}" \
+                  "#{if @verbose
+                       "#{score_split(breakdown)} (killed+timeout)/(killed+survived+timeout); " \
+                         'errors, resource limits and skips excluded'
+                     end}"
         report.skip_reasons.each { |reason, count| @out.puts "skipped: #{reason}: #{count}" }
         reused = report.results.count(&:reused?)
         @out.puts "reused #{reused} of #{report.results.size} verdicts from earlier runs (--incremental)" if
           reused.positive?
+        @out.puts "invalid mutations dropped (did not parse): #{report.invalid_mutations}" if
+          report.invalid_mutations.positive?
+        hazard_suppressions(report)
+        debug_details(report) if @verbose
+      end
+
+      def debug_details(report)
+        whole_body_score(report)
+        mean = report.mean_runtime
+        @out.puts "mean time per executed mutant #{format('%.3f', mean)} s" if mean
         @out.puts "kills rejected by unchanged-method check: #{report.rejected_kills}"
         kill_causes(report)
       end
@@ -119,6 +205,37 @@ module Saboteur
         end
       end
 
+      # Mutants no test can judge, listed apart so they are not read as
+      # misses: code that only ran while the app loaded, and methods a
+      # captured Method object still calls in their original form.
+      def outside_the_score(report)
+        { ran_at_load: "Ran at load (out of the score):",
+          unreachable: "Unreachable (out of the score):" }.each do |status, heading|
+          results = report.results.select { |result| result.status == status }
+          next if results.empty?
+
+          @out.puts heading
+          results.each do |result|
+            location = "#{relative(result.subject.file, report.root)}:#{result.subject.start_line}"
+            @out.puts "  #{result.subject.id} #{result.mutation.operator} #{result.digest} #{location}"
+          end
+          @out.puts "  hint: #{results.first.reason}" if results.first.reason
+        end
+      end
+
+      # The verdict covers only the subjects that ran, so say it where the
+      # score is read.
+      def early_stop(report)
+        stop = report.early_stop
+        return unless stop
+
+        @out.puts @palette.paint(:yellow, "stopped early (--fail-fast): #{stop.unreached.size} selected " \
+                                          "subject#{'s' unless stop.unreached.one?} did not run; the score below " \
+                                          "covers only the subjects that ran")
+        stop.unreached.first(MAX_ERRORS).each { |id| @out.puts "  not run: #{id}" }
+        @out.puts "  ... #{stop.unreached.size - MAX_ERRORS} more" if stop.unreached.size > MAX_ERRORS
+      end
+
       def warnings(report)
         report.warnings.each { |warning| @out.puts "warning: #{warning}" }
       end
@@ -136,70 +253,14 @@ module Saboteur
       end
 
       def survivors(report)
-        return if report.survivors.empty?
-
-        @out.puts "\nSurvivors:"
-        shown(report).each do |result, hidden|
-          location = "#{relative(result.subject.file, report.root)}:#{result.subject.start_line}"
-          @out.puts "\n#{result.subject.id} #{result.mutation.operator} #{result.digest} #{location}"
-          changed_lines(report, result)
-          @out.puts "ignored: #{result.ignored}" if result.ignored
-          @out.puts result.diff(root: report.root)
-          passing_tests(result)
-          @out.puts "#{hidden} more survivor#{'s' if hidden > 1} on this line in the JSON report" if hidden.positive?
-        end
-      end
-
-      # The tests that ran with the mutant applied and still passed: the
-      # missing assertion belongs in one of them. They are listed likeliest
-      # 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
-        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):"
-        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
-
-      # A reused verdict was not run again: its tests passed in the earlier run.
-      def passed_phrase(result)
-        result.reused? ? "passed in an earlier run (--incremental)" : "still passed"
-      end
-
-      # In diff mode: the changed lines this mutant touches. The location above
-      # is where the mutated statement starts, which can be a line or two above
-      # the line that changed.
-      def changed_lines(report, result)
-        lines = report.changed_lines_for(result)
-        return if lines.empty?
-
-        path = relative(result.subject.file, report.root)
-        shown = lines.first(MAX_CHANGED_LINES).map { |line| "#{path}:#{line}" }.join(", ")
-        more = lines.size - MAX_CHANGED_LINES
-        @out.puts "changed #{lines.one? ? 'line' : 'lines'}: #{shown}#{" (+#{more} more)" if more.positive?}"
-      end
-
-      # [[result, how many more on the same line]]. In review mode survivors
-      # on one line usually share a fate, so one is shown: live before
-      # ignored, then coarse before fine, then the earliest edit.
-      def shown(report)
-        return report.survivors.map { |result| [result, 0] } unless report.review?
-
-        lines = report.survivors.group_by { |result| [result.subject.file, edit_line(result)] }
-        lines.values.map do |same_line|
-          best = same_line.min_by do |result|
-            [result.ignored ? 1 : 0, result.mutation.coarse ? 0 : 1, result.mutation.edits.first.start_byte]
-          end
-          [best, same_line.size - 1]
-        end
+        SurvivorList.new(@out, @palette).call(report, ranked_survivors(report))
+        @out.puts unless report.survivors.empty?
       end
 
-      def edit_line(result)
-        result.subject.line_of(result.mutation.edits.first.start_byte)
+      # Live survivors precede accepted ones; each group follows SurvivorRanking.
+      def ranked_survivors(report)
+        live, accepted = report.survivors.partition(&:unignored_survivor?)
+        [live, accepted].flat_map { |group| SurvivorRanking.ordered(report, group) }
       end
 
       def relative(file, root)

data/lib/saboteur/reporter/test_matrix.rb

@@ -0,0 +1,57 @@
+# SPDX-License-Identifier: MIT
+# frozen_string_literal: true
+
+module Saboteur
+  module Reporter
+    # What a --matrix run says about the tests themselves. Every covering test
+    # ran against every mutant, so each killed mutant lists all of its
+    # killers. A blind test covered mutants and killed none of them. A
+    # redundant test killed some, and every one of those had another killer.
+    #
+    # Only mutants whose every planned test is known to have run (see
+    # MutantResult#complete?) count. A run that stopped early or could not
+    # report what it ran is an incomplete mutant: the tests planned for it
+    # are unverified, and no blind or redundant verdict is given for them.
+    class TestMatrix
+      MAX_LISTED = 20
+
+      attr_reader :blind, :redundant, :tests, :incomplete
+
+      def initialize(results)
+        executed = results.select { |result| %i[killed survived].include?(result.status) }
+        complete, partial = executed.partition(&:complete?)
+        @incomplete = partial.size
+        @covered = Hash.new(0)
+        @killed = Hash.new { |hash, test| hash[test] = [] }
+        complete.each { |result| tally(result) }
+        @unverified = partial.flat_map(&:covered_by).uniq
+        @tests = @covered.keys.sort
+        judged = @tests - @unverified
+        @blind = judged.select { |test| @killed[test].empty? }
+        @redundant = judged.select { |test| redundant?(test) }
+      end
+
+      def mutants_covered(test)
+        @covered.fetch(test)
+      end
+
+      def mutants_killed(test)
+        @killed[test].size
+      end
+
+      private
+
+      def tally(result)
+        key = [result.subject.id, result.digest]
+        result.covered_by.each { |test| @covered[test] += 1 }
+        killers = result.killed_by & result.covered_by
+        killers.each { |test| @killed[test] << [key, killers.size - 1] }
+      end
+
+      def redundant?(test)
+        kills = @killed[test]
+        kills.any? && kills.all? { |_key, others| others.positive? }
+      end
+    end
+  end
+end