branchproof 0.6.0 → 0.8.0

data/lib/branchproof/analyzer.rb

@@ -8,20 +8,32 @@ module Branchproof
   class Analyzer
     CRITERION = "masking_occurrence_v1"
 
-    def initialize(inventory:, evidence:, limits:)
+    def initialize(inventory:, evidence:, limits:, reachability: true)
       @inventory = inventory || {}
       @evidence = evidence || {}
       @limits = limits || {}
+      @reachability = reachability
       @vectors = records(@evidence, :vectors)
+      @vectors_by_decision = @vectors.each_with_object(Hash.new { |hash, key| hash[key] = [] }) do |vector, hash|
+        hash[id(vector, :decision_id)] << vector
+      end
+      @decisions = records(@inventory, :decisions)
+      @decisions_by_id = @decisions.each_with_object({}) do |decision, hash|
+        key = id(decision, :id)
+        hash[key] = decision unless hash.key?(key)
+      end
       @constraint_states = Hash.new(0)
       @missing_cache = {}
       @invalid_diagnostics = []
       @analysis_invalid = false
       @diagnostic_keys = Set.new
+      # Keyed by vector object identity (not content), so a validated vector's
+      # values are checked once and reused on every later read.
+      @values_cache = {}.compare_by_identity
     end
 
     def call
-      decisions = records(@inventory, :decisions).map { analyze_decision(_1) }
+      decisions = @decisions.map { analyze_decision(_1) }
       proven = decisions.sum { |decision| decision[:condition_results].count { |result| result[:status] == "PROVEN" } }
       eligible = decisions.sum { |decision| decision[:unsupported] ? 0 : decision[:conditions].length }
       {
@@ -35,27 +47,29 @@ module Branchproof
       }.freeze
     end
 
-    def pair?(decision_id:, condition_index:, left:, right:)
+    def pair?(decision_id:, condition_index:, left:, right:, masks: nil)
+      return false if alternative_decision_for_id?(decision_id)
       return false unless compatible_vectors?(left, right, decision_id)
       return false unless observed?(left, condition_index) && observed?(right, condition_index)
       return false if value(left, condition_index) == value(right, condition_index)
       return false if outcome(left) == outcome(right)
 
-      masks = [left, right].map { effective_mask(_1, decision_id) }
-      masks.all? { |mask| mask&.anybits?(1 << condition_index) }
+      [left, right].all? { |vector| masked_bits(vector, decision_id, masks)&.anybits?(1 << condition_index) }
     end
 
     def missing(decision_id:, condition_index:)
       cache_key = [decision_id, condition_index]
       return @missing_cache[cache_key] if @missing_cache.key?(cache_key)
 
-      decision = records(@inventory, :decisions).find { id(_1, :id) == decision_id }
+      decision = @decisions_by_id[decision_id]
       return @missing_cache[cache_key] = nil unless decision
 
+      return @missing_cache[cache_key] = nil if alternative_decision?(decision)
+
       support_status = id(decision, :support_status).to_s
       return @missing_cache[cache_key] = nil unless support_status.empty? || support_status.upcase == "SUPPORTED"
 
-      relevant = @vectors.select { id(_1, :decision_id) == decision_id }
+      relevant = @vectors_by_decision[decision_id]
       valid = relevant.filter_map { valid_vector(_1, decision) }
       if valid.empty?
         return @missing_cache[cache_key] = {
@@ -64,14 +78,15 @@ module Branchproof
           feasibility_statement: "No completed structural observation exists."
         }
       end
-      return @missing_cache[cache_key] = nil if first_pair(valid, condition_index, decision_id)
+      masks = valid.to_h { |vector| [id(vector, :id), effective_mask(vector, decision_id)] }
+      return @missing_cache[cache_key] = nil if first_pair(valid, condition_index, decision_id, masks)
 
-      existing = valid.find { |vector| effective_mask(vector, decision_id).anybits?(1 << condition_index) }
+      existing = valid.find { |vector| masks[id(vector, :id)].anybits?(1 << condition_index) }
       signs = existing ? [!value(existing, condition_index)] : [true, false]
       candidates = signs.filter_map { counterpart(decision, condition_index, _1) }
       candidates.select! do |candidate|
         !existing || pair?(decision_id: decision_id, condition_index: condition_index, left: existing,
-                           right: candidate[:vector])
+                           right: candidate[:vector], masks: masks)
       end
       limited = @constraint_states[id(decision, :id)] > constraint_limit
       if limited
