branchproof 0.6.0 → 0.8.0

data/lib/branchproof/source.rb

@@ -3,10 +3,14 @@
 require "digest"
 require "pathname"
 require "prism"
+require_relative "decision_syntax"
+require_relative "constraints"
 
 module Branchproof
   # Inventories supported condition and decision occurrences from Ruby files.
   class Source
+    include DecisionSyntax
+
     attr_reader :root, :limits
 
     def initialize(root:, limits:)
@@ -55,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 })
@@ -75,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
@@ -97,12 +103,118 @@ 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")
-      nodes = []
-      walk(program) { |node| nodes << node if decision_node?(node) }
-      nodes.sort_by { |node| node.location.start_offset }.map.with_index do |node, _|
-        build_decision(node, bytes, source_id, file_reasons, encoding)
+      specs = []
+      inventoried_boolean_nodes = {}.compare_by_identity
+      collected = collect_ast_nodes(program)
+      defined_ranges = collected[:defined_ranges]
+      guard_patterns = collected[:guard_patterns]
+
+      collected[:phase_one_nodes].each do |node|
+        if decision_node?(node)
+          predicate = node.predicate
+          next unless predicate
+
+          predicate = unwrap_predicate(predicate)
+          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)
+        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)
+            end
+          end
+        end
+      end
+
+      # Boolean expressions nested in an atomic expression (for example, a call
+      # argument) are separate decisions when tree_for did not decompose them.
+      collected[:phase_two_nodes].each do |node|
+        next if inventoried_boolean_nodes[node]
+
+        additional_reasons = if within_defined_expression?(node, defined_ranges)
+                               ["unsupported_defined_expression"]
+                             else
+                               []
+                             end
+        context = node.is_a?(Prism::MatchPredicateNode) ? "pattern_in" : "short_circuit"
+        specs << { node: nil, predicate: node, context: context,
+                   additional_reasons: additional_reasons }
+        mark_semantic_boolean_nodes(node, inventoried_boolean_nodes)
+      end
+
+      ordered_specs = specs.each_with_index.sort_by do |(spec, index)|
+        [spec[:predicate].location.start_offset, index]
+      end.map(&:first)
+      seen_ranges = {}
+      boolean_decisions = ordered_specs.filter_map do |spec|
+        predicate = spec[:predicate]
+        range = [predicate.location.start_offset, predicate.location.length]
+        next if seen_ranges[range]
+
+        seen_ranges[range] = true
+        build_decision(spec[:node], bytes, source_id, file_reasons, encoding,
+                       predicate: predicate, context: spec[:context],
+                       additional_reasons: spec[:additional_reasons] || [])
       end
+      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: nil, nodes: nil)
+      defined_ranges ||= collect_defined_ranges(program)
+
+      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(
+          support_status: "UNSUPPORTED",
+          support_reasons: (Array(decision[:support_reasons]) + ["unsupported_defined_expression"]).uniq
+        )
+      end
+    end
+
+    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]
+      offsets_within_defined_expression?(start_offset, start_offset + decision[:byte_length], defined_ranges)
     end
 
     def walk(node, &block)
@@ -111,39 +223,67 @@ module Branchproof
     end
 
     def decision_node?(node)
-      node.is_a?(Prism::IfNode) || node.is_a?(Prism::UnlessNode)
+      node.is_a?(Prism::IfNode) || node.is_a?(Prism::UnlessNode) ||
+        node.is_a?(Prism::WhileNode) || node.is_a?(Prism::UntilNode)
+    end
+
+    def boolean_node?(node)
+      node.is_a?(Prism::AndNode) || node.is_a?(Prism::OrNode)
     end
 
-    def build_decision(node, bytes, source_id, file_reasons = [], encoding = "UTF-8")
-      predicate = unwrap_predicate(node.predicate)
+    def subjectless_case?(node)
+      node.is_a?(Prism::CaseNode) && node.predicate.nil?
+    end
+
+    def conditions_for(node)
+      conditions = node.conditions
+      if conditions.is_a?(Array)
+        conditions
+      else
+        (conditions.respond_to?(:body) ? conditions.body : [])
+      end
+    end
+
+    def decision_context(node, bytes)
+      return "unless" if node.is_a?(Prism::UnlessNode)
+      return "while" if node.is_a?(Prism::WhileNode)
+      return "until" if node.is_a?(Prism::UntilNode)
+      return "ternary" if node.if_keyword_loc.nil?
+
+      token = bytes.byteslice(node.if_keyword_loc.start_offset, node.if_keyword_loc.length)
+      token == "elsif" ? "elsif" : "if"
+    end
+
+    def build_decision(node, bytes, source_id, file_reasons = [], encoding = "UTF-8", predicate: nil,
+                       context: nil, additional_reasons: [])
+      original_predicate = node.respond_to?(:predicate) ? node.predicate : nil
+      predicate ||= unwrap_predicate(original_predicate)
+      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
-      context = if node.is_a?(Prism::UnlessNode)
-                  "unless"
-                elsif node.if_keyword_loc.nil?
-                  "ternary"
-                else
-                  token = bytes.byteslice(node.if_keyword_loc.start_offset, node.if_keyword_loc.length)
-                  token == "elsif" ? "elsif" : "if"
-                end
       opaque_ranges = leaves.filter_map { |leaf| leaf.delete(:_opaque_range) }
       conditions = leaves.each_with_index.map do |leaf, index|
         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)
       conditions = conditions.map do |condition|
         condition.merge(id: Records.condition_id(decision_id, condition[:index]))
       end
