branchproof 0.7.0 → 0.8.0

data/lib/branchproof/saved_report.rb

@@ -5,11 +5,19 @@
 # rubocop:disable Metrics/ClassLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
 
 require "json"
+# rubocop:disable-next Lint/RedundantRequireStatement -- supports standalone core entry
+require "set"
+require_relative "decision_table"
 
 module Branchproof
   # Reads and validates a persisted JSON report without loading the project.
   class SavedReport
-    SUPPORTED_SCHEMAS = %w[1.0 1.1 1.2].freeze
+    SUPPORTED_SCHEMAS = %w[1.0 1.1 1.2 1.3].freeze
+    STRICT_FLOW_SCHEMAS = %w[1.2 1.3].freeze
+    DECISION_TABLE_STATUSES = %w[calculated not_calculated].freeze
+    RULE_CONDITION_VALUES = DecisionTable::CONDITION_VALUES
+    RULE_COVERAGE_STATUSES = DecisionTable::COVERAGE_STATUSES
+    RULE_REACHABILITY_STATUSES = DecisionTable::REACHABILITY_STATUSES
     DECISION_KINDS = %w[boolean implicit multiway pattern exception].freeze
     NONBOOLEAN_KINDS = (DECISION_KINDS - ["boolean"]).freeze
     CRITERION_VERSION = "masking_occurrence_v1"
@@ -107,7 +115,7 @@ module Branchproof
       end
       fail_with("duplicate condition id") unless @condition_ids.uniq.length == @condition_ids.length
       @conditions_by_decision = decisions.to_h do |decision|
-        [decision["id"], Array(decision["conditions"]).map { |condition| condition["id"] }]
+        [decision["id"], Array(decision["conditions"]).to_set { |condition| condition["id"] }]
       end
       sources.each do |source|
         validate_string_field(source, "relative_path", nullable: true)
@@ -142,11 +150,12 @@ module Branchproof
       fail_with("tests must be an array") unless tests.is_a?(Array)
       fail_with("vectors must be an array") unless vectors.is_a?(Array)
       @test_ids = unique_ids(tests, "id", "test")
+      @test_id_set = @test_ids.to_set
       tests.each { |test| validate_test(test) }
       vector_ids = unique_ids(vectors, "id", "vector")
       vectors.each do |vector|
         fail_with("invalid vector") unless hash_with_string_keys?(vector)
-        fail_with("unknown vector decision") unless @decision_ids.include?(vector["decision_id"])
+        fail_with("unknown vector decision") unless @decisions_by_id.key?(vector["decision_id"])
         decision = @decisions_by_id.fetch(vector["decision_id"])
         values = vector["values"]
         valid_values = values.is_a?(Array) && values.all? do |value|
@@ -162,7 +171,7 @@ module Branchproof
         fail_with("vector outcome must be boolean") unless [true, false].include?(vector["outcome"])
         validate_flow_vector(vector, decision) if strict_flow_decision?(decision)
         fail_with("unknown vector test") unless strings?(vector["test_ids"]) && vector["test_ids"].all? do |id|
-          @test_ids.include?(id)
+          @test_id_set.include?(id)
         end
         validate_phases(vector)
         validate_integer_field(vector, "count")
@@ -171,6 +180,7 @@ module Branchproof
       @vector_ids = vector_ids
       @vector_decision_by_id = vectors.to_h { |vector| [vector["id"], vector["decision_id"]] }
       @vectors_by_id = vectors.to_h { |vector| [vector["id"], vector] }
+      @vectors_by_decision = vectors.group_by { |vector| vector["decision_id"] }
       aborts = observations["abort_counts"]
       return if aborts.nil? || aborts.is_a?(Integer) || (aborts.is_a?(Hash) && aborts.values.all?(Integer))
 
@@ -199,7 +209,7 @@ module Branchproof
       decisions.each do |decision|
         fail_with("invalid analysis decision") unless hash_with_string_keys?(decision)
         id = decision["decision_id"]
-        fail_with("unknown analysis decision") unless @decision_ids.include?(id) && !seen.key?(id)
+        fail_with("unknown analysis decision") unless @decisions_by_id.key?(id) && !seen.key?(id)
         seen[id] = true
         results = decision["condition_results"]
         fail_with("condition results must be an array") unless results.is_a?(Array)