@@ -94,17 +109,21 @@ module Branchproof
     private
 
     def analyze_decision(decision)
+      return analyze_alternative_decision(decision) if alternative_decision?(decision)
+
       decision_id = id(decision, :id)
       unless id(decision, :support_status).to_s.empty? || id(decision, :support_status).to_s.upcase == "SUPPORTED"
         return {
-          decision_id: decision_id, effective_masks_by_vector: {}, condition_results: [], witness_buckets: {},
+          decision_id: decision_id, effective_masks_by_vector: {}, condition_results: [],
           conditions: [], unsupported: true, coverage: unsupported_coverage,
+          decision_table: DecisionTable.build(decision: decision, vectors: [], limits: @limits,
+                                              reachability: @reachability),
           completeness: { observation: true, attribution: true, analysis: true },
           diagnostics: [diagnostic("unsupported_decision", "warning", decision_id, nil)]
         }
       end
 
-      vectors = @vectors.filter_map { |vector| valid_vector(vector, decision) }
+      vectors = @vectors_by_decision[decision_id].filter_map { |vector| valid_vector(vector, decision) }
       masks = vectors.to_h { |vector| [id(vector, :id), effective_mask(vector, decision_id)] }
       buckets = {}
       conditions(decision).each do |condition|
@@ -127,7 +146,7 @@ module Branchproof
         true_ids = buckets[index][:true]
         false_ids = buckets[index][:false]
         # rubocop:enable Lint/BooleanSymbol
-        pair = first_pair(vectors, index, decision_id)
+        pair = first_pair(vectors, index, decision_id, masks)
         {
           condition_id: id(condition, :id),
           status: pair ? "PROVEN" : "NOT_PROVEN",
@@ -144,28 +163,98 @@ module Branchproof
       decision_coverage = decision_coverage(vectors)
       condition_coverage_summary = condition_summary(results)
       mcdc = mcdc_coverage(results)
+      table = DecisionTable.build(decision: decision, vectors: vectors, limits: @limits,
+                                  reachability: @reachability)
       {
         decision_id: decision_id,
         effective_masks_by_vector: masks,
         condition_results: results,
-        witness_buckets: buckets,
         edge_table: edge_table(decision[:tree]),
         conditions: conditions(decision),
         coverage: { decision: decision_coverage, condition: condition_coverage_summary,
                     condition_decision: conjunction_coverage(decision_coverage, condition_coverage_summary),
-                    mcdc: mcdc },
+                    mcdc: mcdc, decision_table: DecisionTable.coverage_entry(table) },
+        decision_table: table,
         completeness: { observation: true, attribution: true, analysis: !@analysis_invalid },
-        diagnostics: []
+        diagnostics: table[:diagnostics]
       }
     end
 