-      reasons = unsupported_reasons(predicate, bytes) + file_reasons
-      reasons << "unsupported_control_expression" if ambiguous_parentheses?(node.predicate)
+      reasons = unsupported_reasons(predicate, bytes) + additional_reasons + file_reasons
+      reasons << "unsupported_case_splat" if predicate.is_a?(Prism::SplatNode)
+      reasons << "unsupported_control_expression" if ambiguous_parentheses?(original_predicate)
       reasons << "condition_limit_exceeded" if conditions.length > @limits[:conditions_per_decision]
       discovered_condition_count = conditions.length
       if discovered_condition_count > @limits[:conditions_per_decision]
@@ -152,14 +292,40 @@ module Branchproof
       end
       support = reasons.empty? ? "SUPPORTED" : "UNSUPPORTED"
       expression = text_value(bytes.byteslice(predicate.location.start_offset, predicate.location.length), encoding)
-      Records.build(id: decision_id, source_id: source_id, context: context, byte_start: start_offset,
-                    byte_length: length, line: predicate.location.start_line, column: predicate.location.start_column,
+      Records.build(id: decision_id, source_id: source_id, kind: "boolean", context: context,
+                    byte_start: start_offset, byte_length: length,
+                    line: predicate.location.start_line, column: predicate.location.start_column,
                     expression: expression,
                     tree: tree,
                     conditions: conditions, discovered_condition_count: discovered_condition_count,
                     support_status: support, support_reasons: reasons.uniq, opaque_ranges: opaque_ranges)
     end
 
+    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 <= start_offset && defined_location.end_offset >= end_offset
+      end
+    end
+
+    def mark_semantic_boolean_nodes(node, inventoried_boolean_nodes)
+      node = unwrap_predicate(node)
+      case node
+      when Prism::AndNode, Prism::OrNode
+        inventoried_boolean_nodes[node] = true
+        mark_semantic_boolean_nodes(node.left, inventoried_boolean_nodes)
+        mark_semantic_boolean_nodes(node.right, inventoried_boolean_nodes)
+      when Prism::MatchPredicateNode
+        inventoried_boolean_nodes[node] = true
+      when Prism::CallNode
+        mark_semantic_boolean_nodes(node.receiver, inventoried_boolean_nodes) if unary_not?(node)
+      end
+    end
+
     def tree_for(node, bytes, leaves)
       node = unwrap_predicate(node)
       case node
@@ -167,18 +333,57 @@ module Branchproof
         Records.build(type: :and, left: tree_for(node.left, bytes, leaves), right: tree_for(node.right, bytes, leaves))
       when Prism::OrNode
         Records.build(type: :or, left: tree_for(node.left, bytes, leaves), right: tree_for(node.right, bytes, leaves))
+      when Prism::CallNode
+        if unary_not?(node)
+          Records.build(type: :not, child: tree_for(node.receiver, bytes, leaves))
+        else
+          leaf_for(node, bytes, leaves)
+        end
       else
-        location = node.location
-        leaf = {
-          _expression: bytes.byteslice(location.start_offset, location.length), _location: location,
-          _literal_truth: literal_truth(node),
-          _opaque_range: opaque?(node) ? { start: location.start_offset, length: location.length } : nil
-        }
-        leaves << leaf
-        Records.build(type: :atom, index: leaves.length - 1)
+        leaf_for(node, bytes, leaves)
       end
     end
 
+    def leaf_for(node, bytes, leaves)
+      location = node.location
+      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
+      }
+      leaves << leaf
+      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
+
     def literal_truth(node)
       return true if node.is_a?(Prism::TrueNode)
       return false if node.is_a?(Prism::FalseNode) || node.is_a?(Prism::NilNode)
@@ -186,10 +391,6 @@ module Branchproof
       nil
     end
 