@@ -207,6 +217,9 @@ module Branchproof
         if nonboolean_kind?(decision_kind(inventory_decision))
           fail_with("nonboolean condition results must be empty") unless results.empty?
           validate_nonboolean_analysis(decision, inventory_decision)
+        elsif decision.key?("decision_table")
+          fail_with("decision tables are unsupported in legacy report schemas") unless @schema_version == "1.3"
+          validate_decision_table(decision["decision_table"], inventory_decision)
         end
         seen_conditions = {}
         results.each do |result|
@@ -221,13 +234,183 @@ module Branchproof
 
           pair = result["canonical_pair"]
           valid_pair = pair.is_a?(Array) && pair.length == 2 && pair.uniq.length == 2 && pair.all? do |id|
-            @vector_ids.include?(id) && @vector_decision_by_id[id] == decision["decision_id"]
+            @vectors_by_id.key?(id) && @vector_decision_by_id[id] == decision["decision_id"]
           end
           fail_with("canonical pair must reference vectors") unless valid_pair
         end
       end
     end
 
+    # The persisted decision table must describe the same decision it was
+    # derived from, so a saved report can be reported on and compared offline.
+    def validate_decision_table(table, decision)
+      fail_with("decision_table must be an object") unless hash_with_string_keys?(table)
+      fail_with("decision_table status is invalid") unless DECISION_TABLE_STATUSES.include?(table["status"])
+      fail_with("decision_table decision id mismatch") unless table["decision_id"] == decision["id"]
+      %w[schema_version constraint_analysis_version].each do |field|
+        fail_with("decision_table #{field} must be an integer") unless table[field].is_a?(Integer)
+      end
+      unless table["schema_version"] == DecisionTable::SCHEMA_VERSION
+        fail_with("unsupported decision_table schema version")
+      end
+      solver_version = table["constraint_analysis_version"]
+      supported_solver = [1, DecisionTable::CONSTRAINT_ANALYSIS_VERSION].include?(solver_version) &&
+                         solver_version <= DecisionTable::CONSTRAINT_ANALYSIS_VERSION
+      fail_with("unsupported decision_table constraint analysis version") unless supported_solver
+      validate_string_field(table, "reason", nullable: true)
+      unless DecisionTable::COVERAGE_SUMMARY_STATUSES.include?(table["coverage_status"])
+        fail_with("invalid decision_table coverage status")
+      end
+      %w[generated_rules impossible_rules required_rules covered_rules missing_rules].each do |field|
+        unless table[field].is_a?(Integer) && table[field] >= 0
+          fail_with("decision_table #{field} must be a nonnegative integer")
+        end
+      end
+      rules = table["rules"]
+      fail_with("decision_table rules must be an array") unless rules.is_a?(Array)
+      unique_ids(rules, "id", "decision table rule")
+      indexes = rules.map { |rule| rule["index"] }
+      fail_with("decision table rule indexes must be consecutive") unless indexes.sort == (0...rules.length).to_a
+      condition_count = decision["conditions"].length
+      rules.each { |rule| validate_decision_table_rule(rule, decision, condition_count) }
+      validate_decision_table_counts(table, rules)
+      validate_decision_table_summary(table, rules)
+    end
+
+    def validate_decision_table_rule(rule, decision, condition_count)
+      fail_with("invalid decision table rule") unless hash_with_string_keys?(rule)
+      validate_string_field(rule, "label")
+      validate_integer_field(rule, "index")
+      unless rule["index"].is_a?(Integer) && rule["index"] >= 0
+        fail_with("decision table rule index must be nonnegative")
+      end
+      fail_with("decision table rule label does not match its index") unless rule["label"] == "R#{rule["index"] + 1}"
+      conditions = rule["conditions"]
+      valid = conditions.is_a?(Array) && conditions.length == condition_count &&
+              conditions.all? { |value| RULE_CONDITION_VALUES.include?(value) }
+      fail_with("decision table rule conditions do not match the decision") unless valid
+      fail_with("decision table rule outcome must be boolean") unless [true, false].include?(rule["outcome"])
+      expected_id = DecisionTable.rule_id(decision["id"], conditions, rule["outcome"])
+      unless rule["id"] == expected_id
+        fail_with("decision table rule id does not match its decision, conditions, and outcome")
+      end
+      fail_with("invalid decision table rule coverage") unless RULE_COVERAGE_STATUSES.include?(rule["coverage"])
+      unless RULE_REACHABILITY_STATUSES.include?(rule["reachability"])
+        fail_with("invalid decision table rule reachability")
+      end
+      validate_string_field(rule, "reachability_reason", nullable: true)
+      if rule["reachability"] == "statically_impossible" && !rule["reachability_reason"].is_a?(String)
+        fail_with("statically impossible rule requires a reason code")
+      end
+      if %w[observed unknown].include?(rule["reachability"]) && !rule["reachability_reason"].nil?
+        fail_with("observed or unknown rule must not have a reachability reason")
+      end
+      fail_with("decision table rule tests must be strings") unless strings?(rule["tests"])
+      fail_with("unknown decision table rule test") unless rule["tests"].all? { |id| @test_id_set.include?(id) }
+      fail_with("decision table rule vector_ids must be strings") unless strings?(rule["vector_ids"])
+      unless rule["vector_ids"].uniq.length == rule["vector_ids"].length
+        fail_with("duplicate decision table rule vector")
+      end
+      fail_with("unknown decision table rule vector") unless rule["vector_ids"].all? do |id|
+        @vector_decision_by_id[id] == decision["id"]
+      end
+      validate_decision_table_evidence(rule, decision)
+      validate_integer_field(rule, "unattributed_count")
+      unless rule["unattributed_count"].is_a?(Integer) && rule["unattributed_count"] >= 0
+        fail_with("decision table rule unattributed count must be nonnegative")
+      end
+      return unless rule["coverage"] == "covered" && rule["vector_ids"].empty?
+
+      fail_with("covered decision table rule requires evidence")
+    end
+
+    def validate_decision_table_counts(table, rules)
+      if table["status"] == "not_calculated"
+        fail_with("not_calculated decision table must not contain rules") unless rules.empty?
+        %w[generated_rules impossible_rules required_rules covered_rules missing_rules].each do |field|
+          fail_with("not_calculated decision table #{field} must be zero") unless table[field].zero?
+        end
+        return
+      end
+
+      fail_with("decision_table generated_rules mismatch") unless table["generated_rules"] == rules.length
+      impossible = rules.count { |rule| rule["coverage"] == "excluded" }
+      covered = rules.count { |rule| rule["coverage"] == "covered" }
+      fail_with("decision_table impossible_rules mismatch") unless table["impossible_rules"] == impossible
+      fail_with("decision_table required_rules mismatch") unless table["required_rules"] == rules.length - impossible
+      fail_with("decision_table covered_rules mismatch") unless table["covered_rules"] == covered
+      return if table["missing_rules"] == table["required_rules"] - table["covered_rules"]
+
+      fail_with("decision_table missing_rules mismatch")
+    end
+
+    def validate_decision_table_summary(table, rules)
+      if table["status"] == "not_calculated"
+        allowed_reason = DecisionTable::NOT_CALCULATED_REASONS.include?(table["reason"])
+        fail_with("not_calculated decision table requires a supported reason") unless allowed_reason
+        expected_status = table["reason"] == "unsupported_decision" ? "unsupported" : "not_calculated"
+        unless table["coverage_status"] == expected_status
+          fail_with("not_calculated decision table coverage status mismatch")
+        end
+        fail_with("not_calculated decision table percentage must be null") unless table["percentage"].nil?
+        unless table["reachability_analyzed"] == false
+          fail_with("not_calculated decision table reachability must be false")
+        end
+        return
+      end
+
+      fail_with("calculated decision table reason must be null") unless table["reason"].nil?
+      reachability_analyzed = table["reachability_analyzed"]
+      unless [true, false].include?(reachability_analyzed)
+        fail_with("decision_table reachability_analyzed must be boolean")
+      end
+      required = table["required_rules"]
+      covered = table["covered_rules"]
+      generated = table["generated_rules"]
+      expected_status = DecisionTable.coverage_status(covered, required, generated)
+      fail_with("decision_table coverage status mismatch") unless table["coverage_status"] == expected_status
+      expected_percentage = DecisionTable.percentage(covered, required)
+      fail_with("decision_table percentage mismatch") unless table["percentage"] == expected_percentage
+      return unless table["reachability_analyzed"] == false
+
+      fail_with("un-analyzed reachability cannot exclude rules") if rules.any? do |rule|
+        rule["coverage"] == "excluded"
+      end
+      fail_with("un-analyzed reachability contains impossible rule") if rules.any? do |rule|
+        rule["reachability"] == "statically_impossible"
+      end
+    end
+
+    def validate_decision_table_evidence(rule, _decision)
+      rule["vector_ids"].each do |vector_id|
+        vector = @vectors_by_id.fetch(vector_id)
+        matches = vector["outcome"] == rule["outcome"] && rule["conditions"].each_with_index.all? do |required, index|
+          required == DecisionTable::DONT_CARE || vector["values"][index] == (required == DecisionTable::TRUE_VALUE)
+        end
+        fail_with("decision table rule evidence does not match its conditions and outcome") unless matches
+      end
+      expected_tests = rule["vector_ids"].flat_map { |id| @vectors_by_id.fetch(id)["test_ids"] }.uniq.sort
+      fail_with("decision table rule tests do not match its evidence") unless rule["tests"].sort == expected_tests
+      expected_unattributed = rule["vector_ids"].sum { |id| @vectors_by_id.fetch(id).fetch("unattributed_count", 0) }
+      unless rule["unattributed_count"] == expected_unattributed
+        fail_with("decision table rule unattributed count does not match its evidence")
+      end
+      if rule["coverage"] == "covered" && rule["reachability"] != "observed"
+        fail_with("covered decision table rule requires observed reachability")
+      end
+      if rule["coverage"] == "excluded" && rule["reachability"] != "statically_impossible"
+        fail_with("excluded decision table rule requires static impossibility")
+      end
+      if rule["coverage"] == "missing" && rule["reachability"] != "unknown"
+        fail_with("missing decision table rule requires unknown reachability")
+      end
+      return unless %w[missing excluded].include?(rule["coverage"])
+
+      fail_with("noncovered decision table rule must not contain evidence") unless rule["vector_ids"].empty? &&
+                                                                                   rule["tests"].empty? &&
+                                                                                   rule["unattributed_count"].zero?
+    end
+
     def decision_kind(decision)
       kind = decision && decision["kind"]
       kind.nil? || kind.empty? ? "boolean" : kind
