branchproof 0.6.0 → 0.8.0

data/lib/branchproof/report.rb

@@ -1,19 +1,26 @@
 # frozen_string_literal: true
 
+# rubocop:disable Metrics/BlockLength
+
 require "json"
 require "pathname"
 
 module Branchproof
   # Renders versioned terminal and JSON analysis reports.
   class Report
-    SCHEMA_VERSION = "1.1"
+    SCHEMA_VERSION = "1.3"
     CRITERION_VERSION = "masking_occurrence_v1"
+    VIEWS = %i[decisions conditions tests decision_tables].freeze
+    DECISION_TABLE_LABELS = { "true" => "T", "false" => "F", "dont_care" => "-" }.freeze
+    DECISION_TABLE_STATUS_LABELS = { "covered" => "COVERED", "missing" => "MISSING",
+                                     "excluded" => "EXCLUDED" }.freeze
 
     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)
+      unless VIEWS.include?(view.to_sym)
+        raise ArgumentError, "view must be :decisions, :conditions, :tests, or :decision_tables"
+      end
 
       @inventory = inventory || {}
       @evidence = evidence || {}
@@ -30,8 +37,8 @@ module Branchproof
 
     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"],
+      new(inventory: data[:source_inventory] || data["source_inventory"],
+          evidence: data[:observations] || data["observations"],
           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,
@@ -103,7 +110,9 @@ module Branchproof
       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?
+
+      eligible = metrics[:eligible_conditions].positive? || metrics[:eligible_alternatives].positive?
+      return 2 unless eligible
       return 2 unless valid_for_requested_level?
 
       0
@@ -118,7 +127,7 @@ module Branchproof
                 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,
+                source_inventory: inventory_with_default_kinds, baseline: @baseline, observations: @evidence,
                 analysis: @analysis, minima: @minima, metrics: metrics,
                 diagnostics: @diagnostics, completeness: completeness,
                 run_metadata: @run_metadata)
@@ -127,7 +136,7 @@ module Branchproof
     def terminal_document
       unless @view == :decisions
         return FocusedReport.new(document: json_document, view: @view, level: @level,
-                                 missing_only: @missing_only).render
+                                 missing_only: @missing_only, coordinator: self).render
       end
 
       @terminal_ids = terminal_ids
@@ -137,12 +146,13 @@ module Branchproof
                "Analysis: #{terminal_analysis_status}",
                "Decisions: #{metrics[:supported]} supported, #{metrics[:unsupported]} excluded, " \
                "#{metrics[:unexecuted]} unexecuted (#{metrics[:discovered]} discovered)",
+               decision_kind_summary_line,
                "Observations: #{metrics[:completed]} completed, #{metrics[:aborted]} aborted, " \
                "#{metrics[:unattributed]} unattributed",
-               "Values: T=true, F=false, -=short-circuited"]
+               values_legend]
       lines.concat(coverage_ladder_lines)
       lines << missing_summary_line if @missing_only
-      lines << "Scope: supported decisions and conditions"
+      lines << "Scope: supported decisions, conditions, and alternatives"
       lines << ""
       decisions_to_render.each { |decision| render_decision(lines, decision) }
       render_minima(lines) unless @missing_only
@@ -159,20 +169,26 @@ module Branchproof
       decision_label = "Decision #{short_id(value(decision, :id))} #{filename}:#{value(decision, :line)}"
       lines << decision_label
       lines << "  Decision: #{value(decision, :expression)}"
+      lines << "  Kind: #{decision_kind(decision)}"
+      context = value(decision, :context)
+      lines << "  Context: #{context}" unless context.nil? || context.to_s.empty?
       lines << "  Status: #{value(decision, :support_status) || "SUPPORTED"}"