-    def opaque?(node)
-      node.is_a?(Prism::CallNode) && node.name == :!
-    end
-
     def unsupported_reasons(predicate, bytes)
       reasons = []
       walk(predicate) do |node|
@@ -197,13 +398,10 @@ module Branchproof
           reasons << "unsupported_implicit_regexp"
         end
         reasons << "unsupported_flip_flop" if node.is_a?(Prism::FlipFlopNode)
+        reasons << "unsupported_defined_expression" if node.is_a?(Prism::DefinedNode)
         reasons << "unsupported_heredoc" if node.respond_to?(:opening_loc) && node.opening_loc &&
                                             bytes.byteslice(node.opening_loc.start_offset,
                                                             node.opening_loc.length).start_with?("<<")
-        if (node.is_a?(Prism::AndNode) || node.is_a?(Prism::OrNode)) && node.respond_to?(:operator_loc)
-          operator = bytes.byteslice(node.operator_loc.start_offset, node.operator_loc.length)
-          reasons << "unsupported_keyword_boolean" if %w[and or].include?(operator)
-        end
       end
       reasons
     end

data/lib/branchproof/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Branchproof
-  VERSION = "0.6.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,9 +2,10 @@
 
 |  |  |
 | --- | --- |
-| **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/saved_report.rb, lib/branchproof/rails_support.rb, lib/branchproof/coverage_index.rb, lib/branchproof/focused_report.rb, lib/branchproof/minitest_adapter.rb, lib/branchproof/comparison_report.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 |
 
-Public namespace for source inventory and one-run MC/DC reporting.
+Keep each bounded source rewrite together so its evaluation order can be
+audited. rubocop:disable Metrics/AbcSize, Metrics/MethodLength
 
 ## Constants
 ### `VERSION` <a id="constant-VERSION"></a> <a id="VERSION-constant"></a>
@@ -16,9 +17,14 @@ 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)
 - [Branchproof/FocusedReport.md](doc/Branchproof/FocusedReport.md)
 - [Branchproof/Instrumenter.md](doc/Branchproof/Instrumenter.md)
 - [Branchproof/Limits.md](doc/Branchproof/Limits.md)
@@ -31,6 +37,7 @@ Not documented.
 - [Branchproof/Records.md](doc/Branchproof/Records.md)
 - [Branchproof/Report.md](doc/Branchproof/Report.md)
 - [Branchproof/Runtime.md](doc/Branchproof/Runtime.md)
+- [Branchproof/RuntimeFlow.md](doc/Branchproof/RuntimeFlow.md)
 - [Branchproof/SavedReport.md](doc/Branchproof/SavedReport.md)
 - [Branchproof/Source.md](doc/Branchproof/Source.md)
 - [Branchproof/Worker.md](doc/Branchproof/Worker.md)

data/sig/branchproof.rbs

@@ -62,6 +62,12 @@ module Branchproof
     def self.condition: (String decision_id, Integer index, untyped value) -> untyped
     def self.finish: (String decision_id, untyped value) -> untyped
     def self.leave: (String decision_id) -> nil
+    def self.flow_candidate: (String decision_id, Integer index) -> nil
+    def self.flow_selected: (String decision_id) -> nil
+    def self.flow_select: (String decision_id, Integer index) -> nil
+    def self.flow_path: (String decision_id, Integer index) -> nil
+    def self.flow_finish: (String decision_id, untyped value, ?Integer? default_path) -> untyped
+    def self.flow_receiver: (String decision_id, untyped receiver) -> untyped
     def self.context: (?test_id: String?, ?phase: String?) -> nil
     def self.snapshot: () -> record
     def self.diagnostics: () -> Array[record]
@@ -83,12 +89,53 @@ module Branchproof
 
   class Analyzer
     CRITERION: String
-    def initialize: (inventory: record, evidence: record, limits: limits) -> void
+    def initialize: (inventory: record, evidence: record, limits: limits, ?reachability: bool) -> void
     def call: () -> record
     def pair?: (decision_id: String, condition_index: Integer, left: record, right: record) -> bool
     def missing: (decision_id: String, condition_index: Integer) -> record?
   end
 