@@ -359,12 +542,16 @@ module Branchproof
       unless evidence["vector_ids"].uniq.length == evidence["vector_ids"].length
         fail_with("duplicate alternative evidence vector")
       end
-      fail_with("unknown alternative evidence vector") unless (evidence["vector_ids"] - @vector_ids).empty?
+      fail_with("unknown alternative evidence vector") unless evidence["vector_ids"].all? do |id|
+        @vectors_by_id.key?(id)
+      end
       fail_with("alternative evidence test_ids must be strings") unless strings?(evidence["test_ids"])
       unless evidence["test_ids"].uniq.length == evidence["test_ids"].length
         fail_with("duplicate alternative evidence test")
       end
-      fail_with("unknown alternative evidence test") unless (evidence["test_ids"] - @test_ids).empty?
+      fail_with("unknown alternative evidence test") unless evidence["test_ids"].all? do |id|
+        @test_id_set.include?(id)
+      end
       validate_integer_field(evidence, "unattributed_count")
       return unless decision
 
@@ -381,9 +568,8 @@ module Branchproof
         end
       end
       fail_with("alternative evidence state mismatch") unless vectors.all?(&expected_value)
-      expected_vectors = @vectors_by_id.values.select do |vector|
-        vector["decision_id"] == decision["id"] && expected_value.call(vector)
-      end
+      decision_vectors = @vectors_by_decision.fetch(decision["id"], [])
+      expected_vectors = decision_vectors.select(&expected_value)
       expected_vector_ids = expected_vectors.map { |vector| vector["id"] }.sort
       fail_with("alternative evidence is incomplete") unless evidence["vector_ids"].sort == expected_vector_ids
       expected_tests = vectors.flat_map { |vector| vector["test_ids"] }.uniq.sort