+    def analyze_alternative_decision(decision)
+      decision_id = id(decision, :id)
+      unless id(decision, :support_status).to_s.empty? || id(decision, :support_status).to_s.upcase == "SUPPORTED"
+        return {
+          decision_id: decision_id, kind: id(decision, :kind), effective_masks_by_vector: {},
+          condition_results: [],
+          conditions: [], alternatives: alternatives(decision), unsupported: true,
+          coverage: unsupported_alternative_coverage,
+          completeness: { observation: true, attribution: true, analysis: true },
+          diagnostics: [diagnostic("unsupported_decision", "warning", decision_id, nil)]
+        }
+      end
+
+      vectors = @vectors_by_decision[decision_id].filter_map { |vector| valid_vector(vector, decision) }
+      rows = alternatives(decision).map do |alternative|
+        index = id(alternative, :index).to_i
+        selected = vectors.select { |vector| value(vector, index) == true }
+        not_selected = vectors.select { |vector| value(vector, index) == false }
+        skipped = vectors.select { |vector| value(vector, index).nil? }
+        {
+          alternative_id: id(alternative, :id), index: id(alternative, :index),
+          expression: id(alternative, :expression),
+          selected: alternative_evidence_bucket(selected),
+          not_selected: alternative_evidence_bucket(not_selected),
+          skipped: alternative_evidence_bucket(skipped)
+        }
+      end
+      missing = rows.filter_map { |row| row[:alternative_id] unless row[:selected][:observed] }
+      covered = rows.count { |row| row[:selected][:observed] }
+      {
+        decision_id: decision_id, kind: id(decision, :kind), effective_masks_by_vector: {},
+        condition_results: [],
+        conditions: [], alternatives: alternatives(decision), unsupported: false,
+        coverage: { alternative: { status: coverage_status(covered, rows.length), covered_alternatives: covered,
+                                   required_alternatives: rows.length, alternatives: rows,
+                                   missing_alternatives: missing },
+                    mcdc: { status: "not_applicable" } },
+        completeness: { observation: true, attribution: true, analysis: !@analysis_invalid }, diagnostics: []
+      }
+    end
+
+    def unsupported_alternative_coverage
+      { alternative: { status: "unsupported", covered_alternatives: 0, required_alternatives: 0,
+                       alternatives: [], missing_alternatives: [] }, mcdc: { status: "unsupported" } }
+    end
+
+    def alternative_evidence_bucket(vectors)
+      evidence = vectors.map { |vector| provenance(vector) }
+      { observed: !vectors.empty?, vector_ids: evidence.map { |item| item[:vector_id] }.uniq.sort,
+        test_ids: evidence.flat_map { |item| item[:test_ids] }.uniq.sort,
+        unattributed_count: evidence.sum { |item| item[:unattributed_count] } }
+    end
+
+    def alternative_decision?(decision)
+      kind = id(decision, :kind).to_s
+      !kind.empty? && kind != "boolean"
+    end
+
+    def alternative_decision_for_id?(decision_id)
+      decision = @decisions_by_id[decision_id]
+      decision && alternative_decision?(decision)
+    end
+
+    def alternatives(decision)
+      records(decision, :alternatives)
+    end
+
     def unsupported_coverage
       { decision: { status: "unsupported", true_observed: false, false_observed: false,
                     covered_outcomes: 0, required_outcomes: 2, outcomes: [], missing_outcomes: [] },
         condition: { status: "unsupported", covered_values: 0, required_values: 0,
                      covered_conditions: 0, condition_count: 0 },
         condition_decision: { status: "unsupported" },
-        mcdc: { status: "unsupported", proven_conditions: 0, condition_count: 0 } }
+        mcdc: { status: "unsupported", proven_conditions: 0, condition_count: 0 },
+        decision_table: DecisionTable.unsupported_coverage_entry }
     end
 
     def provenance(vector)
@@ -254,29 +343,57 @@ module Branchproof
 
     def aggregate_coverage(decisions)
       supported = decisions.reject { |decision| decision[:unsupported] }
-      decision_covered = supported.count do |decision|
+      boolean_supported = supported.reject { |decision| alternative_decision?(decision) }
+      decision_covered = boolean_supported.count do |decision|
         decision[:coverage][:decision][:status] == "covered"
       end
-      condition_decision_covered = supported.count do |decision|
+      condition_decision_covered = boolean_supported.count do |decision|
         decision[:coverage][:condition_decision][:status] == "covered"
       end
-      condition_count = supported.sum { |decision| decision[:coverage][:condition][:condition_count] }
-      condition_values = supported.sum { |decision| decision[:coverage][:condition][:covered_values] }
-      covered_conditions = supported.sum do |decision|
+      condition_count = boolean_supported.sum { |decision| decision[:coverage][:condition][:condition_count] }
+      condition_values = boolean_supported.sum { |decision| decision[:coverage][:condition][:covered_values] }
+      covered_conditions = boolean_supported.sum do |decision|
         decision[:coverage][:condition][:covered_conditions]
       end