+  module Constraints
+    VERSION: Integer
+    NUMERIC_OPERATORS: Array[String]
+    COMPARISON_OPERATORS: Array[String]
+    OPERATORS: Array[String]
+    LITERAL_TYPES: Array[String]
+    SUBJECT_KINDS: Array[String]
+    REASONS: Array[String]
+
+    class Solver
+      def initialize: () -> void
+      def add: (record? constraint, bool truth) -> String?
+      def add_prepared: (record constraint, bool truth) -> String?
+    end
+
+    def self.for_node: (untyped node) -> record?
+    def self.usable?: (untyped constraint) -> bool
+    def self.message: (untyped reason) -> String
+  end
+
+  module DecisionTable
+    SCHEMA_VERSION: Integer
+    CONSTRAINT_ANALYSIS_VERSION: Integer
+    TRUE_VALUE: String
+    FALSE_VALUE: String
+    DONT_CARE: String
+    CONDITION_VALUES: Array[String]
+    VALUE_LABELS: Hash[String, String]
+    REACHABILITY_STATUSES: Array[String]
+    COVERAGE_STATUSES: Array[String]
+    TABLE_STATUSES: Array[String]
+    NOT_CALCULATED_REASONS: Array[String]
+    DEFAULT_MAX_CONDITIONS: Integer
+    DEFAULT_MAX_RULES: Integer
+
+    def self.build: (decision: record, ?vectors: Array[record], ?limits: limits, ?reachability: bool) -> record
+    def self.rule_id: (String decision_id, Array[String] values, bool outcome) -> String
+    def self.coverage_entry: (record table) -> record
+    def self.unsupported_coverage_entry: () -> record
+  end
+
   class Minimizer
     def initialize: (analysis: record, evidence: record, limits: limits) -> void
     def call: (objective: Symbol, decision_ids: Array[String]) -> record
@@ -103,10 +150,14 @@ module Branchproof
   class Report
     SCHEMA_VERSION: String
     CRITERION_VERSION: String
+    VIEWS: Array[Symbol]
     def initialize: (inventory: document, evidence: document, analysis: document?, minima: Array[document], baseline: document, diagnostics: Array[document], ?level: Integer, ?missing_only: bool, ?view: Symbol, ?run_metadata: document, ?saved_document: document?) -> void
     def self.from_document: (document: document, ?level: Integer?, ?view: Symbol, ?missing_only: bool) -> Report
     def diagnostic_message: (Hash[Symbol | String, untyped] diagnostic) -> String
     def condition_explanation: (decision_id: String, condition_id: String) -> String
+    def decision_table_requirement: (untyped value) -> String?
+    def decision_table_reachability: (document rule) -> String
+    def decision_table_expected_heading: (document decision) -> String
     def write: (io: _WriteIO, format: Symbol | String) -> nil
     def exit_code: () -> Integer
   end
@@ -114,7 +165,9 @@ module Branchproof
   class CoverageIndex
     def initialize: (document: document) -> void
     attr_reader conditions: Array[record]
+    attr_reader alternatives: Array[record]
     attr_reader tests: Array[record]
+    attr_reader decision_tables: Array[record]
   end
 
   class FocusedReport

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: branchproof
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.8.0
 platform: ruby
 authors:
 - Lucian Ghinda
@@ -70,9 +70,14 @@ files:
 - doc/Branchproof/CLI.md
 - doc/Branchproof/Comparison.md
 - doc/Branchproof/ComparisonReport.md
+- doc/Branchproof/Constraints.md
+- doc/Branchproof/Constraints/Solver.md
 - doc/Branchproof/CoverageIndex.md
+- doc/Branchproof/DecisionSyntax.md
+- doc/Branchproof/DecisionTable.md
 - doc/Branchproof/Error.md
 - doc/Branchproof/Evidence.md
+- doc/Branchproof/FlowInstrumentation.md
 - doc/Branchproof/FocusedReport.md
 - doc/Branchproof/Instrumenter.md
 - doc/Branchproof/Limits.md
@@ -85,6 +90,7 @@ files:
 - doc/Branchproof/Records.md
 - doc/Branchproof/Report.md
 - doc/Branchproof/Runtime.md
+- doc/Branchproof/RuntimeFlow.md
 - doc/Branchproof/SavedReport.md
 - doc/Branchproof/Source.md
 - doc/Branchproof/Worker.md
@@ -97,8 +103,12 @@ files:
 - lib/branchproof/cli.rb
 - lib/branchproof/comparison.rb
 - lib/branchproof/comparison_report.rb
+- lib/branchproof/constraints.rb
 - lib/branchproof/coverage_index.rb
+- lib/branchproof/decision_syntax.rb
+- lib/branchproof/decision_table.rb
 - lib/branchproof/evidence.rb
+- lib/branchproof/flow_instrumentation.rb
 - lib/branchproof/focused_report.rb
 - lib/branchproof/instrumenter.rb
 - lib/branchproof/limits.rb
@@ -110,6 +120,7 @@ files:
 - lib/branchproof/records.rb
 - lib/branchproof/report.rb
 - lib/branchproof/runtime.rb
+- lib/branchproof/runtime_flow.rb
 - lib/branchproof/saved_report.rb
 - lib/branchproof/source.rb
 - lib/branchproof/version.rb