@@ -412,7 +598,7 @@ module Branchproof
     end
 
     def strict_flow_decision?(decision)
-      @schema_version == "1.2" &&
+      STRICT_FLOW_SCHEMAS.include?(@schema_version) &&
         nonboolean_kind?(decision_kind(decision)) &&
         decision["support_status"].to_s.upcase != "UNSUPPORTED"
     end
@@ -446,7 +632,7 @@ module Branchproof
 
       valid = hash_with_string_keys?(phases) && phases.all? do |test_id, values|
         valid_phases = %w[setup body teardown suite unattributed]
-        @test_ids.include?(test_id) && strings?(values) && values.all? { |phase| valid_phases.include?(phase) }
+        @test_id_set.include?(test_id) && strings?(values) && values.all? { |phase| valid_phases.include?(phase) }
       end
       fail_with("invalid phases_by_test") unless valid
     end
@@ -556,7 +742,7 @@ module Branchproof
       return unless locations
 
       valid = hash_with_string_keys?(locations) && locations.all? do |test_id, location|
-        @test_ids.include?(test_id) && hash_with_string_keys?(location) &&
+        @test_id_set.include?(test_id) && hash_with_string_keys?(location) &&
           (!location.key?("relative_path") || location["relative_path"].nil? ||
             location["relative_path"].is_a?(String)) &&
           (!location.key?("line") || location["line"].nil? || location["line"].is_a?(Integer))

