saboteur 0.4.0 → 0.5.0

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,92 @@
 # 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)
+        summary(report)
       end
 
       private
 
+      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 +94,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 +196,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 +244,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

data/lib/saboteur/result.rb

@@ -8,17 +8,21 @@ module Saboteur
   # resource_limit: the mutant's process tree hit the memory or process cap.
   # Like error it is outside the score: a mutant that eats all memory was
   # stopped by saboteur, not detected by a test.
-  STATUSES = %i[killed survived timeout resource_limit error skipped].freeze
+  # ran_at_load: the mutated code only ran while the app loaded; no forked
+  # test can observe a change there, so it is outside the score.
+  # unreachable: a Method object captured before re-evaluation still calls
+  # the original body, so no test can observe the mutant. Outside the score.
+  STATUSES = %i[killed survived timeout resource_limit error skipped ran_at_load unreachable].freeze
 
   # Outcome of one mutation. reason carries the skip reason, the error
   # message or the timeout limit. ignored is the ignore-list reason, if any.
   class MutantResult
     attr_reader :subject, :mutation, :status, :reason, :runtime, :killed_by, :covered_by, :mutated_source,
-                :kill_cause
+                :kill_cause, :executed
     attr_accessor :ignored
 
     def initialize(subject:, mutation:, status:, mutated_source:, reason: nil, runtime: nil, killed_by: [],
-                   covered_by: [], kill_cause: nil, reused: false, rejected_kill: false)
+                   covered_by: [], kill_cause: nil, reused: false, rejected_kill: false, executed: nil)
       raise ArgumentError, "unknown status #{status.inspect}" unless STATUSES.include?(status)
 
       @subject = subject
@@ -30,6 +34,7 @@ module Saboteur
       @covered_by = covered_by
       @mutated_source = mutated_source
       @kill_cause = kill_cause
+      @executed = executed
       @rejected_kill = rejected_kill
       @reused = reused
       @ignored = nil
@@ -39,7 +44,14 @@ module Saboteur
     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,
-                       rejected_kill: rejected_kill)
+                       executed: executed, rejected_kill: rejected_kill)
+    end
+
+    # True when every test planned for this mutant is known to have run.
+    # A killed run that stopped early, a test that called exit, or a verdict
+    # whose executed tests were never recorded is not complete.
+    def complete?
+      !executed.nil? && (covered_by - executed).empty?
     end
 
     def rejected_kill?
@@ -88,18 +100,25 @@ module Saboteur
     end
   end
 
+  # A run that stopped before every selected subject was mutated (--fail-fast).
+  # unreached lists the subject ids that never ran; the verdict covers only
+  # the subjects that did.
+  EarlyStop = Data.define(:reason, :unreached)
+
   # Everything one run produced.
   class Report
     # 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
+    attr_reader :results, :subjects, :wall_time, :invalid_mutations, :warnings, :root, :seed, :skipped_subjects,
+                :generation_events, :omissions, :run_evidence, :hazard_suppressions, :early_stop, :inline_suppressions
 
     # 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, skipped_subjects: {}, diff_scope: nil)
+                   seed: nil, skipped_subjects: {}, diff_scope: nil, generation_events: [], omissions: [],
+                   run_evidence: nil, hazard_suppressions: 0, early_stop: nil, matrix: false, inline_suppressions: [])
       @results = results
       @subjects = subjects
       @wall_time = wall_time
@@ -110,6 +129,18 @@ module Saboteur
       @seed = seed
       @skipped_subjects = skipped_subjects
       @diff_scope = diff_scope
+      @generation_events = generation_events.dup.freeze
+      @omissions = omissions.dup.freeze
+      @run_evidence = run_evidence
+      @hazard_suppressions = hazard_suppressions
+      @early_stop = early_stop
+      @matrix = matrix
+      @inline_suppressions = inline_suppressions.dup.freeze
+    end
+
+    # A --matrix run: every covering test ran per mutant.
+    def matrix?
+      @matrix
     end
 
     # In diff mode, the changed lines (sorted) that a mutant touches; empty
@@ -119,6 +150,10 @@ module Saboteur
       @diff_scope ? @diff_scope.changed_lines_for(result.subject, result.mutation) : []
     end
 