-      proven = supported.sum { |decision| decision[:coverage][:mcdc][:proven_conditions] }
-      percentage = ->(covered, required) { required.zero? ? nil : (covered.to_f / required * 100).round(2) }
-      { decision: { covered_decisions: decision_covered, supported_decisions: supported.length,
-                    percentage: percentage.call(decision_covered, supported.length) },
+      proven = boolean_supported.sum { |decision| decision[:coverage][:mcdc][:proven_conditions] }
+      { decision: { covered_decisions: decision_covered, supported_decisions: boolean_supported.length,
+                    percentage: DecisionTable.percentage(decision_covered, boolean_supported.length) },
         condition: { covered_values: condition_values, required_values: condition_count * 2,
                      covered_conditions: covered_conditions, condition_count: condition_count,
-                     percentage: percentage.call(condition_values, condition_count * 2) },
+                     percentage: DecisionTable.percentage(condition_values, condition_count * 2) },
         condition_decision: { covered_decisions: condition_decision_covered,
-                              supported_decisions: supported.length,
-                              percentage: percentage.call(condition_decision_covered, supported.length) },
+                              supported_decisions: boolean_supported.length,
+                              percentage: DecisionTable.percentage(condition_decision_covered,
+                                                                   boolean_supported.length) },
         mcdc: { proven_conditions: proven, supported_conditions: condition_count,
-                percentage: percentage.call(proven, condition_count) } }
+                percentage: DecisionTable.percentage(proven, condition_count) },
+        decision_table: decision_table_aggregate(boolean_supported),
+        alternative: alternative_aggregate(decisions) }
+    end
+
+    # Rule coverage and fully covered decisions stay separate metrics: a
+    # decision can hold most of its rules and still fail the criterion.
+    def decision_table_aggregate(boolean_supported)
+      analyzed = boolean_supported.select { |decision| decision.dig(:decision_table, :status) == "calculated" }
+      not_calculated = boolean_supported.length - analyzed.length
+      covered = analyzed.sum { |decision| decision.dig(:decision_table, :covered_rules).to_i }
+      required = analyzed.sum { |decision| decision.dig(:decision_table, :required_rules).to_i }
+      generated = analyzed.sum { |decision| decision.dig(:decision_table, :generated_rules).to_i }
+      impossible = analyzed.sum { |decision| decision.dig(:decision_table, :impossible_rules).to_i }
+      fully_covered = analyzed.count { |decision| decision.dig(:decision_table, :coverage_status) == "covered" }
+      { decisions_analyzed: analyzed.length, not_calculated_decisions: not_calculated,
+        fully_covered_decisions: fully_covered, covered_rules: covered, required_rules: required,
+        generated_rules: generated, impossible_rules: impossible,
+        percentage: DecisionTable.percentage(covered, required),
+        decision_percentage: DecisionTable.percentage(fully_covered, analyzed.length) }
+    end
+
+    def alternative_aggregate(decisions)
+      flow = decisions.select { |decision| !decision[:unsupported] && alternative_decision?(decision) }
+      required = flow.sum { |decision| decision.dig(:coverage, :alternative, :required_alternatives).to_i }
+      covered = flow.sum { |decision| decision.dig(:coverage, :alternative, :covered_alternatives).to_i }
+      { covered_alternatives: covered, required_alternatives: required,
+        supported_decisions: flow.length, percentage: DecisionTable.percentage(covered, required) }
     end
 
     def valid_vector(vector, decision)
@@ -308,7 +425,11 @@ module Branchproof
         return nil
       end
 
-      effective_mask(vector, id(decision, :id), decision[:tree])
+      if alternative_decision?(decision)
+        handle_alternative_vector(vector, decision)
+      else
+        effective_mask(vector, id(decision, :id), decision[:tree])
+      end
       decision_source.nil? ? vector : vector.merge(source_id: decision_source)
     rescue ArgumentError
       @analysis_invalid = true
@@ -316,8 +437,38 @@ module Branchproof
       nil
     end
 
+    # rubocop:disable-next Naming/PredicateMethod -- raises on malformed flow vectors
+    def handle_alternative_vector(vector, decision)
+      values = values_for(vector)
+      expected = alternatives(decision).length
+      raise ArgumentError, "invalid alternative vector shape" unless values.length == expected
+
+      observations = values.each_with_index.filter_map { |item, index| [index, item] unless item.nil? }
+      raise ArgumentError, "invalid alternative trace" unless valid_alternative_trace?(decision, observations,
+                                                                                       outcome(vector))
+
+      true
+    end
+
+    def valid_alternative_trace?(decision, observations, result)
+      return false unless result == true
+
+      expected = alternatives(decision).length
+      return false unless expected.positive?
+      if id(decision, :kind).to_s == "implicit"
+        return expected == 2 && observations.length == 2 &&
+               observations.map(&:first) == [0, 1] && observations.map(&:last).count(true) == 1
+      end
+
+      return false unless observations.length.between?(1, expected)
+
+      observations.each_with_index.all? do |(index, value), position|
+        index == position && value == (position == observations.length - 1)
+      end
+    end
+
     def effective_mask(vector, decision_id, tree = nil)