-      conditions_to_render(decision).each do |condition|
-        result = condition_result(decision, condition)
-        detail = condition_detail(decision, condition, result)
-        status = if @analysis.nil? || (@level == 1 && !coverage_available?)
-                   "NOT CALCULATED"
-                 else
-                   value(result, :status) || "NOT_PROVEN"
-                 end
-        lines << "  Condition #{value(condition, :index)}: #{value(condition, :expression)}"
-        lines << "    #{status}#{detail}"
-        render_condition_coverage(lines, decision, condition, result) if @level >= 2 && coverage_available?
+      unless nonboolean_decision?(decision)
+        conditions_to_render(decision).each do |condition|
+          result = condition_result(decision, condition)
+          detail = condition_detail(decision, condition, result)
+          status = if @analysis.nil? || (@level == 1 && !coverage_available?)
+                     "NOT CALCULATED"
+                   else
+                     value(result, :status) || "NOT_PROVEN"
+                   end
+          lines << "  Condition #{value(condition, :index)}: #{value(condition, :expression)}"
+          lines << "    #{status}#{detail}"
+          render_condition_coverage(lines, decision, condition, result) if @level >= 2 && coverage_available?
+        end
       end
       render_decision_coverage(lines, decision) if coverage_available?
+      render_decision_table(lines, decision) if analysis_available? && !nonboolean_decision?(decision)
       vectors_to_render(decision).each do |vector|
         values = Array(value(vector, :values)).map do |item|
           if item.nil?
@@ -183,8 +199,23 @@ module Branchproof
         end.join
         owners = Array(value(vector, :test_ids)).map { |test_id| test_label(test_id) }
         owners << "unattributed" if value(vector, :unattributed_count).to_i.positive?
-        vector_label = "  Vector #{short_id(value(vector, :id))} [#{values}] => " \
-                       "#{value(vector, :outcome) ? "T" : "F"}"
+        vector_label = if nonboolean_decision?(decision)
+                         selected = Array(value(vector, :values)).each_with_index.filter_map do |item, index|
+                           next unless item
+
+                           alternative = Array(value(decision, :alternatives))[index]
+                           value(alternative, :expression) || "alternative #{index}"
+                         end
+                         "  Vector #{short_id(value(vector, :id))} [#{values}] => selected: #{selected.join(", ")}"
+                       else
+                         "  Vector #{short_id(value(vector,
+                                                    :id))} [#{values}] => " + (if value(vector,
+                                                                                        :outcome)
+                                                                                 "T"
+                                                                               else
+                                                                                 "F"
+                                                                               end).to_s
+                       end
         lines << "#{vector_label} owners=#{owners.join(", ")}"
       end
       lines << ""
@@ -197,10 +228,15 @@ module Branchproof
     end
 
     def render_decision_coverage(lines, decision)
+      if nonboolean_decision?(decision)
+        render_alternative_coverage(lines, decision)
+        return
+      end
+
       decision_coverage = value(value(analysis_for(decision), :coverage), :decision)
       all_coverage = value(analysis_for(decision), :coverage) || {}
       statuses = [["D", :decision], ["C", :condition], ["C/D", :condition_decision],
-                  ["MC/DC", :mcdc]].filter_map do |label, key|
+                  ["MC/DC", :mcdc], ["DT", :decision_table]].filter_map do |label, key|
         row = value(all_coverage, key)
         status = value(row, :status)
         status ? criterion_status_text(label, row) : nil
@@ -212,11 +248,11 @@ module Branchproof
       return unless @level >= 2
 
       Array(value(coverage, :outcomes)).each do |outcome|
-        value_label = value(outcome, :value) ? "true" : "false"
+        value_label = decision_outcome_label(decision, value(outcome, :value))
         owners = Array(value(outcome, :test_ids)).map { |id| test_label(id) }
         owners << "unattributed" if value(outcome, :unattributed_count).to_i.positive?
         evidence = owners.empty? ? "none recorded" : owners.uniq.join(", ")