+    def changed_line_distance(result)
+      @diff_scope&.distance_for(result.subject, result.mutation)
+    end
+
     def rejected_kills
       results.count(&:rejected_kill?)
     end

data/lib/saboteur/selection/coverage_map.rb

@@ -16,21 +16,87 @@ module Saboteur
     # to every test in the file of the next test that starts. Each test's
     # duration is recorded so selected tests can run fastest first.
     class CoverageMap
-      FORMAT = 3
+      FORMAT = 8
 
-      attr_reader :lines, :tests, :build_seconds, :durations
+      RAN_AT_LOAD = "ran at load: the code ran while the app loaded; a forked test cannot observe a change here"
+
+      attr_reader :lines, :tests, :build_seconds, :durations, :methods, :load_lines, :branches
 
       # lines: { "/abs/file.rb" => { 12 => ["id1", "id2"] } }
+      # methods: { "/abs/file.rb" => { 12 => ["id1", "id2"] } } keyed by the
+      # def's first line; line coverage never counts an endless def's body,
+      # so methods carry those subjects (issue #107).
       # durations: { "id1" => seconds }
-      def initialize(lines:, tests:, build_seconds: nil, durations: {})
+      def initialize(lines:, tests:, build_seconds: nil, durations: {}, methods: {}, load_lines: {}, branches: {})
         @lines = lines
         @tests = tests
         @build_seconds = build_seconds
         @durations = durations
+        @methods = methods
+        @load_lines = load_lines
+        @branches = branches
       end
 
       def tests_for(subject)
-        tests_for_lines(subject.file, subject.coverage_lines)
+        tests = tests_for_lines(subject.file, subject.coverage_lines)
+        return tests unless tests.empty?
+
+        by_method = methods[CoverageMap.canonical(subject.file)]
+        return [] unless by_method
+
+        span = subject.start_line..subject.end_line
+        ids = by_method.flat_map { |line, method_ids| span.cover?(line) ? method_ids : [] }.uniq
+        sort_test_ids(ids)
+      end
+
+      # Attach the parent's boot counters without losing the child's method coverage.
+      def with_load_lines(load_lines)
+        self.class.new(lines: lines, tests: tests, build_seconds: build_seconds, durations: durations,
+                       methods: methods, load_lines: load_lines, branches: branches)
+      end
+
+      # A requested line ran at load but no test later hit it.
+      def ran_at_load?(file, line_numbers)
+        at_load = load_lines[CoverageMap.canonical(file)]
+        return false unless at_load
+
+        covered = lines[CoverageMap.canonical(file)] || {}
+        line_numbers.any? { |line| at_load.include?(line) && !covered.key?(line) }
+      end
+
+      # Tests for the lines of one edit. A branch no test executes keeps its
+      # "no coverage" skip, but a subject whose lines never record at all
+      # (an endless def) falls back to its method coverage (issue #107).
+      def tests_for_edit(subject, line_numbers)
+        tests = tests_for_lines(subject.file, line_numbers)
+        return tests unless tests.empty?
+        return [] unless tests_for_lines(subject.file, subject.coverage_lines).empty?
+
+        tests_for(subject)
+      end
+
+      # nil means Ruby supplied no arm evidence for this edit (including &&/||).
+      # An empty list means a known arm was never taken. Nested arms intersect.
+      def tests_for_branches(subject, edits)
+        arms = branches.fetch(CoverageMap.canonical(subject.file), {})
+        matching = edits.map do |edit|
+          first = position(subject.file_source, edit.start_byte)
+          last = position(subject.file_source, edit.end_byte)
+          selected = arms.select do |span, ids|
+            (span.first(2) <=> first) <= 0 && (last <=> span.last(2)) <= 0 &&
+              !ran_before_tests?(subject.file, span, ids)
+          end
+          selected.values.reduce { |ids, other| ids & other }
+        end
+        return nil if matching.include?(nil)
+
+        sort_test_ids(matching.flatten.uniq)
+      end
+
+      # True when neither boot nor tests recorded included code. Load-only
+      # evidence is valid, even though it supplies no judged mutation score.
+      def empty?
+        [lines, methods, load_lines].all? { |hits| hits.none? { |_file, values| values.any? } }
       end
 
       # Tests that executed any of the lines, fastest first (suite order breaks