-      decision = records(@inventory, :decisions).find { id(_1, :id) == decision_id } unless tree
+      decision = @decisions_by_id[decision_id] unless tree
       tree ||= decision && decision[:tree]
       raise ArgumentError, "unknown decision" unless tree
 
@@ -332,6 +483,15 @@ module Branchproof
       mask
     end
 
+    # Returns the effective mask for a vector, reusing a precomputed
+    # vector-id => mask hash when the caller has one, instead of
+    # replaying the whole Boolean tree again.
+    def masked_bits(vector, decision_id, masks)
+      return effective_mask(vector, decision_id) unless masks
+
+      masks[id(vector, :id)] || effective_mask(vector, decision_id)
+    end
+
     def replay(node, values, offset)
       type = id(node, :type).to_sym
       if type == :atom
@@ -341,6 +501,10 @@ module Branchproof
 
         return [value, 1 << index, offset + 1]
       end
+      if type == :not
+        child_result, child_mask, consumed = replay(node.fetch(:child), values, offset)
+        return [!child_result, child_mask, consumed]
+      end
       left_result, left_mask, consumed = replay(node.fetch(:left), values, offset)
       return [left_result, left_mask, consumed] if (type == :and && !left_result) || (type == :or && left_result)
 
@@ -352,9 +516,9 @@ module Branchproof
       end
     end
 
-    def first_pair(vectors, index, decision_id)
+    def first_pair(vectors, index, decision_id, masks = nil)
       observed_vectors = vectors.select do |vector|
-        observed?(vector, index) && effective_mask(vector, decision_id).anybits?(1 << index)
+        observed?(vector, index) && masked_bits(vector, decision_id, masks)&.anybits?(1 << index)
       end
       observed_vectors.sort_by! { |vector| id(vector, :id).to_s }
       grouped = observed_vectors.group_by do |vector|
@@ -371,7 +535,9 @@ module Branchproof
 
         left = left_vectors.first
         right = right_vectors.first
-        return [left, right] if pair?(decision_id: decision_id, condition_index: index, left: left, right: right)
+        if pair?(decision_id: decision_id, condition_index: index, left: left, right: right, masks: masks)
+          return [left, right]
+        end
       end
       nil
     end
@@ -440,6 +606,8 @@ module Branchproof
         return { entry: entry, true_exits: [edges[0]], false_exits: [edges[1]], all_bits: 1 << index, edges: edges }
       end
       type = id(node, :type).to_sym
+      return build_graph(node.fetch(:child), false_destination, true_destination) if type == :not
+
       right = build_graph(node[:right], true_destination, false_destination)
       if type == :and
         left = build_graph(node[:left], right[:entry], false_destination)
@@ -455,7 +623,9 @@ module Branchproof
     end
 
     def impose_path(node, target, target_value, constraints)
-      return true if id(node, :type).to_sym == :atom && id(node, :index) == target
+      type = id(node, :type).to_sym
+      return true if type == :atom && id(node, :index) == target
+      return impose_path(node.fetch(:child), target, target_value, constraints) if type == :not
 
       left = node[:left]
       right = node[:right]
@@ -480,6 +650,8 @@ module Branchproof
 
         constraints << { condition_index: id(node, :index), value: desired }
         true
+      elsif id(node, :type).to_sym == :not
+        impose_subtree(node.fetch(:child), !desired, constraints)
       elsif desired == (id(node, :type).to_sym == :and)
         impose_subtree(node[:left], desired, constraints) && impose_subtree(node[:right], desired, constraints)
       else
@@ -487,22 +659,17 @@ module Branchproof
       end
     end
 
