branchproof 0.2.0 → 0.4.0

data/lib/branchproof/focused_report.rb

@@ -0,0 +1,205 @@
+# frozen_string_literal: true
+
+# rubocop:disable Metrics/ClassLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+require "pathname"
+
+module Branchproof
+  # Terminal renderings grouped around conditions or tests.
+  class FocusedReport
+    def initialize(document:, view:, level:, missing_only: false)
+      @document = document || {}
+      @view = view.to_sym
+      raise ArgumentError, "view must be :conditions or :tests" unless %i[conditions tests].include?(@view)
+
+      @level = level.to_i
+      @missing_only = missing_only ? true : false
+      @index = CoverageIndex.new(document: @document)
+      @tests = @index.tests.to_h { |test| [test[:id].to_s, test] }
+      @coordinator = Report.from_document(document: @document, level: @level)
+    end
+
+    def render
+      baseline = fetch(@document, :baseline) || {}
+      completeness = fetch(@document, :completeness) || {}
+      evidence = fetch(@document, :observations) || {}
+      lines = ["Branchproof focused view: #{@view}", "Tests: #{fetch(baseline, :status) || "INCOMPLETE"}",
+               "Values: T=true, F=false, -=short-circuited"]
+      if completeness.values.include?(false) || fetch(baseline, :status).to_s != "PASSED"
+        lines << "Warning: failed or incomplete run; observations and proof evidence may be unavailable."
+      end
+      aborts = fetch(evidence, :abort_counts)
+      abort_count = aborts.is_a?(Hash) ? aborts.values.sum(&:to_i) : aborts.to_i
+      if abort_count.positive?
+        lines << "Warning: #{abort_count} aborted observations; completed vectors do not describe aborted evaluations."
+      end
+      lines << "Empty groups mean no recorded completed observation."
+      lines << ""
+      @view == :conditions ? render_conditions(lines) : render_tests(lines)
+      render_unowned(lines)
+      render_unsupported(lines)
+      Array(fetch(@document, :diagnostics)).each do |diagnostic|
+        lines << "Diagnostic: #{fetch(diagnostic, :message) || fetch(diagnostic, :code)}"
+      end
+      lines.join("\n") << "\n"
+    end
+
+    private
+
+    def render_conditions(lines)
+      rows = @index.conditions
+      rows = rows.reject { |row| row[:status].to_s.upcase == "PROVEN" } if @missing_only && @level > 1
+      rows.each do |row|
+        lines << "Condition: #{row[:expression]}"
+        lines << "Location: #{location(row[:relative_path], row[:line], unavailable: "condition line unavailable")}"
+        lines << "Decision: #{row[:decision_expression]} (condition #{row[:index]})"
+        lines << "MC/DC: #{@level == 1 ? "NOT CALCULATED" : (row[:status] || "NOT_PROVEN")}"
+        render_group(lines, "Evaluated true by", row[:observed_true], row)
+        render_group(lines, "Evaluated false by", row[:observed_false], row)
+        render_group(lines, "Short-circuited in", row[:short_circuited], row)
+        lines << "  Unattributed observations: #{row[:unattributed]}" if row[:unattributed].to_i.positive?
+        if @level >= 2 && row[:supporting_set].any?
+          lines << "  Supporting test set: #{row[:supporting_set].map { |id| test_label(id) }.join(", ")}"
+          lines << "  Tests outside this MC/DC evidence set may provide other coverage."
+        end
+        render_constraint(lines, row) if @level >= 3 && row[:constraint_result]
+        if @level >= 3 && row[:witness_vector_ids].any?
+          lines << "  Witness observations (owners of example evidence):"
+          row[:witness_vector_ids].each do |id|
+            vector = row[:vectors].values.flatten.find { |item| item[:id].to_s == id.to_s }
+            next unless vector
+
+            owners = Array(vector[:test_ids]).map { |test_id| test_label(test_id) }.uniq.sort
+            owners << "unattributed" if vector[:unattributed_count].to_i.positive?
+            owners = owners.join(", ")
+            lines << "    [#{values(vector)}] => #{vector[:outcome] ? "T" : "F"} — #{owners}"
+          end
+        end
+        lines << ""
+      end
+      lines << "No missing conditions" if @missing_only && rows.empty?
+    end
+
+    def render_constraint(lines, row)
+      lines << @coordinator.condition_explanation(decision_id: row[:decision_id], condition_id: row[:id])
+    end
+
+    def render_group(lines, heading, ids, _row)
+      lines << "  #{heading}:"
+      if ids.empty?
+        lines << "    none recorded"
+      else
+        ids.each { |id| lines << "    #{test_label(id)}" }
+      end
+    end
+
+    def render_tests(lines)
+      rows = @index.tests
+      missing_ids = @index.conditions.reject { |row| row[:status].to_s.upcase == "PROVEN" }.map { |row| row[:id] }
+      rows.each { |row| render_test_row(lines, row, missing_ids) }
+    end
+
+    def render_test_row(lines, row, missing_ids)
+      observations = row[:observations]
+      if @missing_only
+        observations = observations.select { |observation| missing_ids.include?(observation[:condition_id]) }
+        return if observations.empty?
+      end
+      lines << "Test: #{row[:name]}"
+      lines << "Location: #{location(row[:relative_path], row[:line], unavailable: "location unavailable")}"
+      lines << "Status: #{row[:status] || "unknown"}"
+      lines << "Phases: #{row[:phases].join(", ")}" unless row[:phases].empty?
+      render_test_observations(lines, observations)
+      lines << ""
+    end
+
+    def render_test_observations(lines, observations)
+      if observations.empty?
+        lines << "  No recorded completed condition observations"
+        return
+      end
+      observations.group_by { |observation| observation[:condition_id] }.each_value do |items|
+        observation = items.first
+        observed_values = items.map { |item| item[:value] }.uniq
+        label = observed_values.all?(&:nil?) ? "short-circuited-only" : "evaluated"
+        label += "; owns canonical witness evidence" if @level > 1 && items.any? { |item| item[:owns_witness] }
+        phases = items.flat_map { |item| item[:phases] }.uniq.sort.join(", ")
+        signs = values(values: observed_values)
+        condition_location = location(observation[:relative_path], observation[:line],
+                                      unavailable: "condition line unavailable")
+        lines << "  #{observation[:expression]} (#{condition_location}): #{signs}; #{label}; " \
+                 "phases: #{phases}"
+      end
+    end
+
+    def render_unowned(lines)
+      rows = @index.conditions
+      rows = rows.reject { |row| row[:status] == "PROVEN" } if @missing_only
+      { "Unexecuted conditions" => rows.select { |row| row[:unexecuted] },
+        "Unattributed evidence" => rows.select { |row| row[:unattributed].positive? } }.each do |heading, conditions|
+        next if conditions.empty?
+
+        lines << "#{heading}:"
+        conditions.each do |row|
+          lines << "  #{row[:expression]} (#{location(row[:relative_path], row[:line],
+                                                      unavailable: "condition line unavailable")})"
+        end
+      end
+    end
+
+    def render_unsupported(lines)
+      inventory = fetch(@document, :source_inventory) || {}
+      sources = Array(fetch(inventory, :source_units)).to_h { |source| [fetch(source, :source_id), source] }
+      excluded = Array(fetch(inventory, :decisions)).select do |decision|
+        fetch(decision, :support_status) == "UNSUPPORTED"
+      end
+      return if excluded.empty?
+
+      lines << "Unsupported conditions (MC/DC unavailable):"
+      excluded.each do |decision|
+        source = sources[fetch(decision, :source_id)] || {}
+        path = fetch(source, :relative_path)
+        path = nil if path && Pathname.new(path).absolute?
+        conditions = Array(fetch(decision, :conditions))
+        conditions = [{ expression: fetch(decision, :expression) }] if conditions.empty?
+        conditions.each do |condition|
+          label = location(path, fetch(condition, :line), unavailable: "condition line unavailable")
+          lines << "  #{fetch(condition, :expression)} (#{label})"
+        end
+      end
+    end
+
+    def location(path, line, unavailable: "location unavailable")
+      return "location unavailable" if path.to_s.empty?
+      return "#{path}: #{unavailable}" if line.nil?
+
+      "#{path}:#{line}"
+    end
+
+    def values(vector)
+      Array(vector[:values]).map do |item|
+        if item.nil?
+          "-"
+        else
+          (item ? "T" : "F")
+        end
+      end.join
+    end
+
+    def test_label(id)
+      test = @tests[id.to_s]
+      return id.to_s unless test
+
+      label = "#{test[:name]} (#{location(test[:relative_path], test[:line])})"
+      duplicates = @index.tests.count do |row|
+        [row[:name], row[:relative_path], row[:line]] == [test[:name], test[:relative_path], test[:line]]
+      end
+      duplicates > 1 ? "#{label} [#{id}]" : label
+    end
+
+    def fetch(hash, 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/report.rb

@@ -1,15 +1,19 @@
 # frozen_string_literal: true
 
 require "json"
+require "pathname"
 
 module Branchproof
   # Renders versioned terminal and JSON analysis reports.
   class Report
-    SCHEMA_VERSION = "1.0"
+    SCHEMA_VERSION = "1.1"
     CRITERION_VERSION = "masking_occurrence_v1"
 
-    def initialize(inventory:, evidence:, analysis:, minima:, baseline:, diagnostics:, level: 3)
+    def initialize(inventory:, evidence:, analysis:, minima:, baseline:, diagnostics:, level: 3, missing_only: false,
+                   view: :decisions, run_metadata: {}, saved_document: nil)
       raise ArgumentError, "level must be 1, 2, or 3" unless [1, 2, 3].include?(level.to_i)
+      raise ArgumentError, "view must be :decisions, :conditions, or :tests" unless %i[decisions conditions
+                                                                                       tests].include?(view.to_sym)
 
       @inventory = inventory || {}
       @evidence = evidence || {}
@@ -18,6 +22,20 @@ module Branchproof
       @baseline = baseline || {}
       @diagnostics = Array(diagnostics)
       @level = level.to_i
+      @missing_only = missing_only ? true : false
+      @view = view.to_sym
+      @run_metadata = run_metadata || {}
+      @saved_document = saved_document
+    end
+
+    def self.from_document(document:, level: nil, view: :decisions, missing_only: false)
+      data = document || {}
+      new(inventory: data[:source_inventory] || data["source_inventory"] || data[:inventory] || data["inventory"],
+          evidence: data[:observations] || data["observations"] || data[:evidence] || data["evidence"],
+          analysis: data[:analysis] || data["analysis"], minima: data[:minima] || data["minima"],
+          baseline: data[:baseline] || data["baseline"], diagnostics: data[:diagnostics] || data["diagnostics"],
+          level: level || (data[:analysis] || data["analysis"] ? 3 : 1), view: view, missing_only: missing_only,
+          run_metadata: data[:run_metadata] || data["run_metadata"], saved_document: data)
     end
 
     def write(io:, format:)
@@ -28,6 +46,18 @@ module Branchproof
       nil
     end
 
+    # Shares the existing missing-case wording with focused terminal views.
+    def condition_explanation(decision_id:, condition_id:)
+      decision = inventory_decisions.find { |item| value(item, :id).to_s == decision_id.to_s }
+      return "" unless decision
+
+      condition = Array(value(decision, :conditions)).find { |item| value(item, :id).to_s == condition_id.to_s }
+      return "" unless condition
+
+      @terminal_ids ||= terminal_ids
+      condition_detail(decision, condition, condition_result(decision, condition))
+    end
+
     def exit_code
       return 2 unless usage_valid?
 
@@ -35,6 +65,7 @@ module Branchproof
       return 2 if %w[ERROR INCOMPLETE].include?(status)
       return 1 if status == "FAILED"
       return 2 unless status == "PASSED" && value(@baseline, :finalized) == true
+      return 2 if @saved_document && (value(@saved_document, :completeness) || {}).values.include?(false)
       return 2 unless metrics[:eligible_conditions].positive?
       return 2 unless valid_for_requested_level?
 
@@ -44,16 +75,24 @@ module Branchproof
     private
 
     def json_document
+      return normalize(@saved_document) if @saved_document
+
       normalize(schema_version: SCHEMA_VERSION,
                 tool_version: (defined?(Branchproof::VERSION) ? Branchproof::VERSION : "unknown"),
                 criterion_version: CRITERION_VERSION, runtime: RUBY_DESCRIPTION,
                 run_ids: Array(value(@evidence, :run_ids)),
                 source_inventory: @inventory, baseline: @baseline, observations: @evidence,
                 analysis: @level == 1 ? nil : @analysis, minima: @minima, metrics: metrics,
-                diagnostics: @diagnostics, completeness: completeness)
+                diagnostics: @diagnostics, completeness: completeness,
+                run_metadata: @run_metadata)
     end
 
     def terminal_document