data/lib/branchproof/source.rb

@@ -4,6 +4,7 @@ require "digest"
 require "pathname"
 require "prism"
 require_relative "decision_syntax"
+require_relative "constraints"
 
 module Branchproof
   # Inventories supported condition and decision occurrences from Ruby files.
@@ -58,11 +59,13 @@ module Branchproof
     end
 
     def read_unit(path)
+      absolute_path = File.expand_path(path)
+      relative_path = relative(path)
       bytes = File.binread(path)
       parsed = Prism.parse(bytes)
       encoding = source_encoding(bytes, parsed)
-      source_id = Records.source_id(relative_path: relative(path), digest: Digest::SHA256.hexdigest(bytes),
-                                    encoding: encoding)
+      digest = Digest::SHA256.hexdigest(bytes)
+      source_id = Records.source_id(relative_path: relative_path, digest: digest, encoding: encoding)
       diagnostics = parsed.errors.map do |error|
         Records.diagnostic(code: "parse_error", severity: "error", message: error.message, source_id: source_id,
                            details: { byte_start: error.location.start_offset, byte_length: error.location.length })
@@ -78,11 +81,11 @@ module Branchproof
       file_reasons << "unsupported_data_section" if parsed.respond_to?(:data_loc) && parsed.data_loc
       file_reasons << "parse_error" unless parsed.errors.empty?
       decisions = parsed.value ? decisions_for(parsed.value, bytes, source_id, file_reasons, encoding) : []