-        lines << "  Outcome #{value_label}: #{value(outcome, :observed) ? "observed" : "missing"}; tests: #{evidence}"
+        lines << "  #{value_label}: #{value(outcome, :observed) ? "observed" : "missing"}; tests: #{evidence}"
       end
       missing = Array(value(coverage, :missing_outcomes))
       return if missing.empty?
@@ -226,6 +262,209 @@ module Branchproof
       end.join(", ")}"
     end
 
+    # Renders the reduced decision table, its runtime overlay, and the
+    # actionable detail for rules that no observation reached.
+    def render_decision_table(lines, decision)
+      table = decision_table_for(decision)
+      return unless table
+
+      unless value(table, :status).to_s == "calculated"
+        return if value(table, :reason).to_s == "unsupported_decision" && unsupported?(decision)
+
+        lines << "  Decision Table: NOT CALCULATED"
+        lines << "  Reason: #{value(table, :reason)}"
+        return
+      end
+
+      covered = value(table, :covered_rules).to_i
+      required = value(table, :required_rules).to_i
+      percentage = value(table, :percentage)
+      lines << "  Decision Table: #{covered}/#{required} rules covered" \
+               "#{" (#{percentage}%)" unless percentage.nil?}"
+      impossible = value(table, :impossible_rules).to_i
+      lines << "  Statically impossible rules excluded: #{impossible}" if impossible.positive?
+      lines << "  Reachability: not analyzed" unless value(table, :reachability_analyzed)
+      rules = decision_table_rules_to_render(table)
+      lines.concat(decision_table_rows(decision, rules))
+      return unless @level >= 2
+
+      rules.each { |rule| render_decision_table_rule(lines, decision, rule) }
+    end
+
+    def decision_table_rows(decision, rules)
+      return [] if rules.empty?
+
+      conditions = Array(value(decision, :conditions))
+      header = ["Rule"] + conditions.map { |condition| truncate(value(condition, :expression).to_s, 24) } +
+               %w[Result Status]
+      body = rules.map do |rule|
+        [value(rule, :label).to_s] +
+          Array(value(rule, :conditions)).map { |item| DECISION_TABLE_LABELS.fetch(item.to_s, item.to_s) } +
+          [value(rule, :outcome) ? "T" : "F", decision_table_rule_status(rule)]
+      end
+      return [] unless body.all? { |row| row.length == header.length }
+
+      widths = ([header] + body).transpose.map { |column| column.map(&:length).max }
+      ([header] + body).map do |row|
+        "    #{row.each_with_index.map { |cell, index| cell.ljust(widths[index]) }.join("  ").rstrip}"
+      end
+    end
+
+    def decision_table_rule_status(rule)
+      DECISION_TABLE_STATUS_LABELS.fetch(value(rule, :coverage).to_s, value(rule, :coverage).to_s.upcase)
+    end
+
+    def render_decision_table_rule(lines, decision, rule)
+      case value(rule, :coverage).to_s
+      when "covered" then render_covered_rule(lines, rule)
+      when "excluded" then lines.concat(impossible_rule_lines(rule))
+      else lines.concat(missing_rule_lines(decision, rule))
+      end
+    end
+
+    def render_covered_rule(lines, rule)
+      owners = Array(value(rule, :tests)).map { |id| test_label(id) }
+      owners << "unattributed" if value(rule, :unattributed_count).to_i.positive?
+      lines << "    #{value(rule, :label)} tests: #{owners.empty? ? "none recorded" : owners.uniq.join(", ")}"
+      return unless value(rule, :impossible_withdrawn)
+
+      lines << "    #{value(rule, :label)} note: runtime evidence overrides the static impossibility claim " \
+               "(#{value(rule, :withdrawn_reason)}); diagnostic constraint_model_conflict"
+    end
+
+    # Impossible rules stay visible even though they leave the denominator.
+    def impossible_rule_lines(rule)
+      ["    #{value(rule, :label)} #{rule_signature(rule)}",
+       "    Status:", "      EXCLUDED",
+       "    Reachability:", "      STATICALLY IMPOSSIBLE",
+       "    Reason:", "      #{Constraints.message(value(rule, :reachability_reason))}"]
+    end
+
+    # Condition values only: Branchproof never claims which application inputs
+    # would produce them.
+    def missing_rule_lines(decision, rule)
+      requirements = decision_table_requirements(decision, rule)
+      width = requirements.map { |name, _| name.length }.max.to_i
+      lines = ["    #{value(rule, :label)}", "    Need:"]
+      requirements.each { |name, requirement| lines << "      #{name.ljust(width)} #{requirement}" }
+      lines << "    #{decision_table_expected_heading(decision)}"
+      lines << "      #{value(rule, :outcome) ? "true" : "false"}"
+      lines << "    Reachability:"
+      lines << "      #{decision_table_reachability(rule)}"
+      lines
+    end
+
+    def decision_table_requirements(decision, rule)
+      Array(value(rule, :conditions)).each_with_index.map do |required, index|
+        expression = condition_expression(decision, index) || "condition #{index}"
+        requirement = decision_table_requirement(required) || "not evaluated (short-circuited)"
+        [expression.to_s, "= #{requirement}"]
+      end
+    end
+
+    def decision_table_requirement(value)
+      case value.to_s
+      when "true" then "truthy"
+      when "false" then "falsey"
+      end
+    end
+
+    def decision_table_reachability(rule)
+      return "STATICALLY IMPOSSIBLE" if value(rule, :reachability).to_s == "statically_impossible"
+
+      value(rule, :reachability).to_s
+    end
+
+    def decision_outcome_label(decision, outcome)
+      prefix = %w[unless until].include?(value(decision, :context).to_s) ? "Predicate" : "Outcome"
+      "#{prefix} #{outcome ? "true" : "false"}"
+    end
+
+    def decision_table_expected_heading(decision)
+      %w[unless until].include?(value(decision, :context).to_s) ? "Expected predicate:" : "Expected decision:"
+    end
+
+    def rule_signature(rule)
+      values = Array(value(rule, :conditions)).map { |item| DECISION_TABLE_LABELS.fetch(item.to_s, item.to_s) }
+      "#{values.join} => #{value(rule, :outcome) ? "T" : "F"}"
+    end
+
+    def decision_table_rules_to_render(table)
+      rules = Array(value(table, :rules))
+      return rules unless @missing_only
+
+      rules.select { |rule| value(rule, :coverage).to_s == "missing" }
+    end
+
+    def decision_table_for(decision)
+      value(analysis_for(decision), :decision_table)
+    end
+
+    def missing_decision_table_rules(decision)
+      table = decision_table_for(decision)
+      return [] unless table && value(table, :status).to_s == "calculated"
+
+      Array(value(table, :rules)).select { |rule| value(rule, :coverage).to_s == "missing" }
+    end
+
+    def decision_table_unavailable?(decision)
+      table = decision_table_for(decision)
+      table && value(table, :status).to_s != "calculated"
+    end
+
+    def unavailable_decision_table_count
+      inventory_decisions.count { |decision| decision_table_unavailable?(decision) }
+    end
+
+    def truncate(text, width)
+      text.length <= width ? text : "#{text[0, width - 3]}..."
+    end
+
+    def render_alternative_coverage(lines, decision)
+      coverage = value(value(analysis_for(decision), :coverage), :alternative) || {}
+      status = value(coverage, :status)
+      required = value(coverage, :required_alternatives) || Array(value(decision, :alternatives)).length
+      covered = value(coverage, :covered_alternatives) || 0
+      lines << "  Alternatives: #{status || "NOT_CALCULATED"} (#{covered}/#{required})"
+      lines << "  MC/DC: N/A (not applicable)"
+      rows = Array(value(coverage, :alternatives))
+      rows_by_id = rows.to_h { |row| [value(row, :alternative_id).to_s, row] }
+      alternatives_to_render(decision).each do |alternative|
+        id = value(alternative, :id)
+        row = rows_by_id[id.to_s] || {}
+        lines << "  Alternative #{value(alternative, :index)}: #{value(alternative, :expression)}"
+        render_alternative_state(lines, "Selected", value(row, :selected)) if @level >= 2
+        render_alternative_state(lines, "Not selected", value(row, :not_selected)) if @level >= 2
+        render_alternative_state(lines, "Skipped", value(row, :skipped)) if @level >= 2
+      end
+      missing = Array(value(coverage, :missing_alternatives))
+      return if missing.empty?
+
+      labels = missing.map do |id|
+        alternative = Array(value(decision, :alternatives)).find { |item| value(item, :id).to_s == id.to_s }
+        value(alternative, :expression) || short_id(id)
+      end
+      label = labels.join(", ")
+      lines << "  Missing alternatives: #{label}"
+      lines << "  Need selection of: #{label}"
+    end
+
+    def render_alternative_state(lines, label, evidence)
+      evidence ||= {}
+      owners = Array(value(evidence, :test_ids)).map { |id| test_label(id) }
+      owners << "unattributed" if value(evidence, :unattributed_count).to_i.positive?
+      owners = owners.uniq
+      status = if value(evidence, :observed)
+                 "observed"
+               elsif label == "Selected"
+                 "missing"
+               else
+                 "none recorded"
+               end
+      detail = owners.empty? ? "none recorded" : owners.join(", ")
+      lines << "    #{label}: #{status}; tests: #{detail}"
+    end
+
     def render_condition_coverage(lines, _decision, condition, result)
       coverage = value(result, :coverage)
       return unless coverage
@@ -417,8 +656,15 @@ module Branchproof
     end
 
     def condition_result(decision, condition)
-      Array(value(analysis_for(decision), :condition_results)).find do |item|
-        value(item, :condition_id).to_s == value(condition, :id).to_s
+      condition_results_index.dig(value(decision, :id).to_s, value(condition, :id).to_s)
+    end
+
+    def condition_results_index
+      @condition_results_index ||= Array(value(@analysis, :decisions)).each_with_object({}) do |item, index|
+        by_condition_id = index[value(item, :decision_id).to_s] ||= {}
+        Array(value(item, :condition_results)).each do |result|
+          by_condition_id[value(result, :condition_id).to_s] = result
+        end
       end
     end
 
@@ -517,34 +763,92 @@ module Branchproof
       id = value(constraint, :existing_vector_id).to_s
       return if id.empty?
 
-      vectors.find { |vector| value(vector, :id).to_s == id }
+      vectors_by_id[id]
+    end
+
+    def vectors_by_id
+      @vectors_by_id ||= vectors.to_h { |vector| [value(vector, :id).to_s, vector] }
+    end
+
+    def values_legend
+      return "Values: T=true, F=false, -=short-circuited" unless inventory_decisions.any? do |decision|
+        nonboolean_decision?(decision)
+      end
+
+      "Values: Boolean T=true/F=false; flow T=selected, F=not-selected, -=skipped"
+    end
+
+    def inventory_with_default_kinds
+      decisions = inventory_decisions.map do |decision|
+        next decision if value(decision, :kind)
+
+        decision.respond_to?(:key?) ? decision.merge(kind: "boolean") : decision
+      end
+      return @inventory unless value(@inventory, :decisions)
+
+      @inventory.merge(decisions: decisions)
+    end
+
+    def decision_kind(decision)
+      kind = value(decision, :kind).to_s
+      kind.empty? ? "boolean" : kind
+    end
+
+    def nonboolean_decision?(decision)
+      %w[implicit multiway pattern exception].include?(decision_kind(decision))
+    end
+
+    def decision_kind_summary_line
+      counts = metrics[:kind_counts]
+      return "Decision kinds: none" if counts.empty?
+
+      contexts = metrics[:context_counts]
+      suffix = if contexts.empty?
+                 ""
+               else
+                 "; contexts: #{contexts.map do |context, count|
+                   "#{context}=#{count}"
+                 end.join(", ")}"
+               end
+      "Decision kinds: #{counts.map { |kind, count| "#{kind}=#{count}" }.join(", ")}#{suffix}"
     end
 
     def metrics