@@ -46,19 +112,19 @@ module Saboteur
         by_line = lines[CoverageMap.canonical(file)]
         return [] unless by_line
 
-        ids = line_numbers.flat_map { |line| by_line.fetch(line, []) }.uniq
-        order = test_order
-        ids.sort_by { |id| [durations.fetch(id, Float::INFINITY), order.fetch(id, Float::INFINITY)] }
+        sort_test_ids(line_numbers.flat_map { |line| by_line.fetch(line, []) }.uniq)
       end
 
       # Lines refer to tests by their index in tests, which keeps the cache
       # small for suites with long test ids.
       def to_json(*)
         index = test_order
-        encoded = lines.transform_values do |by_line|
-          by_line.to_h { |line, ids| [line.to_s, ids.map { |id| index.fetch(id) }] }
+        encode = lambda do |hits|
+          hits.transform_values { |by_line| by_line.to_h { |line, ids| [line.to_s, ids.map { |id| index.fetch(id) }] } }
         end
-        JSON.generate(format: FORMAT, tests: tests, build_seconds: build_seconds, lines: encoded,
+        JSON.generate(format: FORMAT, tests: tests, build_seconds: build_seconds, lines: encode.call(lines),
+                      methods: encode.call(methods), load_lines: load_lines,
+                      branches: encode_branches(index),
                       durations: tests.map { |id| durations[id]&.round(6) })
       end
 
@@ -67,11 +133,22 @@ module Saboteur
         raise Error, "coverage map format #{data['format']} is not #{FORMAT}" unless data["format"] == FORMAT
 
         tests = data["tests"]
-        lines = data["lines"].transform_values do |by_line|
-          by_line.to_h { |line, indexes| [line.to_i, indexes.map { |i| tests.fetch(i) }] }
+        decode = lambda do |hits|
+          hits.transform_values do |by_line|
+            by_line.to_h { |line, indexes| [line.to_i, indexes.map { |i| tests.fetch(i) }] }
+          end
         end
         durations = tests.zip(data["durations"]).to_h.compact
-        new(lines: lines, tests: tests, build_seconds: data["build_seconds"], durations: durations)
+        load_lines = (data["load_lines"] || {}).transform_values { |list| list.map(&:to_i) }
+        new(lines: decode.call(data["lines"]), tests: tests, build_seconds: data["build_seconds"],
+            durations: durations, methods: decode.call(data["methods"] || {}), load_lines: load_lines,
+            branches: decode_branches(data.fetch("branches", {}), tests))
+      end
+
+      def self.decode_branches(branches, tests)
+        branches.transform_values do |arms|
+          arms.to_h { |span, ids| [span, ids.map { |id| tests.fetch(id) }] }
+        end
       end
 
       # Cache key over every input that can change which test runs which line.
@@ -105,6 +182,35 @@ module Saboteur
 
       private
 
+      def encode_branches(index)
+        branches.transform_values do |arms|
+          arms.map { |span, ids| [span, ids.map { |id| index.fetch(id) }] }
+        end
+      end
+
+      # An arm whose body the app ran while loading (a def inside an if) has no
+      # per-test hits, yet tests ran the lines inside it. Only lines strictly
+      # between the arm's first and last line count: the boundary lines can
+      # also hold code outside the arm. An arm with no interior line, such as
+      # a one-line arm, cannot be told apart, so its empty list still means
+      # "not taken".
+      def ran_before_tests?(file, span, ids)
+        return false unless ids.empty?
+
+        covered = lines[CoverageMap.canonical(file)] || {}
+        ((span[0] + 1)...span[2]).any? { |line| covered.key?(line) }
+      end
+
+      def position(source, offset)
+        prefix = source.byteslice(0, offset).b
+        [prefix.count("\n") + 1, offset - ((prefix.rindex("\n") || -1) + 1)]
+      end
+
+      def sort_test_ids(ids)
+        order = test_order
+        ids.sort_by { |id| [durations.fetch(id, Float::INFINITY), order.fetch(id, Float::INFINITY)] }
+      end
+
       def test_order
         @test_order ||= tests.each_with_index.to_h
       end