-      Records.build(source_id: source_id, relative_path: relative(path), absolute_path: File.expand_path(path),
-                    real_path: File.realpath(path), digest: Digest::SHA256.hexdigest(bytes), encoding: encoding,
+      Records.build(source_id: source_id, relative_path: relative_path, absolute_path: absolute_path,
+                    real_path: File.realpath(path), digest: digest, encoding: encoding,
                     original_bytes: bytes, decisions: decisions, diagnostics: diagnostics)
     rescue SystemCallError => e
-      Records.build(source_id: nil, relative_path: relative(path), absolute_path: File.expand_path(path),
+      Records.build(source_id: nil, relative_path: relative_path, absolute_path: absolute_path,
                     real_path: nil, digest: nil, encoding: nil, original_bytes: nil, decisions: [],
                     diagnostics: [Records.diagnostic(code: "source_unreadable", severity: "error", message: e.message)])
     end
@@ -100,25 +103,53 @@ module Branchproof
       Encoding::UTF_8.name
     end
 
+    # Walks the whole program AST exactly once, sorting every node into the
+    # buckets the two classification phases below need. Phase one (decision
+    # and case-when nodes) must run to completion before phase two (bare
+    # boolean/pattern nodes) because phase two skips nodes phase one already
+    # inventoried via mark_semantic_boolean_nodes.
+    def collect_ast_nodes(program)
+      defined_ranges = []
+      guard_patterns = {}.compare_by_identity
+      phase_one_nodes = []
+      phase_two_nodes = []
+      flow_nodes = []
+
+      walk(program) do |node|
+        if node.is_a?(Prism::DefinedNode)
+          defined_ranges << node.location
+        elsif node.is_a?(Prism::InNode)
+          pattern = node.pattern
+          guard_patterns[pattern] = true if pattern.is_a?(Prism::IfNode) || pattern.is_a?(Prism::UnlessNode)
+        end
+        phase_one_nodes << node if decision_node?(node) || subjectless_case?(node)
+        phase_two_nodes << node if boolean_node?(node) || node.is_a?(Prism::MatchPredicateNode)
+        flow_nodes << node if flow_decision_node?(node)
+      end
+
+      { defined_ranges: defined_ranges, guard_patterns: guard_patterns, phase_one_nodes: phase_one_nodes,
+        phase_two_nodes: phase_two_nodes, flow_nodes: flow_nodes }
+    end
+
     def decisions_for(program, bytes, source_id, file_reasons = [], encoding = "UTF-8")
       specs = []
       inventoried_boolean_nodes = {}.compare_by_identity
-      defined_ranges = []
-      pattern_guard_nodes = pattern_guard_nodes_for(program)
+      collected = collect_ast_nodes(program)
+      defined_ranges = collected[:defined_ranges]
+      guard_patterns = collected[:guard_patterns]
 
-      walk(program) do |node|
-        defined_ranges << node.location if node.is_a?(Prism::DefinedNode)
+      collected[:phase_one_nodes].each do |node|
         if decision_node?(node)
           predicate = node.predicate
           next unless predicate
 
           predicate = unwrap_predicate(predicate)
-          context = pattern_guard_nodes[node] ? "pattern_guard" : decision_context(node, bytes)
+          context = guard_patterns[node] ? "pattern_guard" : decision_context(node, bytes)
           specs << { node: node, predicate: predicate, context: context }
           mark_semantic_boolean_nodes(predicate, inventoried_boolean_nodes)
-        elsif subjectless_case?(node)
-          when_nodes(node).each do |when_node|
-            when_predicates(when_node).each do |predicate|
+        else
+          conditions_for(node).each do |when_node|
+            conditions_for(when_node).each do |predicate|
               predicate = unwrap_predicate(predicate)
               specs << { node: when_node, predicate: predicate, context: "case_when" }
               mark_semantic_boolean_nodes(predicate, inventoried_boolean_nodes)
@@ -129,8 +160,7 @@ module Branchproof
 
       # Boolean expressions nested in an atomic expression (for example, a call
       # argument) are separate decisions when tree_for did not decompose them.
-      walk(program) do |node|
-        next unless boolean_node?(node) || node.is_a?(Prism::MatchPredicateNode)
+      collected[:phase_two_nodes].each do |node|
         next if inventoried_boolean_nodes[node]
 
         additional_reasons = if within_defined_expression?(node, defined_ranges)
@@ -158,16 +188,15 @@ module Branchproof
                        predicate: predicate, context: spec[:context],
                        additional_reasons: spec[:additional_reasons] || [])
       end
-      boolean_decisions + flow_decisions_for(program, bytes, source_id, file_reasons, encoding)
+      boolean_decisions + flow_decisions_for(program, bytes, source_id, file_reasons, encoding,
+                                             defined_ranges: defined_ranges, nodes: collected[:flow_nodes])
     end
 
-    def flow_decisions_for(program, bytes, source_id, file_reasons = [], encoding = "UTF-8")
-      defined_ranges = []
-      walk(program) do |node|
-        defined_ranges << node.location if node.is_a?(Prism::DefinedNode)
-      end
+    def flow_decisions_for(program, bytes, source_id, file_reasons = [], encoding = "UTF-8",
+                           defined_ranges: nil, nodes: nil)
+      defined_ranges ||= collect_defined_ranges(program)
 
-      super.map do |decision|
+      super(program, bytes, source_id, file_reasons, encoding, nodes: nodes).map do |decision|
         next decision unless range_within_defined_expression?(decision, defined_ranges)
 
         decision.merge(
@@ -177,23 +206,15 @@ module Branchproof
       end
     end
 
-    def pattern_guard_nodes_for(program)
-      guards = {}.compare_by_identity
-      walk(program) do |node|
-        next unless node.is_a?(Prism::InNode)
-
-        pattern = node.pattern
-        guards[pattern] = true if pattern.is_a?(Prism::IfNode) || pattern.is_a?(Prism::UnlessNode)
-      end
-      guards
+    def collect_defined_ranges(program)
+      defined_ranges = []
+      walk(program) { |node| defined_ranges << node.location if node.is_a?(Prism::DefinedNode) }
+      defined_ranges
     end
 
     def range_within_defined_expression?(decision, defined_ranges)
       start_offset = decision[:byte_start]
-      end_offset = start_offset + decision[:byte_length]
-      defined_ranges.any? do |defined_location|
-        defined_location.start_offset <= start_offset && defined_location.end_offset >= end_offset
-      end
+      offsets_within_defined_expression?(start_offset, start_offset + decision[:byte_length], defined_ranges)
     end
 
     def walk(node, &block)
@@ -214,16 +235,7 @@ module Branchproof
       node.is_a?(Prism::CaseNode) && node.predicate.nil?
     end
 
-    def when_nodes(node)
-      conditions = node.conditions
-      if conditions.is_a?(Array)
-        conditions
-      else
-        (conditions.respond_to?(:body) ? conditions.body : [])
-      end
-    end
-
-    def when_predicates(node)
+    def conditions_for(node)
       conditions = node.conditions
       if conditions.is_a?(Array)
         conditions
@@ -249,6 +261,7 @@ module Branchproof
       context ||= decision_context(node, bytes)
       leaves = []
       tree = tree_for(predicate, bytes, leaves)
+      decision_constraint_safe = constraint_safe_expression?(predicate)
       start_offset = predicate.location.start_offset
       length = predicate.location.length
       opaque_ranges = leaves.filter_map { |leaf| leaf.delete(:_opaque_range) }
@@ -256,9 +269,12 @@ module Branchproof
         expression = text_value(leaf.delete(:_expression), "UTF-8")
         location = leaf.delete(:_location)
         literal_truth = leaf.delete(:_literal_truth)
+        constraint = leaf.delete(:_constraint)
+        constraint_safe = leaf.delete(:_constraint_safe)
         Records.build(id: nil, index: index, byte_start: location.start_offset, byte_length: location.length,
                       line: location.start_line, column: location.start_column,
-                      expression: expression, literal_truth: literal_truth, coupling: "unknown")
+                      expression: expression, literal_truth: literal_truth, coupling: "unknown",
+                      constraint: constraint, constraint_safe: decision_constraint_safe && constraint_safe == true)
       end
       decision_id = Records.decision_id(source_id: source_id, context: context, byte_start: start_offset,
                                         byte_length: length, tree: tree)
@@ -287,9 +303,12 @@ module Branchproof
 
     def within_defined_expression?(node, defined_ranges)
       location = node.location
+      offsets_within_defined_expression?(location.start_offset, location.end_offset, defined_ranges)
+    end
+
+    def offsets_within_defined_expression?(start_offset, end_offset, defined_ranges)
       defined_ranges.any? do |defined_location|
-        defined_location.start_offset <= location.start_offset &&
-          defined_location.end_offset >= location.end_offset
+        defined_location.start_offset <= start_offset && defined_location.end_offset >= end_offset
       end
     end
 
@@ -330,6 +349,8 @@ module Branchproof
       leaf = {
         _expression: bytes.byteslice(location.start_offset, location.length), _location: location,
         _literal_truth: literal_truth(node),
+        _constraint: (constraint = Constraints.for_node(node)),
+        _constraint_safe: safe_constraint_node?(constraint),
         _opaque_range: if node.is_a?(Prism::CallNode) && node.name == :!
                          { start: location.start_offset, length: location.length }
                        end
@@ -338,6 +359,27 @@ module Branchproof
       Records.build(type: :atom, index: leaves.length - 1)
     end
 
+    # Source-derived comparisons are deliberately untrusted. Ruby permits
+    # mutation between leaves and user-defined operators, so only repeated
+    # truthiness reads of local variables in an entirely side-effect-free
+    # decision may be used by the table solver.
+    def constraint_safe_expression?(node)
+      node = unwrap_predicate(node)
+      case node
+      when Prism::AndNode, Prism::OrNode
+        constraint_safe_expression?(node.left) && constraint_safe_expression?(node.right)
+      when Prism::LocalVariableReadNode, Prism::TrueNode, Prism::FalseNode, Prism::NilNode,
+           Prism::IntegerNode, Prism::FloatNode, Prism::SymbolNode, Prism::StringNode
+        true
+      else
+        false
+      end
+    end
+
+    def safe_constraint_node?(constraint)
+      constraint && constraint[:operator] == "truthy" && constraint[:subject][:kind] == "local"
+    end
+
     def unary_not?(node)
       node.is_a?(Prism::CallNode) && node.name == :! && node.receiver && node.call_operator_loc.nil?
     end

data/lib/branchproof/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Branchproof
-  VERSION = "0.7.0"
+  VERSION = "0.8.0"
 end

data/lib/branchproof/worker.rb

@@ -14,12 +14,9 @@ module Branchproof
 
     def child_process(config_path)
       payload = JSON.parse(File.binread(config_path))
-      project = symbolize(payload.fetch("project", legacy_project))
+      project = symbolize(payload.fetch("project"))
       prepend_load_paths(project)
       inventory = symbolize(payload.fetch("inventory"))
-      Array(inventory[:source_units]).each do |unit|
-        unit[:original_bytes] = File.binread(unit[:absolute_path]) if unit[:absolute_path]
-      end
       limits = symbolize(payload.fetch("limits"))
       require "minitest"
       require "minitest/test"

data/lib/branchproof.rb

@@ -16,6 +16,8 @@ module Branchproof
   autoload :MinitestAdapter, "branchproof/minitest_adapter"
   autoload :Evidence, "branchproof/evidence"
   autoload :Analyzer, "branchproof/analyzer"
+  autoload :Constraints, "branchproof/constraints"
+  autoload :DecisionTable, "branchproof/decision_table"
   autoload :Minimizer, "branchproof/minimizer"
   autoload :Report, "branchproof/report"
   autoload :CoverageIndex, "branchproof/coverage_index"

data/llms.txt

@@ -2,7 +2,7 @@
 
 |  |  |
 | --- | --- |
-| **Defined in** | lib/branchproof.rb, lib/branchproof/cli.rb, lib/branchproof/limits.rb, lib/branchproof/loader.rb, lib/branchproof/report.rb, lib/branchproof/source.rb, lib/branchproof/worker.rb, lib/branchproof/project.rb, lib/branchproof/records.rb, lib/branchproof/runtime.rb, lib/branchproof/version.rb, lib/branchproof/analyzer.rb, lib/branchproof/evidence.rb, lib/branchproof/minimizer.rb, lib/branchproof/comparison.rb, lib/branchproof/instrumenter.rb, lib/branchproof/runtime_flow.rb, lib/branchproof/saved_report.rb, lib/branchproof/rails_support.rb, lib/branchproof/coverage_index.rb, lib/branchproof/focused_report.rb, lib/branchproof/decision_syntax.rb, lib/branchproof/minitest_adapter.rb, lib/branchproof/comparison_report.rb, lib/branchproof/flow_instrumentation.rb |
+| **Defined in** | lib/branchproof.rb, lib/branchproof/cli.rb, lib/branchproof/limits.rb, lib/branchproof/loader.rb, lib/branchproof/report.rb, lib/branchproof/source.rb, lib/branchproof/worker.rb, lib/branchproof/project.rb, lib/branchproof/records.rb, lib/branchproof/runtime.rb, lib/branchproof/version.rb, lib/branchproof/analyzer.rb, lib/branchproof/evidence.rb, lib/branchproof/minimizer.rb, lib/branchproof/comparison.rb, lib/branchproof/constraints.rb, lib/branchproof/instrumenter.rb, lib/branchproof/runtime_flow.rb, lib/branchproof/saved_report.rb, lib/branchproof/rails_support.rb, lib/branchproof/coverage_index.rb, lib/branchproof/decision_table.rb, lib/branchproof/focused_report.rb, lib/branchproof/decision_syntax.rb, lib/branchproof/minitest_adapter.rb, lib/branchproof/comparison_report.rb, lib/branchproof/flow_instrumentation.rb |
 
 Keep each bounded source rewrite together so its evaluation order can be
 audited. rubocop:disable Metrics/AbcSize, Metrics/MethodLength
@@ -17,8 +17,11 @@ Not documented.
 - [Branchproof/CLI.md](doc/Branchproof/CLI.md)
 - [Branchproof/Comparison.md](doc/Branchproof/Comparison.md)
 - [Branchproof/ComparisonReport.md](doc/Branchproof/ComparisonReport.md)
+- [Branchproof/Constraints/Solver.md](doc/Branchproof/Constraints/Solver.md)
+- [Branchproof/Constraints.md](doc/Branchproof/Constraints.md)
 - [Branchproof/CoverageIndex.md](doc/Branchproof/CoverageIndex.md)
 - [Branchproof/DecisionSyntax.md](doc/Branchproof/DecisionSyntax.md)
+- [Branchproof/DecisionTable.md](doc/Branchproof/DecisionTable.md)
 - [Branchproof/Error.md](doc/Branchproof/Error.md)
 - [Branchproof/Evidence.md](doc/Branchproof/Evidence.md)
 - [Branchproof/FlowInstrumentation.md](doc/Branchproof/FlowInstrumentation.md)