branchproof 0.7.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,22 +47,21 @@ 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)
@@ -58,7 +69,7 @@ module Branchproof
       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] = {
@@ -67,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
@@ -102,14 +114,16 @@ module Branchproof
       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|
@@ -132,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",
@@ -149,18 +163,20 @@ 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
 
@@ -169,7 +185,7 @@ module Branchproof
       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: [], witness_buckets: {},
+          condition_results: [],
           conditions: [], alternatives: alternatives(decision), unsupported: true,
           coverage: unsupported_alternative_coverage,
           completeness: { observation: true, attribution: true, analysis: true },
@@ -177,7 +193,7 @@ module Branchproof
         }
       end
 
-      vectors = @vectors.filter_map { |vector| valid_vector(vector, decision) }
+      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 }
@@ -195,7 +211,7 @@ module Branchproof
       covered = rows.count { |row| row[:selected][:observed] }
       {
         decision_id: decision_id, kind: id(decision, :kind), effective_masks_by_vector: {},
-        condition_results: [], witness_buckets: {},
+        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,
@@ -223,7 +239,7 @@ module Branchproof
     end
 
     def alternative_decision_for_id?(decision_id)
-      decision = records(@inventory, :decisions).find { |item| id(item, :id) == decision_id }
+      decision = @decisions_by_id[decision_id]
       decision && alternative_decision?(decision)
     end
 
@@ -237,7 +253,8 @@ module Branchproof
         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)
@@ -339,26 +356,44 @@ module Branchproof
         decision[:coverage][:condition][:covered_conditions]
       end
       proven = boolean_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: boolean_supported.length,
-                    percentage: percentage.call(decision_covered, 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: boolean_supported.length,
-                              percentage: percentage.call(condition_decision_covered, 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: required.zero? ? nil : (covered.to_f / required * 100).round(2) }
+        supported_decisions: flow.length, percentage: DecisionTable.percentage(covered, required) }
     end
 
     def valid_vector(vector, decision)
@@ -433,7 +468,7 @@ module Branchproof
     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
 
@@ -448,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
@@ -472,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|
@@ -491,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
@@ -613,18 +659,6 @@ module Branchproof
       end
     end
 
-    def evaluate(node, values)
-      type = id(node, :type).to_sym
-      return values[id(node, :index)] if type == :atom
-      return !evaluate(node.fetch(:child), values) if type == :not
-
-      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 = [])
       type = id(node, :type).to_sym
       if type == :atom
@@ -654,13 +688,15 @@ module Branchproof
     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)