+      unless @view == :decisions
+        return FocusedReport.new(document: json_document, view: @view, level: @level,
+                                 missing_only: @missing_only).render
+      end
+
       @terminal_ids = terminal_ids
       lines = ["Branchproof #{defined?(Branchproof::VERSION) ? Branchproof::VERSION : "unknown"}",
                "Tests: #{baseline_status} (#{baseline_test_counts})",
@@ -64,10 +103,11 @@ module Branchproof
                "Observations: #{metrics[:completed]} completed, #{metrics[:aborted]} aborted, " \
                "#{metrics[:unattributed]} unattributed",
                "Values: T=true, F=false, -=short-circuited"]
+      lines << missing_summary_line if @missing_only
       lines << "Scope: supported decisions and conditions"
       lines << ""
-      inventory_decisions.each { |decision| render_decision(lines, decision) }
-      render_minima(lines)
+      decisions_to_render.each { |decision| render_decision(lines, decision) }
+      render_minima(lines) unless @missing_only
       unless @diagnostics.empty?
         lines << "Diagnostics:"
         @diagnostics.each { |diagnostic| lines << "  - #{value(diagnostic, :message) || value(diagnostic, :code)}" }
@@ -82,9 +122,9 @@ module Branchproof
       lines << decision_label
       lines << "  Decision: #{value(decision, :expression)}"
       lines << "  Status: #{value(decision, :support_status) || "SUPPORTED"}"