-    def evaluate(node, values)
-      return values[id(node, :index)] if id(node, :type).to_sym == :atom
-
-      left = evaluate(node[:left], values)
-      return left if id(node, :type).to_sym == :and && !left
-      return left if id(node, :type).to_sym == :or && left
-
-      evaluate(node[:right], values)
-    end
-
     def evaluate_with_trace(node, values, trace = [])
-      if id(node, :type).to_sym == :atom
+      type = id(node, :type).to_sym
+      if type == :atom
         value = !values[id(node, :index)].nil? && values[id(node, :index)] != false
         trace << [id(node, :index), value]
         return [value, trace]
       end
+      if type == :not
+        child, = evaluate_with_trace(node.fetch(:child), values, trace)
+        return [!child, trace]
+      end
       left, = evaluate_with_trace(node[:left], values, trace)
       return [left, trace] if id(node, :type).to_sym == :and && !left
       return [left, trace] if id(node, :type).to_sym == :or && left
@@ -511,24 +678,25 @@ module Branchproof
     end
 
     def contains?(node, target)
-      if id(node,
-            :type).to_sym == :atom
-        id(node,
-           :index) == target
+      if id(node, :type).to_sym == :atom
+        id(node, :index) == target
+      elsif id(node, :type).to_sym == :not
+        contains?(node.fetch(:child), target)
       else
-        contains?(node[:left],
-                  target) || contains?(node[:right], target)
+        contains?(node[:left], target) || contains?(node[:right], target)
       end
     end
 
     def values_for(vector)
+      return @values_cache[vector] if @values_cache.key?(vector)
+
       raw = vector[:values] || vector["values"]
       raise ArgumentError, "observation must contain booleans or nil" unless raw.is_a?(Array)
       unless raw.all? { |value| value.nil? || value == true || value == false }
         raise ArgumentError, "observation must contain booleans or nil"
       end
 
-      raw
+      @values_cache[vector] = raw
     end
 
     def outcome(vector) = vector[:outcome].nil? ? vector["outcome"] : vector[:outcome]

data/lib/branchproof/cli.rb

@@ -15,6 +15,9 @@ require "time"
 module Branchproof
   # Coordinates source inventory, isolated test execution, and report output.
   class CLI
+    VIEWS = Report::VIEWS.to_h { |view| [view.to_s.tr("_", "-"), view] }
+                         .merge("decision_tables" => :decision_tables).freeze
+
     def initialize(stdout:, stderr:)
       @stdout = stdout
       @stderr = stderr
@@ -25,7 +28,7 @@ module Branchproof
       return help if [["--help"], ["help"], ["analyze", "--help"]].include?(argv)
       return offline(argv) if %w[report compare].include?(argv.first)
 
-      options = parse(Array(argv))
+      options = parse(argv)
       return usage_error("expected analyze, report, or compare; use branchproof --help") unless options
 
       inventory = build_inventory(options)
@@ -49,30 +52,29 @@ module Branchproof
                                             message: merge_status[:reason].to_s }]
         end
       end
+      snapshot = evidence.snapshot
       if value(baseline, :status).to_s == "PASSED"
-        analysis = Analyzer.new(inventory: inventory, evidence: evidence.snapshot, limits: options[:limits]).call
+        analysis = Analyzer.new(inventory: inventory, evidence: snapshot, limits: options[:limits],
+                                reachability: options[:reachability]).call
         baseline[:analysis] = analysis
         if options[:level] >= 2
           ids = Array(value(inventory, :decisions)).map { |decision| value(decision, :id) }
+          minimizer = Minimizer.new(analysis: analysis, evidence: snapshot, limits: options[:limits])
           baseline[:minima] = ids.filter_map do |decision_id|
-            Minimizer.new(analysis: analysis, evidence: evidence.snapshot, limits: options[:limits]).call(objective: :vectors, decision_ids: [decision_id])
+            minimizer.call(objective: :vectors, decision_ids: [decision_id])
           end
           baseline[:minima] += ids.filter_map do |decision_id|
-            Minimizer.new(analysis: analysis, evidence: evidence.snapshot, limits: options[:limits]).call(
-              objective: :tests, decision_ids: [decision_id]
-            )
+            minimizer.call(objective: :tests, decision_ids: [decision_id])
           end