-      decisions = inventory_decisions
-      unsupported, supported = decisions.partition { |decision| unsupported?(decision) }
-      eligible = supported.sum { |decision| Array(value(decision, :conditions)).length }
-      observed = vectors.map { |vector| value(vector, :decision_id).to_s }.uniq
-      proven = @analysis ? value(@analysis, :proven_count).to_i : 0
-      { discovered: decisions.length, supported: supported.length, unsupported: unsupported.length,
-        unsupported_conditions: unsupported.sum do |decision|
-          discovered_conditions(decision)
-        end, eligible_conditions: eligible,
-        opaque: decisions.sum { |decision| Array(value(decision, :opaque_ranges)).length },
-        unexecuted: supported.count { |decision| !observed.include?(value(decision, :id).to_s) },
-        completed: vectors.sum do |vector|
-          value(vector, :count).to_i
-        end, aborted: numeric_hash_value(@evidence, :abort_counts),
-        unattributed: vectors.sum { |vector| value(vector, :unattributed_count).to_i }, limited: incomplete? ? 1 : 0,
-        proven: proven, percentage: percentage(eligible, proven) }
+      @metrics ||= begin
+        decisions = inventory_decisions
+        unsupported, supported = decisions.partition { |decision| unsupported?(decision) }
+        eligible = supported.sum { |decision| Array(value(decision, :conditions)).length }
+        observed = vectors.map { |vector| value(vector, :decision_id).to_s }.uniq
+        proven = @analysis ? value(@analysis, :proven_count).to_i : 0
+        kind_counts = decisions.group_by { |decision| decision_kind(decision) }.transform_values(&:length)
+        context_counts = decisions.group_by { |decision| value(decision, :context).to_s }
+        context_counts = context_counts.reject { |context, _| context.empty? }.transform_values(&:length)
+        { discovered: decisions.length, supported: supported.length, unsupported: unsupported.length,
+          unsupported_conditions: unsupported.sum do |decision|
+            discovered_conditions(decision)
+          end, eligible_conditions: eligible,
+          opaque: decisions.sum { |decision| Array(value(decision, :opaque_ranges)).length },
+          unexecuted: supported.count { |decision| !observed.include?(value(decision, :id).to_s) },
+          eligible_alternatives: supported.sum do |decision|
+            nonboolean_decision?(decision) ? Array(value(decision, :alternatives)).length : 0
+          end,
+          completed: vectors.sum do |vector|
+            value(vector, :count).to_i
+          end, aborted: numeric_hash_value(@evidence, :abort_counts),
+          unattributed: vectors.sum { |vector| value(vector, :unattributed_count).to_i }, limited: incomplete? ? 1 : 0,
+          proven: proven, percentage: percentage(eligible, proven), kind_counts: kind_counts,
+          decision_kinds: kind_counts, context_counts: context_counts }
+      end
     end
 
     def completeness