-      Array(value(decision, :conditions)).each do |condition|
+      conditions_to_render(decision).each do |condition|
         result = condition_result(decision, condition)
-        detail = condition_detail(result)
+        detail = condition_detail(decision, condition, result)
         status = if @analysis.nil? || @level == 1
                    "NOT CALCULATED"
                  else
@@ -93,7 +133,7 @@ module Branchproof
         lines << "  Condition #{value(condition, :index)}: #{value(condition, :expression)}"
         lines << "    #{status}#{detail}"
       end
-      vectors_for(decision).each do |vector|
+      vectors_to_render(decision).each do |vector|
         values = Array(value(vector, :values)).map do |item|
           if item.nil?
             "-"
@@ -169,6 +209,11 @@ module Branchproof
           [value(result, :condition_id), *Array(value(result, :canonical_pair))]
         end
       end)
+      ids.concat(Array(value(@analysis, :decisions)).flat_map do |decision|
+        Array(value(decision, :condition_results)).flat_map do |result|
+          Array(value(value(result, :constraint_result), :candidate_vectors)).map { |vector| value(vector, :id) }
+        end
+      end)
       ids = ids.compact.map(&:to_s).reject(&:empty?).uniq
       by_prefix = ids.group_by { |id| id[0, 8] }
       ids.to_h do |id|
