saboteur 0.2.0 → 0.4.0

data/lib/saboteur/reporter/html.rb

@@ -0,0 +1,213 @@
+# SPDX-License-Identifier: MIT
+# frozen_string_literal: true
+
+require "cgi"
+require "fileutils"
+
+module Saboteur
+  module Reporter
+    # One self-contained HTML page: inline style, no script, no network. It is
+    # rendered from the same hash the JSON reporter writes (Stryker.build), so
+    # both reports list the same mutants with the same statuses. The scores can
+    # differ: the JSON schema counts NoCoverage as undetected, while this page
+    # shows Report#score, which leaves it out (see the "Covered mutation score"
+    # label on the page). The score note says what is and is not counted.
+    class Html
+      STYLE = <<~CSS
+        body{font:14px/1.5 system-ui,sans-serif;margin:1rem auto;max-width:72rem;padding:0 1rem;color:#1b1b1b}
+        h1,h2{margin:1.2em 0 .4em}table{border-collapse:collapse;width:100%;min-width:60rem}
+        th,td{border-bottom:1px solid #ddd;padding:.25rem .5rem;text-align:left;vertical-align:top;overflow-wrap:break-word}
+        td.fit{white-space:nowrap}td.wide{min-width:14rem}
+        th{background:#f4f4f4;font-size:12px;text-transform:uppercase}
+        .scroll{overflow-x:auto}.note{color:#555;font-size:12px}
+        .status{border-radius:3px;padding:0 .4rem;color:#fff;white-space:nowrap}
+        .Killed{background:#2e7d32}.Survived{background:#c62828}.Timeout{background:#b45309}
+        .RuntimeError{background:#6a1b9a}.NoCoverage{background:#455a64}.Ignored{background:#616161}
+        .Accepted{background:#8d6e63}
+        .warning{background:#fff8e1;border-left:4px solid #f9a825;margin:.3rem 0;padding:.3rem .6rem;overflow-wrap:anywhere}
+        code,pre{font-family:ui-monospace,monospace;font-size:13px}
+        pre{display:inline-block;vertical-align:top;margin:0;white-space:pre-wrap;overflow-wrap:anywhere}summary{cursor:pointer;font-weight:600;overflow-wrap:anywhere}
+      CSS
+
+      SCORE_FORMULA = "(killed + timeout) / (killed + survived + timeout)"
+
+      def initialize(path)
+        @path = path
+      end
+
+      def call(report)
+        FileUtils.mkdir_p(File.dirname(@path))
+        File.write(@path, self.class.build(report))
+      end
+
+      def self.build(report)
+        new(nil).build(report)
+      end
+
+      def build(report)
+        data = Stryker.build(report)
+        names = test_names(data)
+        results = report.results.to_h do |result|
+          [[Stryker.relative(result.subject.file, report.root), result.digest], result]
+        end
+        <<~HTML
+          <!DOCTYPE html>
+          <html lang="en"><head><meta charset="utf-8">
+          <meta name="viewport" content="width=device-width, initial-scale=1">
+          <title>saboteur report</title>
+          <style>#{STYLE}</style></head><body>
+          <h1>saboteur report</h1>
+          #{summary(report, data)}#{warnings(data[:warnings])}#{skipped_subjects(data[:skippedSubjects])}
+          <h2>Files</h2>
+          #{data[:files].map { |file, entry| file_section(file, entry, names, results) }.join("\n")}
+          </body></html>
+        HTML
+      end
+
+      private
+
+      def summary(report, data)
+        seed = data.dig(:config, :seed)
+        seed_note = seed ? ", seed #{seed}" : ""
+        counts = data[:files].values.flat_map { |entry| entry[:mutants] }.map { |mutant| mutant[:status] }.tally
+        <<~HTML
+          <p><strong>Covered mutation score: #{score_text(report.score)}</strong>
+          (#{report.subjects.size} subjects, #{report.results.size} mutants, #{format('%.1f', report.wall_time)}s#{seed_note})</p>
+          <p class="note">Covered mutation score = #{SCORE_FORMULA}. NoCoverage, errors, resource limits and skipped
+          mutants are not counted. Survivors accepted on the ignore list stay in the denominator. It covers only the subjects of this run, not the whole project. A tool that reads the
+          Stryker JSON may show a different score, because the schema counts NoCoverage as undetected.</p>
+          #{score_split(report)}
+          <p class="note">Wide tables scroll sideways.</p>
+          <p>#{counts.map { |status, count| "#{status_label(status)} #{count}" }.join(' ')}</p>
+          <p>Survivors: #{report.unignored_survivors.size} to fix, #{report.survivors.size - report.unignored_survivors.size}
+          accepted on the ignore list (still shown as Survived, with the reason).</p>
+        HTML
+      end
+
+      # How the score splits into assertion and crash kills, and the score
+      # without the whole-body mutants, which almost any test that runs the
+      # method kills. Each part shows only when it has something to say.
+      def score_split(report)
+        breakdown = report.score_breakdown
+        lines = []
+        lines << kill_split_line(breakdown) if breakdown.split_known?
+        lines << whole_body_line(report)
+        lines.compact.join("\n")
+      end
+
+      def kill_split_line(breakdown)
+        "<p>Of the tested mutants: #{parts_text(breakdown)}. A crash shows the code ran and broke, " \
+          "not that a test checked a value.</p>"
+      end
+
+      def parts_text(breakdown)
+        breakdown.parts.map { |label, share| "#{score_text(share)} #{label}" }.join(", ")
+      end
+
+      def whole_body_line(report)
+        whole = report.coarse_score_breakdown
+        fine = report.fine_score_breakdown
+        return if whole.tested.zero? || fine.tested.zero?
+
+        split = fine.split_known? ? " (#{parts_text(fine)})" : ""
+        "<p>Without whole-body mutants (body_nil, body_true, body_false, body_raise): #{score_text(fine.value)}" \
+          "#{split} over #{fine.tested} mutants. Whole-body mutants alone: #{score_text(whole.value)} " \
+          "over #{whole.tested}.</p>"
+      end
+
+      def score_text(score)
+        score ? format("%.1f%%", score * 100) : "n/a"
+      end
+
+      def warnings(messages)
+        return "" if messages.empty?
+
+        items = messages.map { |message| %(<div class="warning">#{escape(message)}</div>) }
+        "<h2>Warnings</h2>\n#{items.join("\n")}"
+      end
+
+      def skipped_subjects(entries)
+        return "" if entries.empty?
+
+        rows = entries.map do |entry|
+          "<tr><td>#{escape(entry[:subject])}</td><td>#{escape(entry[:file])}:#{entry[:line]}</td>" \
+            "<td>#{escape(entry[:reason])}</td></tr>"
+        end
+        "<h2>Skipped subjects</h2>\n<div class=\"scroll\"><table><thead><tr><th>Subject</th><th>Location</th>" \
+          "<th>Reason</th></tr></thead>#{rows.join}</table></div>"
+      end
+
+      def test_names(data)
+        data[:testFiles].values.flat_map { |group| group[:tests] }.to_h { |test| [test[:id], test[:name]] }
+      end
+
+      def file_section(file, entry, names, results)
+        open = entry[:mutants].any? { |mutant| mutant[:status] == "Survived" } ? " open" : ""
+        ordered = entry[:mutants].sort_by { |mutant| position_key(mutant) }
+        rows = ordered.map { |mutant| mutant_row(mutant, names, results[[file, mutant[:id]]]) }
+        "<details#{open}><summary>#{escape(file)} (#{entry[:mutants].size} mutants)</summary>\n" \
+          "<div class=\"scroll\"><table><thead><tr><th>Location</th><th>Status</th><th>Operator</th><th>Change</th>" \
+          "<th>Id</th><th>Notes</th></tr></thead>\n#{rows.join("\n")}</table></div></details>"
+      end
+
+      def position_key(mutant)
+        start = mutant[:location][:start]
+        [start[:line], start[:column], mutant[:id]]
+      end
+
+      def mutant_row(mutant, names, result)
+        start = mutant[:location][:start]
+        tests = Array(mutant[:killedBy]).map { |id| names.fetch(id) }.join(", ")
+        notes = [mutant[:statusReason], tests.empty? ? nil : "killed by #{tests}",
+                 passing_tests_note(mutant, names, result)].compact.join("; ")
+        "<tr><td class=\"fit\">line #{start[:line]}, column #{start[:column]}</td><td>#{row_status(mutant,
+                                                                                                   result)}</td>" \
+          "<td>#{escape(mutant[:mutatorName])}</td><td class=\"wide\">#{change(mutant, result)}</td>" \
+          "<td class=\"fit\"><code>#{escape(mutant[:id])}</code></td><td class=\"wide\">#{escape(notes)}</td></tr>"
+      end
+
+      # A survivor's covering tests all passed with the mutant applied, or, for
+      # a reused verdict, in the earlier run it came from.
+      def passing_tests_note(mutant, names, result)
+        return unless mutant[:status] == "Survived"
+
+        passed = Array(mutant[:coveredBy]).map { |id| names.fetch(id) }
+        return if passed.empty?
+
+        shown = passed.first(Terminal::MAX_PASSING_TESTS).join(", ")
+        more = passed.size - Terminal::MAX_PASSING_TESTS
+        extra = more.positive? ? " (+#{more} more)" : ""
+        when_passed = result.reused? ? "passed in an earlier run" : "passed"
+        "covered by #{passed.size} #{passed.one? ? 'test' : 'tests'} that #{when_passed}: #{shown}#{extra}"
+      end
+
+      def row_status(mutant, result)
+        badge = status_label(mutant[:status])
+        # Only survivors are ever put on the ignore list.
+        result.ignored ? "#{badge} #{status_label('Accepted')}" : badge
+      end
+
+      # One edit shows the original text and its replacement. A mutant with
+      # several edits shows only the replacements, because one location cannot
+      # stand for all of them.
+      def change(mutant, result)
+        edits = result.mutation.edits
+        return "<pre>#{escape(mutant[:replacement])}</pre>" unless edits.size == 1
+
+        source = result.subject.file_source
+        edit = edits.first
+        original = source.byteslice(edit.start_byte, edit.end_byte - edit.start_byte).to_s
+        "<pre>#{escape(original.dup.force_encoding(Encoding::UTF_8).scrub)}</pre> becomes " \
+          "<pre>#{escape(edit.replacement)}</pre>"
+      end
+
+      def status_label(status)
+        %(<span class="status #{status}">#{status}</span>)
+      end
+
+      def escape(text)
+        CGI.escapeHTML(text.to_s)
+      end
+    end
+  end
+end

data/lib/saboteur/reporter/replay.rb

@@ -0,0 +1,23 @@
+# SPDX-License-Identifier: MIT
+# frozen_string_literal: true
+
+module Saboteur
+  module Reporter
+    # A replay is an inspection too, regardless of the resulting verdict.
+    class Replay
+      def initialize(out)
+        @out = out
+      end
+
+      def call(report)
+        report.results.each do |result|
+          @out.puts "\nReplay: #{result.subject.id} #{result.mutation.operator} #{result.digest} (#{result.status})"
+          @out.puts result.diff(root: report.root)
+          @out.puts "Selected tests:"
+          result.covered_by.each { |name| @out.puts "  #{name}" }
+          @out.puts "  none" if result.covered_by.empty?
+        end
+      end
+    end
+  end
+end

data/lib/saboteur/reporter/stryker.rb

@@ -16,14 +16,14 @@ module Saboteur
         @path = path
       end
 
-      def call(report)
+      def call(report, exit_cause: nil)
         FileUtils.mkdir_p(File.dirname(@path))
-        File.write(@path, JSON.generate(self.class.build(report)))
+        File.write(@path, JSON.generate(self.class.build(report, exit_cause: exit_cause)))
       end
 
       # Tests are listed once under testFiles with short ids; mutants refer to
       # them by id in killedBy/coveredBy instead of repeating full test names.
-      def self.build(report)
+      def self.build(report, exit_cause: nil)
         test_ids = test_index(report.results)
         files = report.results.group_by { |result| result.subject.file }.to_h do |file, results|
           [relative(file, report.root), file_entry(results, test_ids)]
@@ -34,10 +34,27 @@ module Saboteur
           projectRoot: report.root,
           files: files,
           testFiles: test_files(test_ids),
-          framework: { name: "saboteur", version: VERSION }
+          skippedSubjects: skipped_subjects(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 } : {})
         }.merge(report.seed ? { config: { seed: report.seed } } : {})
       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
+
+      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 }
+        end
+      end
+
       def self.test_index(results)
         names = results.flat_map { |result| result.covered_by + result.killed_by }.uniq
         names.each_with_index.to_h { |name, index| [name, index.to_s] }

data/lib/saboteur/reporter/terminal.rb

@@ -7,6 +7,8 @@ module Saboteur
     # errors, then a unified diff for each survivor.
     class Terminal
       MAX_ERRORS = 10
+      MAX_PASSING_TESTS = 5
+      MAX_CHANGED_LINES = 3
 
       def initialize(out)
         @out = out
@@ -14,6 +16,7 @@ module Saboteur
 
       def call(report)
         summary(report)
+        skipped_subjects(report)
         warnings(report)
         errors(report)
         survivors(report)
@@ -39,9 +42,10 @@ module Saboteur
       end
 
       def details(report)
-        score = report.score
-        @out.puts "score #{score ? format('%.1f %%', score * 100) : 'n/a'} " \
+        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
@@ -50,9 +54,35 @@ module Saboteur
         reused = report.results.count(&:reused?)
         @out.puts "reused #{reused} of #{report.results.size} verdicts from earlier runs (--incremental)" if
           reused.positive?
+        @out.puts "kills rejected by unchanged-method check: #{report.rejected_kills}"
         kill_causes(report)
       end
 
+      # " (assertion 50.0 %, crash 50.0 %)": how much of the score is a failed
+      # check and how much is a crash. Timeouts and kills with no recorded
+      # cause are named only when there are some, so the parts add up.
+      def score_split(breakdown)
+        return "" unless breakdown.split_known?
+
+        " (#{breakdown.parts.map { |label, share| "#{label} #{percent(share)}" }.join(', ')})"
+      end
+
+      # Whole-body mutants (body_nil, body_true, body_false, body_raise) are
+      # killed by almost any test that runs the method, so they get their own
+      # line.
+      def whole_body_score(report)
+        whole = report.coarse_score_breakdown
+        fine = report.fine_score_breakdown
+        return if whole.tested.zero? || fine.tested.zero?
+
+        @out.puts "score without whole-body mutants #{percent(fine.value)}#{score_split(fine)} " \
+                  "(#{fine.tested} mutants); whole-body mutants alone #{percent(whole.value)} (#{whole.tested})"
+      end
+
+      def percent(share)
+        share ? format("%.1f %%", share * 100) : "n/a"
+      end
+
       # How many kills came from a failed check and how many from a crash, and
       # which operators mostly kill by crashing (their score says less).
       def kill_causes(report)
@@ -80,6 +110,15 @@ module Saboteur
         parts.join(", ")
       end
 
+      def skipped_subjects(report)
+        report.skipped_subjects.values.tally.each do |reason, count|
+          @out.puts "skipped subjects: #{reason}: #{count}"
+        end
+        report.skipped_subjects.each do |subject, reason|
+          @out.puts "  #{subject.id} #{relative(subject.file, report.root)}:#{subject.start_line}: #{reason}"
+        end
+      end
+
       def warnings(report)
         report.warnings.each { |warning| @out.puts "warning: #{warning}" }
       end
@@ -103,12 +142,47 @@ module Saboteur
         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.

data/lib/saboteur/result.rb

@@ -2,6 +2,7 @@
 # frozen_string_literal: true
 
 require_relative "reporter/diff"
+require_relative "score"
 
 module Saboteur
   # resource_limit: the mutant's process tree hit the memory or process cap.
@@ -17,7 +18,7 @@ module Saboteur
     attr_accessor :ignored
 
     def initialize(subject:, mutation:, status:, mutated_source:, reason: nil, runtime: nil, killed_by: [],
-                   covered_by: [], kill_cause: nil, reused: false)
+                   covered_by: [], kill_cause: nil, reused: false, rejected_kill: false)
       raise ArgumentError, "unknown status #{status.inspect}" unless STATUSES.include?(status)
 
       @subject = subject
@@ -29,14 +30,20 @@ module Saboteur
       @covered_by = covered_by
       @mutated_source = mutated_source
       @kill_cause = kill_cause
+      @rejected_kill = rejected_kill
       @reused = reused
       @ignored = nil
     end
 
     # The same mutant, marked as an error: its verdict did not hold up.
-    def as_error(reason)
+    def as_error(reason, rejected_kill: false)
       MutantResult.new(subject: subject, mutation: mutation, status: :error, mutated_source: mutated_source,
-                       reason: reason, runtime: runtime, killed_by: killed_by, covered_by: covered_by)
+                       reason: reason, runtime: runtime, killed_by: killed_by, covered_by: covered_by,
+                       rejected_kill: rejected_kill)
+    end
+
+    def rejected_kill?
+      @rejected_kill
     end
 
     def digest
@@ -53,6 +60,11 @@ module Saboteur
       status == :killed && !kill_cause.nil? && kill_cause != "assertion"
     end
 
+    # Killed because a test's check failed: the test looked at a value.
+    def assertion_kill?
+      status == :killed && kill_cause == "assertion"
+    end
+
     # Taken from an earlier run (--incremental) instead of run again.
     def reused?
       @reused
@@ -78,12 +90,16 @@ module Saboteur
 
   # Everything one run produced.
   class Report
-    attr_reader :results, :subjects, :wall_time, :invalid_mutations, :warnings, :root, :seed
+    # More than half of the executed mutants errored: the run tested
+    # almost nothing and must not pass a gate.
+    MAX_ERROR_FRACTION = 0.5
+
+    attr_reader :results, :subjects, :wall_time, :invalid_mutations, :warnings, :root, :seed, :skipped_subjects
 
     # REVIEW: diff mode; the terminal then shows one survivor per line.
     # seed: the random seed every test run started from (nil when unknown).
     def initialize(results:, subjects:, wall_time:, root:, invalid_mutations: 0, warnings: [], review: false,
-                   seed: nil)
+                   seed: nil, skipped_subjects: {}, diff_scope: nil)
       @results = results
       @subjects = subjects
       @wall_time = wall_time
@@ -92,6 +108,29 @@ module Saboteur
       @warnings = warnings
       @review = review
       @seed = seed
+      @skipped_subjects = skipped_subjects
+      @diff_scope = diff_scope
+    end
+
+    # In diff mode, the changed lines (sorted) that a mutant touches; empty
+    # outside diff mode, or when the mutant touches none (a whole-body mutant
+    # of a method whose only change is its signature).
+    def changed_lines_for(result)
+      @diff_scope ? @diff_scope.changed_lines_for(result.subject, result.mutation) : []
+    end
+
+    def rejected_kills
+      results.count(&:rejected_kill?)
+    end
+
+    # Errored mutants (a crash, a neutral check that failed) are outside
+    # the score, so a run whose executed mutants mostly errored tested
+    # almost nothing. Skipped mutants never ran: they are neither the
+    # numerator nor the denominator.
+    def majority_errored?
+      return false if executed.empty?
+
+      executed.count { |result| result.status == :error }.fdiv(executed.size) > MAX_ERROR_FRACTION
     end
 
     def review?
@@ -104,10 +143,23 @@ module Saboteur
 
     # (killed + timeout) / (killed + survived + timeout); nil with nothing tested.
     def score
-      c = counts
-      detected = c[:killed] + c[:timeout]
-      tested = detected + c[:survived]
-      tested.zero? ? nil : detected.fdiv(tested)
+      score_breakdown.value
+    end
+
+    # The score with its split into assertion kills and crash kills.
+    def score_breakdown
+      @score_breakdown ||= Score.of(results)
+    end
+
+    # The same breakdown without the whole-body mutants (every
+    # mutation marked coarse: body_nil, body_true, body_false, body_raise). Almost any test that runs the method kills
+    # those, so they flatter the score.
+    def fine_score_breakdown
+      @fine_score_breakdown ||= Score.of(results.reject { |result| result.mutation.coarse })
+    end
+
+    def coarse_score_breakdown
+      @coarse_score_breakdown ||= Score.of(results.select { |result| result.mutation.coarse })
     end
 
     def survivors

data/lib/saboteur/score.rb

@@ -0,0 +1,89 @@
+# SPDX-License-Identifier: MIT
+# frozen_string_literal: true
+
+module Saboteur
+  # The mutation score of a group of results, with the share of it that came
+  # from failed assertions and the share that came from crashes.
+  #
+  # value is (killed + timeout) / (killed + survived + timeout). A crash kill
+  # shows the code ran and broke, not that a test checked a value, so the
+  # split lets a reader see how much of the score is checked behavior.
+  # Errors, resource limits and skips are outside every number here.
+  class Score
+    def self.of(results)
+      new(results)
+    end
+
+    attr_reader :assertion_kills, :crash_kills, :unclassified_kills, :timeouts, :survivors
+
+    def initialize(results)
+      killed = results.select { |result| result.status == :killed }
+      @assertion_kills = killed.count(&:assertion_kill?)
+      @crash_kills = killed.count(&:crash_kill?)
+      @unclassified_kills = killed.size - assertion_kills - crash_kills
+      @timeouts = results.count { |result| result.status == :timeout }
+      @survivors = results.count(&:survived?)
+    end
+
+    def detected
+      assertion_kills + crash_kills + unclassified_kills + timeouts
+    end
+
+    def tested
+      detected + survivors
+    end
+
+    # nil with nothing tested.
+    def value
+      share(detected)
+    end
+
+    def assertion_share
+      share(assertion_kills)
+    end
+
+    def crash_share
+      share(crash_kills)
+    end
+
+    def unclassified_share
+      share(unclassified_kills)
+    end
+
+    def timeout_share
+      share(timeouts)
+    end
+
+    # False when no kill has a recorded cause: a split would then say
+    # nothing. A cause is missing for verdicts reused from a run made before
+    # causes were recorded, for a test that called exit, and for a failure
+    # outside any example (suite level).
+    def split_known?
+      assertion_kills.positive? || crash_kills.positive?
+    end
+
+    # [[label, share]]: assertion and crash always, then timeout and
+    # "cause not recorded" only when there are some, so the parts add up to
+    # value.
+    def parts
+      list = [["assertion", assertion_share], ["crash", crash_share]]
+      list << ["timeout", timeout_share] if timeouts.positive?
+      list << ["cause not recorded", unclassified_share] if unclassified_kills.positive?
+      list
+    end
+
+    def to_h
+      {
+        score: value, tested: tested, assertionKills: assertion_kills, crashKills: crash_kills,
+        unclassifiedKills: unclassified_kills, timeouts: timeouts, survivors: survivors,
+        assertionShare: assertion_share, crashShare: crash_share
+      }
+    end
+
+    private
+
+    def share(count)
+      tested.zero? ? nil : count.fdiv(tested)
+    end
+  end
+end

data/lib/saboteur/version.rb

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