-      evidence = value(@evidence, :completeness) || {}
-      analysis = value(@analysis, :completeness) || {}
-      { observation: completeness_value?(evidence, analysis, :observation),
-        attribution: completeness_value?(evidence, analysis, :attribution),
-        analysis: @analysis ? value(analysis, :analysis) == true : value(evidence, :analysis) == true }
+      @completeness ||= begin
+        evidence = value(@evidence, :completeness) || {}
+        analysis = value(@analysis, :completeness) || {}
+        { observation: completeness_value?(evidence, analysis, :observation),
+          attribution: completeness_value?(evidence, analysis, :attribution),
+          analysis: @analysis ? value(analysis, :analysis) == true : value(evidence, :analysis) == true }
+      end
     end
 
     def completeness_value?(evidence, analysis, key)
@@ -583,9 +887,11 @@ module Branchproof
     end
 
     def vectors_for(decision)
-      vectors.select do |vector|
-        value(vector, :decision_id).to_s == value(decision, :id).to_s
-      end
+      vectors_by_decision_id[value(decision, :id).to_s] || []
+    end
+
+    def vectors_by_decision_id
+      @vectors_by_decision_id ||= vectors.group_by { |vector| value(vector, :decision_id).to_s }
     end
 
     def decisions_to_render
@@ -594,14 +900,36 @@ module Branchproof
 
       inventory_decisions
         .reject { |decision| unsupported?(decision) }