@@ -217,17 +262,32 @@ module Branchproof
     end
 
     def test_location(test)
+      saved_location = value(value(@run_metadata, :test_locations), value(test, :id))
+      return [relative_test_path(value(saved_location, :relative_path)), value(saved_location, :line)] if saved_location
+
       location = value(test, :source)
       source_line = nil
       if location.respond_to?(:key?)
         source_line = value(location, :line)
-        location = value(location, :path) || value(location, :relative_path)
+        location = value(location, :relative_path) || value(location, :path)
       end
       location ||= value(test, :source_path)
+      location = relative_test_path(location)
       line = value(test, :line) || value(test, :source_line) || source_line
       [location, line]
     end
 
+    def relative_test_path(path)
+      return path unless path && Pathname.new(path.to_s).absolute?
+
+      root = value(@inventory, :root) || value(@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 minimum_member_label(objective, id)
       objective.to_s == "tests" ? test_label(id) : short_id(id)
     end
@@ -264,24 +324,104 @@ module Branchproof
       end
     end
 
-    def condition_detail(result)
-      return "" unless result && @level == 3
+    def condition_detail(decision, _condition, result)
+      return "" unless result && (@level == 3 || @missing_only)
 
       pair = value(result, :canonical_pair)
       return " (witness #{Array(pair).map { |id| short_id(id) }.join(" + ")})" if pair
 
       constraint = value(result, :constraint_result)
       if constraint
-        constraints = Array(value(constraint, :constraints)).map { |item| item.is_a?(Hash) ? item.inspect : item.to_s }
+        constraints = readable_constraints(decision, constraint)
         detail = constraints.empty? ? value(constraint, :status) : constraints.join(", ")
         statement = value(constraint, :feasibility_statement)
         detail = [detail, statement].compact.reject(&:empty?).join("; ")
+        candidates = Array(value(constraint, :candidate_vectors))
+        existing = existing_vector_for(constraint)
+        unless candidates.empty?
+          detail_lines = [" — missing observation"]
+          candidates.each do |candidate|
+            detail_lines << "      Need an observation where:"
+            detail_lines.concat(candidate_requirements(decision, candidate).map { |item| "        #{item}" })
+            outcome = value(candidate, :outcome) ? "true" : "false"
+            detail_lines << "        Expected decision: #{outcome} [#{vector_values(candidate)}]"
+          end
+          detail_lines << "      #{statement}" unless statement.to_s.empty?
+          detail_lines << "      Compare with: #{existing_vector_context(existing)}"
+          return detail_lines.join("\n")
+        end
+        unless existing.nil?
+          owner_ids = Array(value(existing, :test_ids))
+          owners = owner_ids.first(2).map { |id| test_label(id) }
+          owners << "#{owner_ids.length - 2} more" if owner_ids.length > 2
+          owner_detail = owners.empty? ? nil : " (#{owners.join(", ")})"
+          detail = [detail, "existing observation: #{short_id(value(existing, :id))}#{owner_detail}"].compact.join("; ")
+        end
         return " (missing counterpart: #{detail})" unless detail.empty?
       end
 
       ""
     end
 
+    def readable_constraints(decision, constraint)
+      Array(value(constraint, :constraints)).filter_map do |item|
+        if item.respond_to?(:key?)
+          index = value(item, :condition_index)
+          expression = condition_expression(decision, index) || "condition #{index}"
+          required = value(item, :required)
+          required = value(item, :value) if required.nil?
+          "requires #{expression}=#{required ? "true" : "false"}"
+        else
+          item.to_s
+        end
+      end
+    end
+
+    def condition_expression(decision, index)
+      condition = Array(value(decision, :conditions)).find { |item| value(item, :index).to_i == index.to_i }
+      value(condition, :expression)
+    end
+
+    def candidate_requirements(decision, candidate)
+      Array(value(candidate, :values)).each_with_index.map do |required, index|
+        expression = condition_expression(decision, index) || "condition #{index}"
+        if required.nil?
+          "#{expression} is not evaluated (short-circuited)"
+        else
+          "#{expression} is #{required ? "truthy" : "falsey"}"
+        end
+      end
+    end
+
+    def vector_values(vector)
+      Array(value(vector, :values)).map do |item|
+        if item.nil?
+          "-"
+        elsif item
+          "T"
+        else
+          "F"
+        end
+      end.join
+    end
+
+    def existing_vector_context(existing)
+      return "no existing effective observation" unless existing
+
+      owner_ids = Array(value(existing, :test_ids))
+      owners = owner_ids.first(2).map { |id| test_label(id) }
+      owners << "#{owner_ids.length - 2} more" if owner_ids.length > 2
+      context = "[#{vector_values(existing)}] => #{value(existing, :outcome) ? "true" : "false"}"
+      owners.empty? ? context : "#{context} (#{owners.join(", ")})"
+    end
+
+    def existing_vector_for(constraint)
+      id = value(constraint, :existing_vector_id).to_s
+      return if id.empty?
+
+      vectors.find { |vector| value(vector, :id).to_s == id }
+    end
+
     def metrics
       decisions = inventory_decisions
       unsupported, supported = decisions.partition { |decision| unsupported?(decision) }
@@ -349,6 +489,50 @@ module Branchproof
       end
     end
 
+    def decisions_to_render
+      return inventory_decisions unless @missing_only
+      return [] unless analysis_available?
+
+      inventory_decisions
+        .reject { |decision| unsupported?(decision) }
+        .select { |decision| conditions_to_render(decision).any? }
+    end
+
+    def conditions_to_render(decision)
+      conditions = Array(value(decision, :conditions))
+      return conditions unless @missing_only && analysis_available?
+
+      conditions.reject { |condition| value(condition_result(decision, condition), :status).to_s.upcase == "PROVEN" }
+    end
+
+    def vectors_to_render(decision)
+      return vectors_for(decision) unless @missing_only
+
+      []
+    end
+
+    def analysis_available?
+      !@analysis.nil? && @level > 1
+    end
+
+    def analysis_complete?
+      analysis_available? && baseline_status == "PASSED" && completeness.values.all?
+    end
+
+    def missing_condition_count
+      decisions_to_render.sum { |decision| conditions_to_render(decision).length }
+    end
+
+    def missing_summary_line
+      return "Missing conditions: Cannot identify missing conditions (analysis unavailable)" unless analysis_available?
+      return "Missing conditions: Cannot identify missing conditions (analysis incomplete)" unless analysis_complete?
+      return "No eligible conditions" if metrics[:eligible_conditions].zero?
+      return "No missing conditions" if analysis_complete? && missing_condition_count.zero?
+
+      count = decisions_to_render.length
+      "Missing conditions: #{missing_condition_count} across #{count} #{count == 1 ? "decision" : "decisions"}"
+    end
+
     def analysis_for(decision)
       Array(value(@analysis, :decisions)).find do |item|
         value(item, :decision_id).to_s == value(decision, :id).to_s