-          baseline[:minima] << Minimizer.new(analysis: analysis, evidence: evidence.snapshot, limits: options[:limits]).call(
-            objective: :tests, decision_ids: ids
-          )
+          baseline[:minima] << minimizer.call(objective: :tests, decision_ids: ids)
         end
       end
       diagnostics = Array(value(inventory, :diagnostics)) + Array(value(baseline, :diagnostics)) +
-                    Array(value(evidence.snapshot,
+                    Array(value(snapshot,
                                 :diagnostics)) + Array(value(value(baseline, :analysis), :diagnostics))
       analysis = value(baseline, :analysis)
       minima = options[:level] == 1 ? [] : Array(value(baseline, :minima))
-      report = Report.new(inventory: inventory, evidence: value(baseline, :evidence) || evidence.snapshot,
+      report = Report.new(inventory: inventory, evidence: value(baseline, :evidence) || snapshot,
                           analysis: analysis, minima: minima, baseline: baseline, diagnostics: diagnostics,
                           level: options[:level], missing_only: options[:missing_only], view: options[:view],
                           run_metadata: run_metadata(options, baseline))
@@ -92,21 +94,24 @@ module Branchproof
       @stdout.write(<<~HELP)
         Usage:
           branchproof analyze [SOURCE_GLOB ...] [--test TEST_GLOB] [--project auto|ruby|rails]
-            [--view decisions|conditions|tests] [--level 1|2|3] [--missing-only]
-            [--format terminal|json] [--output PATH] [--limits PATH] [-- RUNNER_ARGS]
-          branchproof report SNAPSHOT [--view decisions|conditions|tests] [--level 1|2|3]
-            [--missing-only] [--format terminal|json] [--output PATH]
+            [--view decisions|conditions|tests|decision-tables] [--level 1|2|3] [--missing-only]
+            [--format terminal|json] [--output PATH] [--limits PATH] [--no-reachability] [-- RUNNER_ARGS]
+          branchproof report SNAPSHOT [--view decisions|conditions|tests|decision-tables]
+            [--level 1|2|3] [--missing-only] [--format terminal|json] [--output PATH]
           branchproof compare BEFORE AFTER [--format terminal|json] [--output PATH] [--fail-on-regression]
         mcdc accepts the same commands as a compatibility alias.
         JSON always contains full evidence; --view requires terminal output.
+        decision_tables is also accepted as an alias for the decision-tables view.
+        --no-reachability keeps every generated decision-table rule as a coverage obligation.
       HELP
       0
     end
 
     def parse_view(view)
-      raise ArgumentError, "view must be decisions, conditions, or tests" unless %w[decisions conditions tests].include?(view)
+      resolved = VIEWS[view.to_s]
+      raise ArgumentError, "view must be decisions, conditions, tests, or decision-tables" unless resolved
 
-      view.to_sym
+      resolved
     end
 
     def validate_view!(options)
@@ -204,7 +209,8 @@ module Branchproof
         project_root: root, source_patterns: options[:source_patterns].map { |path| relative_path(path, root) },
         test_patterns: options[:test_patterns].map { |path| relative_path(path, root) },
         test_files: options[:tests].map { |path| relative_path(path, root) }, runner_args: options[:runner_args],
-        seed: value(baseline, :seed), limits: options[:limits], test_locations: locations }
+        seed: value(baseline, :seed), limits: options[:limits], test_locations: locations,
+        reachability: options[:reachability] }
     end
 
     def relative_path(path, root)
@@ -221,7 +227,8 @@ module Branchproof
       runner_args = delimiter ? args[(delimiter + 1)..] : []
       args = args[0...delimiter] if delimiter
       options = { level: 3, format: :terminal, output: nil, tests: [], source_paths: [], limits: Limits.default,
-                  runner_args: runner_args, project: nil, missing_only: false, view: :decisions }
+                  runner_args: runner_args, project: nil, missing_only: false, view: :decisions,
+                  reachability: true }
       until args.empty?
         token = args.shift
         case token
@@ -230,6 +237,8 @@ module Branchproof
           options[:explicit_view] = true
         when "--missing-only"
           options[:missing_only] = true
+        when "--no-reachability"
+          options[:reachability] = false
         when "--level"
           level = Integer(args.shift.to_s, 10)
           raise ArgumentError, "level must be 1, 2, or 3" unless (1..3).cover?(level)