-        .select { |decision| conditions_to_render(decision).any? }
+        .select do |decision|
+          if nonboolean_decision?(decision)
+            missing_alternatives_for(decision).any?
+          else
+            conditions_to_render(decision).any? || missing_decision_table_rules(decision).any? ||
+              decision_table_unavailable?(decision)
+          end
+        end
+    end
+
+    def alternatives_to_render(decision)
+      alternatives = Array(value(decision, :alternatives))
+      return alternatives unless @missing_only && analysis_available?
+
+      missing_ids = missing_alternatives_for(decision).map(&:to_s)
+      alternatives.select { |alternative| missing_ids.include?(value(alternative, :id).to_s) }
+    end
+
+    def missing_alternatives_for(decision)
+      coverage = value(value(analysis_for(decision), :coverage), :alternative)
+      Array(value(coverage, :missing_alternatives))
     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" }
+      conditions.reject do |condition|
+        value(condition_result(decision, condition), :status).to_s.upcase == "PROVEN"
+      end
     end
 
     def vectors_to_render(decision)
@@ -650,6 +978,32 @@ module Branchproof
                       end
         lines << "  #{label} (#{description}): #{shown} (#{numerator}/#{denominator} #{denominator_label})#{qualifier}"
       end
+      table = value(aggregate, :decision_table)
+      if table
+        covered = value(table, :covered_rules) || 0
+        required = value(table, :required_rules) || 0
+        percentage = value(table, :percentage)
+        shown = percentage.nil? ? "N/A" : "#{percentage}%"
+        qualifier = incomplete? ? " (lower bound)" : ""
+        lines << "  DT (Decision table coverage): #{shown} (#{covered}/#{required} rules)#{qualifier}"
+        fully_covered = value(table, :fully_covered_decisions) || 0
+        analyzed = value(table, :decisions_analyzed) || 0
+        decision_percentage = value(table, :decision_percentage)
+        lines << "  Decision tables fully covered: #{fully_covered}/#{analyzed} decisions" \
+                 "#{" (#{decision_percentage}%)" unless decision_percentage.nil?}"
+        impossible = value(table, :impossible_rules).to_i
+        lines << "  Statically impossible rules excluded: #{impossible}" if impossible.positive?
+        not_calculated = value(table, :not_calculated_decisions).to_i
+        lines << "  Decision tables not calculated: #{not_calculated} decisions" if not_calculated.positive?
+      end
+      alternative = value(aggregate, :alternative)
+      if alternative
+        covered = value(alternative, :covered_alternatives) || 0
+        required = value(alternative, :required_alternatives) || 0
+        percentage = value(alternative, :percentage)
+        shown = percentage.nil? ? "N/A" : "#{percentage}%"
+        lines << "  Alternative coverage: #{covered}/#{required} alternatives (#{shown})"
+      end
       lines << ""
       lines
     end
@@ -667,6 +1021,10 @@ module Branchproof
         "#{value(row, :covered_conditions) || 0}/#{value(row, :condition_count) || 0} conditions fully covered)"
       when "MC/DC"
         "#{label}=#{status} (#{value(row, :proven_conditions) || 0}/#{value(row, :condition_count) || 0} conditions)"
+      when "DT"
+        return "#{label}=NOT CALCULATED (#{value(row, :reason)})" if raw_status == "not_calculated"
+
+        "#{label}=#{status} (#{value(row, :covered_rules) || 0}/#{value(row, :required_rules) || 0} rules)"
       else
         "#{label}=#{status}"
       end
@@ -683,27 +1041,70 @@ module Branchproof
     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?
+
+      unavailable = unavailable_decision_table_count
+      unavailable_suffix = if unavailable.positive?
+                             "; decision-table analysis unavailable for #{unavailable} " \
+                               "#{unavailable == 1 ? "decision" : "decisions"}"
+                           else
+                             ""
+                           end
+      if missing_condition_count.zero? && missing_alternatives_count.zero? && missing_rule_count.zero?
+        return "No missing conditions, alternatives, or decision-table rules#{unavailable_suffix}"
+      end
 
       count = decisions_to_render.length
-      "Missing conditions: #{missing_condition_count} across #{count} #{count == 1 ? "decision" : "decisions"}"
+      label = count == 1 ? "decision" : "decisions"
+      suffix = missing_rule_count.positive? ? "; decision-table rules: #{missing_rule_count}" : ""
+      summary = if missing_condition_count.positive? && missing_alternatives_count.positive?
+                  "Missing conditions: #{missing_condition_count}; alternatives: #{missing_alternatives_count} " \
+                    "across #{count} #{label}#{suffix}"
+                elsif missing_condition_count.positive?
+                  "Missing conditions: #{missing_condition_count} across #{count} #{label}#{suffix}"
+                elsif missing_alternatives_count.positive?
+                  "Missing alternatives: #{missing_alternatives_count} across #{count} #{label}#{suffix}"
+                else
+                  "Missing decision-table rules: #{missing_rule_count} across #{count} #{label}"
+                end
+      "#{summary}#{unavailable_suffix}"
+    end
+
+    def missing_rule_count
+      decisions_to_render.sum { |decision| missing_decision_table_rules(decision).length }
+    end
+
+    def missing_alternatives_count
+      decisions_to_render.sum { |decision| missing_alternatives_for(decision).length }
     end
 
     def analysis_for(decision)
-      Array(value(@analysis, :decisions)).find do |item|
-        value(item, :decision_id).to_s == value(decision, :id).to_s
+      analysis_by_decision_id[value(decision, :id).to_s]
+    end
+
+    def analysis_by_decision_id
+      @analysis_by_decision_id ||= Array(value(@analysis, :decisions)).to_h do |item|
+        [value(item, :decision_id).to_s, item]
       end
     end
 
     def source_for(decision)
-      Array(value(@inventory, :source_units)).find do |source|
-        value(source, :source_id).to_s == value(decision, :source_id).to_s
-      end || decision
+      source_by_source_id[value(decision, :source_id).to_s] || decision
+    end
+
+    def source_by_source_id
+      @source_by_source_id ||= Array(value(@inventory, :source_units)).to_h do |source|
+        [value(source, :source_id).to_s, source]
+      end
+    end
+
+    def inventory_decisions
+      @inventory_decisions ||= Array(value(@inventory, :decisions)).freeze
+    end
+
+    def vectors
+      @vectors ||= Array(value(@evidence, :vectors)).freeze
     end
 
-    def inventory_decisions = Array(value(@inventory, :decisions))
-    def vectors = Array(value(@evidence, :vectors))
     def unsupported?(decision) = value(decision, :support_status).to_s.upcase == "UNSUPPORTED"
 
     def discovered_conditions(decision)
@@ -749,6 +1150,9 @@ module Branchproof
     def normalize_unknown(object)
       object.to_s
     end
-    public :condition_coverage_evidence, :coverage_ladder_lines, :coverage_status_label
+    public :condition_coverage_evidence, :coverage_ladder_lines, :coverage_status_label,
+           :decision_table_requirement, :decision_table_reachability, :decision_table_expected_heading
   end
 end
+
+# rubocop:enable Metrics/BlockLength