branchproof 0.2.0 → 0.4.0

data/lib/branchproof/comparison.rb

@@ -0,0 +1,363 @@
+# frozen_string_literal: true
+
+# rubocop:disable Metrics/ClassLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+require "json"
+
+module Branchproof
+  # Compares two complete report documents without loading or executing the project.
+  class Comparison
+    SCHEMA_VERSION = "1.0"
+    SUPPORTED_REPORT_SCHEMAS = %w[1.0 1.1].freeze
+    CRITERION_VERSION = "masking_occurrence_v1"
+
+    def initialize(before:, after:)
+      @before = before
+      @after = after
+      @contexts = {}.compare_by_identity
+    end
+
+    def call
+      errors = validate_documents
+      return invalid_result(errors) unless errors.empty?
+
+      before_sources = sources(@before)
+      after_sources = sources(@after)
+      changed_paths = before_sources.keys & after_sources.keys
+      changed_paths.reject! { |path| digest(before_sources[path]) == digest(after_sources[path]) }
+      before_conditions = condition_map(@before)
+      after_conditions = condition_map(@after)
+      matched_ids = before_conditions.keys & after_conditions.keys
+      matched_ids.select! { |id| compatible_condition?(before_conditions[id], after_conditions[id], changed_paths) }
+      changes = matched_ids.filter_map { |id| condition_change(id, before_conditions[id], after_conditions[id]) }
+      reasons = comparability_reasons(changed_paths)
+      reasons.concat(metadata_requirements)
+      reasons << "legacy report is missing comparison context" if [@before, @after].any? do |document|
+        value(document, :schema_version).to_s == "1.0" && value(document, :run_metadata).nil?
+      end
+      complete = complete_run?(@before) && complete_run?(@after)
+      reasons << "run baselines are not successful finalized complete reports" unless complete
+      reasons << "no comparable conditions" if matched_ids.empty?
+      if changes.any? { |change| [change["status_before"], change["status_after"]].include?("UNKNOWN") }
+        reasons << "condition proof status unavailable"
+      end
+      if before_sources.keys.sort != after_sources.keys.sort
+        reasons << "source population differs; whole-source comparison is partial"
+      end
+      if matched_ids.length != before_conditions.length || matched_ids.length != after_conditions.length
+        reasons << "unmatched conditions; exact-match scope is partial"
+      end
+      status = reasons.empty? ? "complete" : "comparison incomplete"
+      lost = changes.count { |change| change["change"] == "lost proof" }
+
+      {
+        "schema_version" => SCHEMA_VERSION,
+        "criterion_version" => CRITERION_VERSION,
+        "status" => status,
+        "comparison_status" => status,
+        "reasons" => reasons,
+        "before" => summary(@before),
+        "after" => summary(@after),
+        "context" => context_changes,
+        "matching" => { "before_conditions" => before_conditions.length,
+                        "after_conditions" => after_conditions.length,
+                        "matched_conditions" => matched_ids.length,
+                        "denominator" => matched_ids.length,
+                        "before_proven" => changes.count { |change| change["status_before"] == "PROVEN" },
+                        "after_proven" => changes.count { |change| change["status_after"] == "PROVEN" } },
+        "changed_sources" => changed_paths.sort.map do |path|
+          { "relative_path" => path, "reason" => "source changed / condition comparison unavailable" }
+        end,
+        "newly_in_report" => (after_sources.keys - before_sources.keys).sort,
+        "no_longer_in_report" => (before_sources.keys - after_sources.keys).sort,
+        "changes" => changes.sort_by do |change|
+          [change["relative_path"].to_s, change["line"].to_i, change["condition_id"]]
+        end,
+        "regressions" => lost,
+        "regression" => lost.positive? && status == "complete"
+      }
+    end
+
+    private
+
+    def validate_documents
+      errors = []
+      { "before" => @before, "after" => @after }.each do |label, document|
+        errors << "#{label} report must be an object" unless document.is_a?(Hash)
+        next unless document.is_a?(Hash)
+
+        schema = value(document, :schema_version).to_s
+        criterion = value(document, :criterion_version).to_s
+        errors << "#{label} report has unsupported schema" unless SUPPORTED_REPORT_SCHEMAS.include?(schema)
+        errors << "#{label} report has incompatible criterion" unless criterion == CRITERION_VERSION
+        errors << "#{label} source_inventory must be an object" unless value(document, :source_inventory).is_a?(Hash)
+      end
+      errors.uniq
+    end
+
+    def invalid_result(errors)
+      { "schema_version" => SCHEMA_VERSION, "status" => "comparison incomplete",
+        "comparison_status" => "comparison incomplete", "reasons" => errors,
+        "before" => summary(@before), "after" => summary(@after),
+        "matching" => { "before_conditions" => 0, "after_conditions" => 0,
+                        "matched_conditions" => 0, "denominator" => 0 },
+        "changed_sources" => [], "newly_in_report" => [], "no_longer_in_report" => [],
+        "changes" => [], "regressions" => 0, "regression" => false }
+    end
+
+    def sources(document)
+      units = value(value(document, :source_inventory), :source_units)
+      Array(units).each_with_object({}) do |source, result|
+        path = value(source, :relative_path).to_s
+        result[path] = source unless path.empty?
+      end
+    end
+
+    def condition_map(document)
+      data = context(document)
+      data[:decisions].values.each_with_object({}) do |decision, result|
+        next if value(decision, :support_status).to_s == "UNSUPPORTED"
+
+        Array(value(decision, :conditions)).each do |condition|
+          id = value(condition, :id).to_s
+          unless id.empty?
+            result[id] = { condition: condition, row: data[:conditions][id], decision: decision,
+                           result: data[:results][id] }
+          end
+        end
+      end
+    end
+
+    def compatible_condition?(before, after, changed_paths)
+      before_path = source_path(@before, before[:decision])
+      after_path = source_path(@after, after[:decision])
+      return false if before_path.nil? || changed_paths.include?(before_path) || before_path != after_path
+
+      before_digest = digest(sources(@before)[before_path])
+      after_digest = digest(sources(@after)[after_path])
+      return false unless before_digest && before_digest == after_digest
+
+      %i[index expression byte_start byte_length].all? do |key|
+        value(before[:condition], key) == value(after[:condition], key)
+      end && %i[id source_id expression context byte_start byte_length tree].all? do |key|
+        Records.normalize(value(before[:decision], key)) == Records.normalize(value(after[:decision], key))
+      end
+    end
+
+    def condition_change(id, before, after)
+      old_status = status(before[:result], @before)
+      new_status = status(after[:result], @after)
+      if new_status == "NOT_PROVEN" && !complete_run?(@after) &&
+         context(@after)[:vectors].values.none? { |vector| value(vector, :decision_id) == value(after[:decision], :id) }
+        new_status = "UNKNOWN"
+      end
+      kind = if old_status == "PROVEN" && new_status == "NOT_PROVEN"
+               "lost proof"
+             elsif old_status == "NOT_PROVEN" && new_status == "PROVEN"
+               "gained proof"
+             elsif old_status == new_status
+               "unchanged"
+             else
+               "unknown"
+             end
+      return if kind.nil?
+
+      decision = after[:decision]
+      source_path = source_path(@after, decision)
+      row = { "condition_id" => id, "change" => kind, "status_before" => old_status,
+              "status_after" => new_status, "expression" => value(after[:condition], :expression),
+              "relative_path" => source_path, "line" => value(after[:condition], :line),
+              "index" => value(after[:condition], :index),
+              "previous_witness" => witness(@before, before[:result], before[:decision]),
+              "current_witness" => witness(@after, after[:result], after[:decision]) }
+      row["previous_witness_owners"] = row["previous_witness"].to_a.flat_map { |item| item["tests"] }.uniq
+      row["current_witness_owners"] = row["current_witness"].to_a.flat_map { |item| item["tests"] }.uniq
+      row["owner_context"] = owner_context(before[:result], before[:decision])
+      row
+    end
+
+    def context(document)
+      @contexts[document] ||= begin
+        index = CoverageIndex.new(document: document)
+        tests = Array(value(value(document, :observations), :tests)).to_h { |test| [value(test, :id).to_s, test] }
+        rows = index.tests.to_h { |test| [test[:id].to_s, test] }
+        keys = tests.to_h do |id, test|
+          parts = %i[adapter class_name method_name].map { |key| value(test, key) }
+          parts << rows.dig(id, :relative_path)
+          [id, parts.all? { |part| part.is_a?(String) && !part.empty? } ? parts : nil]
+        end
+        results = Array(value(value(document, :analysis), :decisions)).flat_map do |decision|
+          Array(value(decision, :condition_results))
+        end
+        { conditions: index.conditions.to_h { |row| [row[:id].to_s, row] }, tests: tests, test_rows: rows,
+          test_keys: keys, key_owners: keys.keys.group_by { |id| keys[id] },
+          vectors: Array(value(value(document, :observations), :vectors)).to_h do |vector|
+            [value(vector, :id).to_s, vector]
+          end,
+          decisions: Array(value(value(document, :source_inventory), :decisions)).to_h do |decision|
+            [value(decision, :id).to_s, decision]
+          end,
+          results: results.to_h { |result| [value(result, :condition_id).to_s, result] } }
+      end
+    end
+
+    def owner_context(result, decision)
+      before = context(@before)
+      after = context(@after)
+      Array(value(result, :canonical_pair)).flat_map do |vector_id|
+        vector = before[:vectors][vector_id.to_s]
+        next [] unless vector
+
+        Array(value(vector, :test_ids)).sort.map do |id|
+          key = before[:test_keys][id.to_s]
+          unique = key && before[:key_owners][key]&.length == 1 && after[:key_owners][key]&.length == 1
+          current_id = unique ? after[:key_owners][key].first : nil
+          observed = current_id && after[:vectors].values.any? do |current|
+            value(current, :decision_id) == value(decision, :id) &&
+              value(current,
+                    :values) == value(vector, :values) && value(current, :outcome) == value(vector, :outcome) &&
+              Array(value(current, :test_ids)).include?(current_id)
+          end
+          test_status = current_id ? "present in current run" : "not observed in current run (no unique test match)"
+          { "label" => test_display(@before, id), "current_label" => current_id && test_display(@after, current_id),
+            "test_status" => test_status,
+            "observation_status" => observed ? "observed in current run" : "not observed in current run",
+            "values" => value(vector, :values), "outcome" => value(vector, :outcome) }
+        end
+      end
+    end
+
+    def witness(document, result, _decision)
+      pair = value(result, :canonical_pair)
+      return nil unless pair.is_a?(Array)
+
+      pair.map do |id|
+        vector = context(document)[:vectors][id.to_s]
+        { "vector_id" => id, "values" => value(vector, :values), "outcome" => value(vector, :outcome),
+          "tests" => Array(value(vector, :test_ids)).map { |test_id| test_display(document, test_id) }.uniq.sort }
+      end
+    end
+
+    def test_display(document, id)
+      row = context(document)[:test_rows][id.to_s]
+      return "unknown test (location unavailable)" unless row
+
+      path = row[:relative_path]
+      location = path && row[:line] ? "#{path}:#{row[:line]}" : "location unavailable"
+      "#{row[:name]} (#{location})"
+    end
+
+    def context_changes
+      changes = []
+      if metadata(@before, :seed) != metadata(@after, :seed)
+        changes << "seed differs: #{metadata(@before, :seed).inspect} -> #{metadata(@after, :seed).inspect}"
+      end
+      if metadata(@before, :test_files) != metadata(@after, :test_files)
+        changes << "expanded test files differ under the recorded selection patterns"
+      end
+      if context(@before)[:test_keys].values.sort_by(&:to_s) != context(@after)[:test_keys].values.sort_by(&:to_s)
+        changes << "test population differs"
+      end
+      changes << "Deltas describe observed runs; nondeterminism and external environment changes are not ruled out."
+      changes
+    end
+
+    def comparability_reasons(changed_paths)
+      reasons = []
+      reasons << "source files changed: #{changed_paths.sort.join(", ")}" unless changed_paths.empty?
+      %i[criterion_version project_kind runner_args source_patterns test_patterns limits runtime].each do |key|
+        next if key == :criterion_version
+
+        left = metadata(@before, key)
+        right = metadata(@after, key)
+        if key == :runner_args
+          left = comparable_runner_args(left)
+          right = comparable_runner_args(right)
+        end
+        reasons << "#{key} differs" if !left.nil? && !right.nil? && left != right
+      end
+      reasons << "source selection differs" if source_selection(@before) != source_selection(@after)
+      reasons
+    end
+
+    def source_selection(document)
+      value(value(document, :run_metadata), :source_patterns)
+    end
+
+    def metadata_requirements
+      [@before, @after].each_with_index.filter_map do |document, index|
+        metadata = value(document, :run_metadata)
+        required = %i[project_kind source_patterns test_patterns test_files runner_args limits]
+        missing = required.reject { |key| metadata.is_a?(Hash) && !value(metadata, key).nil? }
+        missing << :runtime unless value(document, :runtime).is_a?(String) && !value(document, :runtime).empty?
+        if missing.empty?
+          nil
+        else
+          "#{index.zero? ? "before" : "after"} report missing run metadata: #{missing.join(", ")}"
+        end
+      end
+    end
+
+    def metadata(document, key)
+      value(value(document, :run_metadata), key) || value(document, key)
+    end
+
+    def complete_run?(document)
+      baseline = value(document, :baseline) || {}
+      completeness = value(document, :completeness) || {}
+      analysis = value(document, :analysis)
+      return false unless value(baseline, :status).to_s.upcase == "PASSED" && value(baseline, :finalized) == true
+      return false unless analysis.is_a?(Hash)
+
+      [completeness, value(analysis, :completeness),
+       value(value(document, :observations), :completeness)].all? do |section|
+        %i[observation attribution analysis].all? { |key| value(section, key) == true }
+      end
+    end
+
+    def summary(document)
+      { "run_id" => Array(value(value(document, :observations), :run_ids)).first,
+        "status" => value(value(document, :baseline), :status), "metrics" => value(document, :metrics),
+        "completeness" => value(document, :completeness), "run_metadata" => value(document, :run_metadata) }
+    end
+
+    def source_path(document, decision)
+      units = value(value(document, :source_inventory), :source_units)
+      source = Array(units).find { |item| value(item, :source_id).to_s == value(decision, :source_id).to_s }
+      value(source, :relative_path) || value(decision, :relative_path)
+    end
+
+    def digest(source) = value(source, :digest) || value(source, :content_digest)
+
+    def comparable_runner_args(args)
+      skip_next = false
+      Array(args).each_with_object([]) do |arg, result|
+        text = arg.to_s
+        if skip_next
+          skip_next = false
+          next
+        end
+        if ["--seed", "-s"].include?(text)
+          skip_next = true
+          next
+        end
+        next if text.start_with?("--seed=")
+
+        result << arg
+      end
+    end
+
+    def status(result, _document = nil)
+      text = value(result, :status).to_s.upcase
+      return text unless text.empty?
+
+      "UNKNOWN"
+    end
+
+    def value(hash, key)
+      return nil unless hash.respond_to?(:key?)
+
+      hash.key?(key) ? hash[key] : hash[key.to_s]
+    end
+  end
+end
+# rubocop:enable Metrics/ClassLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity

data/lib/branchproof/comparison_report.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+# rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+
+require "json"
+
+module Branchproof
+  # Renders the offline document returned by Comparison.
+  class ComparisonReport
+    def initialize(document:)
+      raise ArgumentError, "comparison document must be a Hash" unless document.is_a?(Hash)
+
+      @document = document
+    end
+
+    def write(io:, format:)
+      format = format.to_sym
+      raise ArgumentError, "format must be :terminal or :json" unless %i[terminal json].include?(format)
+
+      io.write(format == :json ? JSON.generate(@document) : terminal_document)
+      nil
+    end
+
+    def exit_code(fail_on_regression: false)
+      return 2 if status != "complete"
+      return 1 if fail_on_regression && regression?
+
+      0
+    end
+
+    private
+
+    def terminal_document
+      lines = ["Branchproof comparison", "Status: #{status}"]
+      reasons.each { |reason| lines << "Reason: #{reason}" }
+      Array(value(:context)).each { |item| lines << "Context: #{item}" }
+      lines << "Conditions: #{matching.fetch("matched_conditions",
+                                             0)} matched (denominator #{matching.fetch("denominator", 0)})"
+      lines << "Before: #{summary_status(before)}; After: #{summary_status(after)}"
+      lines << "Full-run totals: before #{totals(before)}; after #{totals(after)}"
+      before_total = "#{matching["before_proven"] || 0}/#{matching["denominator"] || 0}"
+      after_total = "#{matching["after_proven"] || 0}/#{matching["denominator"] || 0}"
+      lines << "Exact-match totals: before #{before_total} proven; after #{after_total} proven"
+      lines << "No comparable conditions." if matching.fetch("matched_conditions", 0).zero?
+      changed_sources.each { |source| lines << "Source changed: #{source["relative_path"]}" }
+      newly.each { |path| lines << "Newly in report: #{path}" }
+      removed.each { |path| lines << "No longer in report: #{path}" }
+      rendered_changes = changes.reject { |change| change["change"] == "unchanged" }
+      if rendered_changes.empty?
+        lines << "No comparable condition changes."
+      else
+        rendered_changes.each do |change|
+          location = if change["relative_path"].to_s.empty?
+                       "location unavailable"
+                     else
+                       "#{change["relative_path"]}:#{change["line"] || "condition line unavailable"}"
+                     end
+          lines << "#{change["change"].capitalize}: #{location} (condition #{change["index"]}) #{change["expression"]}"
+          next unless change["change"] == "lost proof"
+
+          owners = Array(change["previous_witness"]).flat_map { |witness| Array(witness["tests"]) }.uniq
+          lines << "  Previous owners: #{owners.empty? ? "unavailable" : owners.join(", ")}"
+          Array(change["previous_witness"]).each do |witness|
+            outcome = witness["outcome"] ? "T" : "F"
+            owners = Array(witness["tests"]).join(", ")
+            lines << "  Previous witness: [#{signs(witness["values"])}] => #{outcome} — #{owners}"
+          end
+          context = Array(change["owner_context"]).map do |item|
+            "#{item["label"]}: #{item["test_status"]}; [#{signs(item["values"])}] => " \
+              "#{item["outcome"] ? "T" : "F"} #{item["observation_status"]}"
+          end
+          lines << "  #{context.empty? ? "not observed in current run" : context.join(", ")}"
+        end
+      end
+      lines.join("\n") << "\n"
+    end
+
+    def status = value(:status).to_s
+
+    def signs(values)
+      Array(values).map do |item|
+        if item.nil?
+          "-"
+        else
+          (item ? "T" : "F")
+        end
+      end.join
+    end
+
+    def totals(summary)
+      metrics = value_from(summary, :metrics) || {}
+      "#{value_from(metrics,
+                    :proven) || "unknown"}/#{value_from(metrics, :eligible_conditions) || "unknown"} conditions proven"
+    end
+
+    def regression? = value(:regression) == true || value(:regressions).to_i.positive?
+    def reasons = Array(value(:reasons))
+    def matching = value(:matching) || {}
+    def before = value(:before) || {}
+    def after = value(:after) || {}
+    def changes = Array(value(:changes))
+    def changed_sources = Array(value(:changed_sources))
+    def newly = Array(value(:newly_in_report))
+    def removed = Array(value(:no_longer_in_report))
+
+    def summary_status(summary)
+      value_from(summary, :status).to_s.upcase.then { |item| item.empty? ? "unknown" : item }
+    end
+
+    def value(key) = value_from(@document, key)
+
+    def value_from(hash, key)
+      return nil unless hash.respond_to?(:key?)
+
+      hash.key?(key) ? hash[key] : hash[key.to_s]
+    end
+  end
+end
+# rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity

data/lib/branchproof/coverage_index.rb

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+# rubocop:disable Metrics/ClassLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity, Metrics/BlockLength
+
+require "pathname"
+
+module Branchproof
+  # Derives condition- and test-oriented rows from one report document.
+  class CoverageIndex
+    attr_reader :conditions, :tests
+
+    def initialize(document:)
+      @document = symbolize(document || {})
+      @inventory = symbolize(@document[:source_inventory] || @document[:inventory] || {})
+      @evidence = symbolize(@document[:observations] || @document[:evidence] || {})
+      @analysis = symbolize(@document[:analysis] || {})
+      @baseline = symbolize(@document[:baseline] || {})
+      @vectors = records(@evidence, :vectors)
+      @vectors_by_decision = @vectors.group_by { |vector| vector[:decision_id].to_s }
+      @vectors_by_id = @vectors.to_h { |vector| [vector[:id].to_s, vector] }
+      @analysis_by_decision = records(@analysis, :decisions).to_h { |decision| [decision[:decision_id].to_s, decision] }
+      @source_units_by_id = records(@inventory, :source_units).to_h { |unit| [unit[:source_id].to_s, unit] }
+      @test_locations = symbolize(@document[:run_metadata] || {})[:test_locations] || {}
+      @tests_by_id = {}
+      (records(@evidence, :tests) + records(@baseline, :tests)).each do |test|
+        id = test[:id].to_s
+        @tests_by_id[id] = (@tests_by_id[id] || {}).merge(test) unless id.empty?
+      end
+      @conditions = build_conditions.freeze
+      @tests = build_tests.freeze
+    end
+
+    private
+
+    def build_conditions
+      decisions = records(@inventory, :decisions)
+      rows = decisions.flat_map do |decision|
+        next [] if decision[:support_status].to_s == "UNSUPPORTED"
+
+        source = @source_units_by_id[decision[:source_id].to_s] || {}
+        result_map = records(analysis_for(decision), :condition_results).to_h do |result|
+          [result[:condition_id].to_s, result]
+        end
+        records(decision, :conditions).map do |condition|
+          condition = symbolize(condition)
+          result = symbolize(result_map[condition[:id].to_s] || {})
+          pair = Array(result[:canonical_pair])
+          vectors = @vectors_by_decision[decision[:id].to_s] || []
+          observations = { true => [], false => [], short_circuited: [], unattributed: [] }
+          vectors.each do |vector|
+            value = vector_values(vector)[condition[:index].to_i]
+            if value.nil?
+              observations[:short_circuited] << vector
+            elsif value == true
+              observations[true] << vector
+            elsif value == false
+              observations[false] << vector
+            end
+            observations[:unattributed] << vector if vector[:unattributed_count].to_i.positive?
+          end
+          {
+            id: condition[:id], decision_id: decision[:id], index: condition[:index],
+            expression: condition[:expression],
+            line: condition[:line], column: condition[:column], relative_path: relative_path(source[:relative_path]),
+            decision_expression: decision[:expression],
+            status: @document[:analysis] ? (result[:status] || "NOT_PROVEN") : "NOT CALCULATED",
+            observed_true: test_ids(observations[true]), observed_false: test_ids(observations[false]),
+            short_circuited: test_ids(observations[:short_circuited]),
+            unattributed: observations[:unattributed].sum { |vector| vector[:unattributed_count].to_i },
+            witness_vector_ids: pair, witness_owners: pair.flat_map { |id| owners_for(id) }.uniq.sort,
+            witness_owner_details: pair.flat_map { |id| owner_details_for(id) }.uniq.sort,
+            vectors: observations, constraint_result: result[:constraint_result],
+            supporting_set: supporting_set_for(decision[:id]), unexecuted: vectors.empty?
+          }
+        end
+      end
+      rows.sort_by do |row|
+        [row[:relative_path].to_s, row[:line].to_i, row[:column].to_i,
+         row[:decision_id].to_s, row[:index].to_i]
+      end
+    end
+
+    def build_tests
+      by_id = @tests_by_id.transform_values do |test|
+        { id: test[:id], name: display_name(test), relative_path: test_location(test)[0], line: test_location(test)[1],
+          status: test[:status], phases: Array(test[:phase_counts]).to_h.keys.sort,
+          observations: [], owns_witness: false }
+      end
+      @conditions.each do |condition|
+        condition[:vectors].each do |kind, vectors|
+          next if kind == :unattributed
+
+          vectors.each do |vector|
+            Array(vector[:test_ids]).each do |id|
+              row = by_id[id.to_s] ||= { id: id, name: id, relative_path: nil, line: nil, status: "unknown",
+                                         phases: [], observations: [], owns_witness: false }
+              phase_map = symbolize(vector[:phases_by_test] || {})
+              phases = phase_map[id.to_s] || phase_map[id.to_sym] || []
+              row[:phases] |= Array(phases).map(&:to_s)
+              row[:observations] << { condition_id: condition[:id], expression: condition[:expression],
+                                      relative_path: condition[:relative_path], line: condition[:line],
+                                      value: kind == :short_circuited ? nil : (kind == true), kind: kind,
+                                      phases: phases.map(&:to_s).sort,
+                                      owns_witness: condition[:witness_vector_ids].include?(vector[:id]) }
+              row[:owns_witness] = true if condition[:witness_vector_ids].include?(vector[:id])
+            end
+          end
+        end
+      end
+      by_id.each_value do |row|
+        row[:observations].uniq!
+        row[:phases] = row[:phases].map(&:to_s).uniq.sort
+      end
+      by_id.values.sort_by { |row| [row[:name].to_s, row[:relative_path].to_s, row[:line].to_i, row[:id].to_s] }
+    end
+
+    def analysis_for(decision)
+      @analysis_by_decision[decision[:id].to_s] || {}
+    end
+
+    def supporting_set_for(decision_id)
+      Array(@document[:minima] || @document["minima"]).filter_map do |minimum|
+        minimum = symbolize(minimum)
+        next unless minimum[:objective].to_s == "tests"
+        next unless Array(minimum[:scope_decision_ids]).map(&:to_s).include?(decision_id.to_s)
+
+        Array(minimum[:selected_ids]).map(&:to_s).sort
+      end.first || []
+    end
+
+    def owners_for(vector_id)
+      vector = @vectors_by_id[vector_id.to_s]
+      Array(vector && vector[:test_ids]).map { |id| display_name(@tests_by_id[id.to_s] || { id: id }) }
+    end
+
+    def owner_details_for(vector_id)
+      vector = @vectors_by_id[vector_id.to_s]
+      Array(vector && vector[:test_ids]).map do |id|
+        test = @tests_by_id[id.to_s] || { id: id }
+        name = display_name(test)
+        path, line = test_location(test)
+        path && line ? "#{name} (#{path}:#{line})" : name
+      end
+    end
+
+    def test_ids(vectors) = vectors.flat_map { |vector| Array(vector[:test_ids]) }.map(&:to_s).uniq.sort
+    def vector_values(vector) = Array(vector[:values])
+    def records(hash, key) = Array(hash[key] || hash[key.to_s]).map { |item| symbolize(item) }
+
+    def display_name(test)
+      return "#{test[:class_name]}##{test[:method_name]}" if test[:class_name] && test[:method_name]
+
+      (test[:name] || test[:id]).to_s
+    end
+
+    def test_location(test)
+      saved = symbolize(@test_locations[test[:id].to_s] || @test_locations[test[:id].to_sym] || {})
+      return [relative_path(saved[:relative_path]), saved[:line]] unless saved.empty?
+
+      source = symbolize(test[:source] || {})
+      path = source[:relative_path] || source[:path] || test[:source_path]
+      [relative_path(path), source[:line] || test[:line] || test[:source_line]]
+    end
+
+    def relative_path(path)
+      return nil if path.nil? || path.to_s.empty?
+      return path.to_s unless Pathname.new(path.to_s).absolute?
+
+      root = @inventory[:root] || symbolize(@document[:run_metadata] || {})[:project_root]
+      return nil unless root && Pathname.new(root.to_s).absolute?
+
+      Pathname.new(path.to_s).relative_path_from(Pathname.new(root.to_s)).to_s
+    rescue ArgumentError
+      nil
+    end
+
+    def symbolize(value)
+      case value
+      when Hash then value.each_with_object({}) { |(key, item), result| result[key.to_sym] = symbolize(item) }
+      when Array then value.map { |item| symbolize(item) }
+      else value
+      end
+    end
+  end
+end
+
+# rubocop:enable Metrics/ClassLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity, Metrics/BlockLength