branchproof 0.6.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b5d48afceb9c6608abf5ebdb2aa6f402dd11b75f43421b49686cc49fd95641c3
-  data.tar.gz: 647789d869c3a01f1809eacc871df99e4e0f81c7d8e70ffdb27228f4fd5c797e
+  metadata.gz: c76fa40f75fbd8122fc0fbb45a1c9d460fa3478f783951674e0e4c2707d44175
+  data.tar.gz: b4b0b88c1a0d5e61797ab52174f1841c57f1dde359d405dc1205bcff27810968
 SHA512:
-  metadata.gz: b5f87cd4aee8588f7a86ba6a91730b7b4a787c256a0485f6dc278acbd948a5a1399669d0e2903371b28f1b7058e5339efb85fdb13d31110944e6462bdfe55b6a
-  data.tar.gz: fb81f01ba2e42014364959afcdce9c8cd218611299d8bbd27a0a9fd5ed1ce1f2d311993f834b9f960934deadab659848257010717c2bdcc6814ea01870f985e2
+  metadata.gz: c32db269cece96c843093cc72accffd3921e56eb2a6b974b61c2d87cd696444ffd0d7fff25ed50ac3c5cadf2e6c316ccfd99aaf4f6c28344112c30451cf8e22a
+  data.tar.gz: 54a46ff6c7a753e2015bdb814d13fc576bc2d9bd88fa18d0bb4bee8f1f939fbcea62b9f006d31a3c5e99ac0d9c95de8a8bbea8d43db05c1a767c3ff828430f8b

data/CHANGELOG.md

@@ -1,5 +1,50 @@
 ## [Unreleased]
 
+## [0.8.0] - 2026-09-17
+
+- Derive a reduced decision table for every supported Boolean decision from its
+  `AND`/`OR`/`NOT`/atom structure, preserving Ruby short-circuit semantics with
+  an explicit `dont_care` value instead of exhaustive Cartesian expansion.
+- Give every rule a stable identity derived from the decision, its normalized
+  condition vector, the expected outcome, and the table schema version, so
+  saved reports compare across runs, test order, and Minitest seeds.
+- Overlay the existing run's observations onto the rules, attribute covered
+  rules to their Minitest tests, and describe uncovered rules as condition-value
+  requirements. No additional test execution is performed.
+- Report Decision Table Coverage as its own criterion in the coverage ladder,
+  per decision and in aggregate, independently from MC/DC in both directions.
+- Add conservative reachability: `observed`, `unknown`, and
+  `statically_impossible` with stable reason codes. Constraint analysis version 2
+  requires safe source constraints before excluding rules, keeping arbitrary
+  comparison receivers, mutation, and unordered numeric cases unknown.
+- Exclude statically impossible rules from coverage denominators while keeping
+  them visible, and let runtime evidence withdraw an impossibility claim with a
+  `constraint_model_conflict` diagnostic.
+- Add `--view decision-tables`, which honours `--missing-only` and never lists
+  an impossible rule as a missing obligation.
+- Bound table derivation with the new `max_conditions_for_decision_table` and
+  `decision_table_rules_per_decision` limits.
+- Persist the table, rule identities, coverage, attribution, and reachability in
+  schema `1.3` reports, and distinguish rule-coverage changes from reachability
+  changes in offline comparison.
+- Enforce exact rule-limit boundaries and index runtime rule matching rather
+  than scanning all observations per rule.
+- Add `--no-reachability` to keep all generated rules as coverage obligations.
+- Align the JSON regression flag with decision-table CLI failures, report
+  analysis-version changes, and validate saved rule identities and evidence.
+- Keep uncalculated decision locations and reasons in missing-only reports;
+  label `unless` and `until` outcomes as predicate values.
+
+## [0.7.0] - 2026-09-10
+
+- Discover Boolean loop predicates, subjectless case candidates, standalone
+  short-circuit expressions, and pattern predicates through Prism.
+- Analyze unary NOT and keyword `and`/`or` with Ruby's parsed precedence.
+- Attribute selected paths for ordinary case, unguarded case/in, safe navigation,
+  and conditional assignments without adding them to MC/DC denominators.
+- Expose decision kinds, contexts, alternative evidence, and explicit unsupported
+  constructs in schema 1.2 reports while retaining older saved-report support.
+
 ## [0.6.0] - 2026-09-10
 
 - Report Decision, Condition, and Condition/Decision Coverage alongside

data/README.md

@@ -1,10 +1,11 @@
 # Branchproof
 
-Branchproof measures modified condition/decision coverage (MC/DC) from one
-serial Minitest run. It inventories supported `if`, `unless`, `elsif`,
-modifier, and ordinary ternary (`?:`) decisions, records observed vectors,
-and reports independence evidence, missing counterpart constraints, and
-smaller supporting test sets.
+Branchproof measures decision, condition, modified condition/decision (MC/DC),
+and decision-table coverage from one serial Minitest run. It discovers Ruby
+decisions through Prism, records their runtime paths, and attributes evidence
+to tests. Boolean decisions receive the coverage ladder; `case`, pattern
+alternatives, safe navigation, and conditional assignments receive alternative
+coverage.
 
 The gem and primary command are named `branchproof`. The `mcdc` command and
 `MCDC` namespace remain compatibility aliases with the same behavior.
@@ -128,7 +129,7 @@ json` when a consumer needs the complete identifiers and versioned schema.
 
 ### Coverage ladder
 
-Each successful `analyze` run calculates four criteria from the same completed
+Each successful `analyze` run calculates five criteria from the same completed
 observations. The report shows their status for each supported decision and
 aggregate counts with explicit denominators:
 
@@ -138,6 +139,7 @@ aggregate counts with explicit denominators:
 | Condition | Every atomic condition evaluated both true and false | Two required truth values per supported condition |
 | Condition/Decision | Both Decision and Condition Coverage hold for a decision | Supported decisions |
 | MC/DC | Every condition has an independence witness pair | Supported conditions |
+| Decision Table | Every executable logical rule was exercised | Non-impossible generated rules |
 
 For `logged_in? && admin?`, observations `[F-] => F` and `[TT] => T` give:
 
@@ -146,6 +148,7 @@ Decision                    PASS
 Condition                   FAIL (3/4 values observed)
 Condition/Decision          FAIL
 MC/DC                       FAIL (1/2 conditions proven)
+Decision Table              FAIL (2/3 rules covered)
 ```
 
 The skipped `admin?` in `[F-]` counts as neither true nor false. Conditions
@@ -155,6 +158,12 @@ for `logged_in?`; `admin?` still needs `[TF] => F`.
 
 Decision and Condition Coverage are calculated independently from the captured
 evidence. Condition/Decision requires both; MC/DC adds independence evidence.
+Decision Table Coverage is calculated independently of all of them: MC/DC asks
+whether each condition can independently affect the outcome, while Decision
+Table Coverage asks whether each logical rule was exercised. Neither status is
+inferred from the other, so `MC/DC PASS` with `Decision Table FAIL` and the
+reverse are both valid results.
+
 Unsupported decisions are excluded from every denominator, while
 unexecuted supported decisions remain in scope. Empty denominators are N/A.
 
@@ -170,6 +179,184 @@ under `analysis.decisions[].coverage`, and condition value evidence under
 pairs, counterpart constraints, and raw vectors remain available. Statuses
 distinguish `covered`, `partial`, `unexecuted`, and `unsupported` results.
 
+### Decision table coverage
+
+For a Boolean decision Branchproof can represent with `AND`, `OR`, `NOT`, and
+atomic conditions, it derives a reduced decision table statically from the
+Boolean structure and then overlays the runtime evidence of the same run. No
+application code is executed while the table is derived, and no extra test run
+is performed while it is overlaid.
+
+Rules come directly from the short-circuit evaluation paths of the Ruby expression,
+so a condition the interpreter would
+skip appears as an explicit don't-care (`-`) rather than as two separate rules.
+Exhaustive Boolean expansion is deferred; it is not required to calculate coverage
+and is never performed on the reporting path.
+For `premium? && (admin? || owner?)`:
+
+```text
+Decision Table: 3/4 rules covered (75.0%)
+  Rule  premium?  admin?  owner?  Result  Status
+  R1    F         -       -       F       COVERED
+  R2    T         T       -       T       COVERED
+  R3    T         F       T       T       MISSING
+  R4    T         F       F       F       COVERED
+  R1 tests: UserAccessTest#test_free_user
+  R2 tests: UserAccessTest#test_admin
+  R3
+  Need:
+    premium? = truthy
+    admin?   = falsey
+    owner?   = truthy
+  Expected decision:
+    true
+  Reachability:
+    unknown
+  R4 tests: UserAccessTest#test_denied
+```
+
+A missing rule describes condition values only. It does not claim which
+application inputs would produce them.
+
+An observation matches a rule when every required condition value matches and
+the decision outcome matches. Conditions Ruby skipped can only line up with
+don't-care positions; they never satisfy a required true or false. Every rule
+carries a stable identity derived from the decision, its normalized condition
+vector, the expected outcome, and the table schema version — never from a test
+name, an observation order, or the Minitest seed, so saved reports compare
+across runs.
+
+Decision tables are derived for `if`, `unless`, `elsif`, ternary, `while`,
+`until`, subjectless `case`/`when`, and supported Boolean pattern guards.
+Multi-way `case`/`when`, `case`/`in` alternatives, safe navigation, conditional
+assignment, and exception handling keep their alternative coverage model and
+produce no Boolean table.
+For `unless` and `until`, the outcome is the predicate value, not whether the
+body executes; the terminal report labels it accordingly.
+
+#### Reachability and impossible rules
+
+Each rule carries a reachability status: `observed`, `unknown`, or
+`statically_impossible`. Branchproof proves impossibility or leaves
+reachability unknown. It never infers impossibility from a missing test, a
+missing observation, application conventions, Rails validations, database
+constraints, comments, or method names.
+
+Constraint analysis version 2 requires evidence that a constraint is safe before
+using it to exclude a rule. A variable name and a numeric literal do not prove
+that the receiver is a number, that its comparison methods use built-in semantics,
+or that its value stays unchanged. Numeric, equality, and nil-check expressions
+are still normalized for inspection, but unproven source constraints remain
+`unknown`. The standalone constraint solver describes its explicit model, not
+arbitrary Ruby objects.
+
+Literal truth values can establish impossibility without invoking application
+methods. For `age && false`, the rule requiring the literal `false` to be truthy
+cannot execute:
+
+```text
+Decision Table: 2/2 rules covered (100.0%)
+Statically impossible rules excluded: 1
+  Rule  age  false  Result  Status
+  R1    F    -      F       COVERED
+  R2    T    F      F       COVERED
+  R3    T    T      T       EXCLUDED
+  R3 TT => T
+  Status:
+    EXCLUDED
+  Reachability:
+    STATICALLY IMPOSSIBLE
+  Reason:
+    conflicting Boolean literal requirements
+```
+
+Impossible rules stay visible in the full report but leave the coverage
+denominator. Reason codes are stable: `conflicting_numeric_bounds`,
+`conflicting_equalities`, `equality_outside_numeric_range`, `nil_conflict`, and
+`boolean_literal_conflict`. Human-readable messages may change independently.
+
+Runtime evidence is authoritative. If an observation matches a rule the static
+model called impossible, the rule becomes `observed`, the impossibility claim is
+withdrawn, the rule returns to the denominator, and a `constraint_model_conflict`
+diagnostic records the disagreement.
+
+For example, `age > 10 && age < 5` stays unknown without a proven domain;
+custom comparison methods can make both comparisons true. Similarly,
+`x > 10 && (x = 0) && x < 5` can execute successfully. `Float::NAN` also prevents
+treating a false comparison as its ordered complement. Runtime evidence can cover
+these rules, but lack of evidence cannot exclude them. Ruby truthiness remains
+distinct from Boolean equality: only `false` and `nil` are falsey.
+
+Use `analyze --no-reachability` to disable all static exclusions, including literal
+proofs. Every generated rule then remains an obligation; reports show
+`Reachability: not analyzed`. The mode is persisted with the report and considered
+when comparing analysis contexts. Reading a saved report preserves its original
+analysis; it does not recalculate it under a different mode.
+
+#### Decision table views and limits
+
+`--view decision-tables` groups the terminal report by decision table, and
+`--missing-only` narrows it to uncovered, non-impossible rules while retaining
+uncalculated decisions with their location and reason. `decision_tables` is an
+accepted compatibility spelling for the view:
+
+```sh
+bundle exec branchproof analyze 'lib/**/*.rb' \
+  --view decision-tables \
+  --missing-only
+```
+
+Tables grow exponentially with condition count, so
+`max_conditions_for_decision_table` (default 12) and
+`decision_table_rules_per_decision` (default 4096) bound the derivation. A
+decision above either limit reports `Decision Table: NOT CALCULATED` with the
+reason `decision_table_condition_limit_exceeded` or
+`decision_table_rule_limit_exceeded` instead of a partial table.
+
+JSON stores the table under `analysis.decisions[].decision_table` with its
+`schema_version`, `constraint_analysis_version`, rules, rule identities, rule
+coverage, test attribution, reachability, and reachability reason. This abbreviated
+example omits counts and evidence bookkeeping fields; full reports also retain
+rule indexes, vector IDs, unattributed counts, and withdrawn-impossibility details:
+
+```json
+{
+  "decision_table": {
+    "status": "calculated",
+    "schema_version": 1,
+    "constraint_analysis_version": 2,
+    "rules": [
+      {
+        "id": "8f1c...",
+        "label": "R1",
+        "conditions": ["false", "dont_care", "dont_care"],
+        "outcome": false,
+        "coverage": "covered",
+        "reachability": "observed",
+        "tests": ["..."]
+      },
+      {
+        "id": "3ad0...",
+        "label": "R3",
+        "conditions": ["true", "false", "true"],
+        "outcome": true,
+        "coverage": "missing",
+        "reachability": "unknown",
+        "tests": []
+      }
+    ]
+  }
+}
+```
+
+Aggregate counts live under `analysis.coverage.decision_table` and keep rule
+coverage and fully covered decisions as distinct metrics:
+
+```text
+DT (Decision table coverage): 83.9% (47/56 rules)
+Decision tables fully covered: 13/18 decisions
+```
+
 ### Find missing cases
 
 Use `--missing-only` to focus the terminal report on conditions that still
@@ -231,7 +418,7 @@ analysis even at Level 1. A failed, unsupported, or incomplete run is reported
 with its status and diagnostics and cannot become a successful coverage
 result by changing the display level.
 
-### Focused condition and test views
+### Focused condition, test, and decision-table views
 
 Use `--view conditions` to group the report by condition. Each condition shows
 its expression, decision, and project-relative source location with the
@@ -253,6 +440,10 @@ conditions. A test that evaluates both Boolean values is evidence of execution;
 it is a proof contributor only when the analyzer's independent witness pair
 uses its observations.
 
+Use `--view decision-tables` to group the report by decision table. See
+[Decision table coverage](#decision-table-coverage) for the rule, reachability,
+and attribution detail it renders.
+
 `--view` changes terminal grouping and does not change instrumentation or test
 execution. JSON output always contains the complete evidence document, so an
 explicit view cannot be combined with `--format json`. The `mcdc` executable
@@ -308,7 +499,12 @@ patterns is valid comparison context, and seed differences are disclosed.
 
 `compare` exits 0 for a complete comparison, including one with coverage
 changes; `--fail-on-regression` exits 1 when a complete comparable run loses
-proof. Invalid input or an incomplete comparison exits 2, which takes
+MC/DC proof or decision-table rule coverage. The JSON `regression` flag includes
+either kind of loss; `regressions` retains the MC/DC count and
+`decision_table_regressions` supplies the separate rule-loss count. Changes to
+table schemas, constraint-analysis versions, or reachability modes are reported
+as analysis context changes rather than silently treated as unchanged analysis.
+Invalid input or an incomplete comparison exits 2, which takes
 precedence. Reports are explicit snapshots: comparison never creates history,
 promotes a baseline, or overwrites either input.
 
@@ -321,33 +517,89 @@ short-circuited or masked rather than fixed to the same observed values. For exa
 short-circuits it once, but does not prove `right`; `[TF]` is also required.
 The condition and test views preserve that distinction.
 
-### Supported conditional forms
+### Supported decision forms
 
-Ordinary Ruby ternaries use the same predicate instrumentation and `&&`/`||`
-condition trees as supported `if` decisions. For example:
+Every decision has a stable `kind` and `context` in JSON. The Boolean ladder
+applies to the following forms:
 
-```ruby
-value = ready ? false : true
-```
-
-Branchproof records `ready` as the ternary predicate. The decision outcome is
-therefore the truth value of `ready`, even though the selected branch returns
-`false` or `true`; branch selection, returned values, object identity, and
-evaluation order are unchanged. Ternaries nested inside other predicates are
-also inventoried at their own level, including all executed nested levels.
-Expanding the supported syntax increases the eligible-condition denominator,
-so percentages should be compared with that changed scope in mind.
-
-The existing predicate exclusions and analysis limits still apply. Keyword
-`and`/`or` expressions, contextual syntax, unsafe or ambiguous predicates,
-and limit overflows remain diagnostics rather than eligible coverage.
+| Construct | Kind | Context |
+| --- | --- | --- |
+| `if`, modifier `if`, `elsif`, `unless`, ternary | `boolean` | `if`, `elsif`, `unless`, `ternary` |
+| `while`, `until`, including modifier and post-test loops | `boolean` | `while`, `until` |
+| Each subjectless `case` candidate | `boolean` | `case_when` |
+| Standalone `value in pattern` | `boolean` | `pattern_in` |
+| Evaluated pattern guard predicate | `boolean` | `pattern_guard` |
+| Standalone `&&`, `||`, `and`, `or` | `boolean` | `short_circuit` |
+
+Prism determines precedence. `!` and `not` appear as NOT nodes in the Boolean
+tree; their operands remain the conditions. Short-circuited operands remain
+not evaluated. A Boolean subtree already decomposed in a decision is not
+inventoried again as a standalone decision.
+
+Loop outcomes describe the predicate as written: an `until` predicate that
+returns true ends the loop. Every predicate evaluation receives an execution
+ID. Repeated equivalent executions aggregate into a vector's `count`, retaining
+the supporting tests. Ternary outcomes likewise describe the predicate, not
+the value returned by the chosen branch.
+
+Other constructs use alternative coverage, separate from MC/DC:
+
+| Construct | Kind | Context | Required alternatives |
+| --- | --- | --- | --- |
+| `case subject` | `multiway` | `case` | Each `when` candidate and `else` (or implicit no-match path) |
+| `case/in` | `pattern` | `case_in` | Each pattern clause and explicit `else`, if present |
+| `receiver&.method` | `implicit` | `safe_navigation` | Receiver nil / non-nil |
+| `lhs ||= rhs` | `implicit` | `or_assignment` | RHS skipped / executed |
+| `lhs &&= rhs` | `implicit` | `and_assignment` | RHS skipped / executed |
+
+Each safe-navigation operation in a chain is a distinct decision. Assignment
+instrumentation preserves Ruby's native local, instance, class, global,
+constant, method, and indexed assignment operations, including receiver and
+index evaluation order. Safe navigation distinguishes nil from false.
+
+For multiway decisions, vector values mean selected (`true`), evaluated but
+not selected (`false`), and skipped (`null`). Later alternatives remain skipped
+when an earlier candidate matches. Implicit vectors record the selected path
+and its unselected complement. Their `outcome` is a selection marker, not the
+truthiness of the application's return value. Reports label these as paths,
+not Boolean outcomes. Each alternative exposes selected, not-selected, and
+skipped evidence with test and vector IDs. The alternative denominator is the
+number of supported selectable alternatives; these decisions do not enter
+Boolean-ladder or MC/DC denominators.
+
+A `case/in` without `else` retains Ruby's native no-match exception. An execution
+that fails before choosing a branch is aborted, not counted as a selected
+alternative. Selected branches and assignment paths remain observed even when
+their bodies or right-hand sides subsequently raise or return.
+
+Unsupported syntax stays visible and outside coverage denominators. Current
+exclusions include guarded `case/in` (`unsupported_pattern_guard`), dynamic
+`when` splats (`unsupported_case_splat`), safe-navigation compound assignment
+(`unsupported_assignment_target`), and rescue alternatives
+(`unsupported_rescue_control_flow`). A guard predicate can still supply Boolean
+evidence when Ruby evaluates it; an unsupported guarded case does not claim
+pattern-match coverage from that evidence. Flip-flops remain
+`unsupported_flip_flop`. Decisions inside `defined?`, contextual regular
+expressions, heredocs, unsafe predicates, and limit overflows retain explicit
+exclusions. Ruby-defined custom `!` methods keep their runtime behavior;
+evidence that contradicts Boolean negation is rejected instead of proving
+coverage with an invalid logical model.
+
+New reports use schema `1.3`; saved schema `1.0`, `1.1`, and `1.2` reports
+remain readable. Comparison distinguishes decision-table coverage movement
+(`rule coverage gained`, `rule coverage lost`) from analysis movement
+(`rule reachability changed`), and treats a structurally changed decision as a
+changed decision-table context instead of guessing which old rule a new rule
+corresponds to. Expanded discovery changes coverage denominators, so compare reports
+with their supported syntax scope in mind.
 
 ### Limits
 
 `--limits` accepts a JSON object containing positive integer overrides. The
 available keys are `conditions_per_decision`, `vectors_per_decision`,
 `owner_associations_per_run`, `tests_per_run`, `exact_candidates`,
-`exact_search_nodes`, and `constraint_search_states`.
+`exact_search_nodes`, `constraint_search_states`,
+`max_conditions_for_decision_table`, and `decision_table_rules_per_decision`.
 
 ```json
 {

data/doc/Branchproof/Analyzer.md

@@ -16,11 +16,11 @@ Not documented.
 ### `call()` <a id="method-i-call"></a> <a id="call-instance_method"></a>
 Not documented.
 
-### `initialize(inventory:, evidence:, limits:)` <a id="method-i-initialize"></a> <a id="initialize-instance_method"></a>
+### `initialize(inventory:, evidence:, limits:, reachability: = true)` <a id="method-i-initialize"></a> <a id="initialize-instance_method"></a>
 - **@return** [Analyzer] a new instance of Analyzer
 
 ### `missing(decision_id:, condition_index:)` <a id="method-i-missing"></a> <a id="missing-instance_method"></a>
 Not documented.
 
-### `pair?(decision_id:, condition_index:, left:, right:)` <a id="method-i-pair-3F"></a> <a id="pair?-instance_method"></a>
+### `pair?(decision_id:, condition_index:, left:, right:, masks: = nil)` <a id="method-i-pair-3F"></a> <a id="pair?-instance_method"></a>
 - **@return** [Boolean]

data/doc/Branchproof/CLI.md

@@ -7,6 +7,10 @@
 
 Coordinates source inventory, isolated test execution, and report output.
 
+## Constants
+### `VIEWS` <a id="constant-VIEWS"></a> <a id="VIEWS-constant"></a>
+Not documented.
+
 ## Public Instance Methods
 ### `call(argv)` <a id="method-i-call"></a> <a id="call-instance_method"></a>
 Not documented.

data/doc/Branchproof/ComparisonReport.md

@@ -7,6 +7,10 @@
 
 Renders the offline document returned by Comparison.
 
+## Constants
+### `RULE_LABELS` <a id="constant-RULE_LABELS"></a> <a id="RULE_LABELS-constant"></a>
+Not documented.
+
 ## Public Instance Methods
 ### `exit_code(fail_on_regression: = false)` <a id="method-i-exit_code"></a> <a id="exit_code-instance_method"></a>
 Not documented.

data/doc/Branchproof/Constraints/Solver.md

@@ -0,0 +1,21 @@
+# Class Branchproof::Constraints::Solver <a id="class-Branchproof-Constraints-Solver"></a>
+
+|  |  |
+| --- | --- |
+| **Inherits** | Object |
+| **Defined in** | lib/branchproof/constraints.rb |
+
+Accumulates the constraints one decision-table rule requires and reports the
+first proven contradiction. Subjects never interact with each other.
+
+## Public Instance Methods
+### `add(constraint, truth)` <a id="method-i-add"></a> <a id="add-instance_method"></a>
+Returns a reason code when the rule became unsatisfiable, otherwise nil.
+
+### `add_prepared(constraint, truth)` <a id="method-i-add_prepared"></a> <a id="add_prepared-instance_method"></a>
+Adds a constraint that has already been symbolized and validated by
+<code>usable?</code>. Source inventory can use this path after preparing each
+leaf once instead of repeating normalization for every solver state.
+
+### `initialize()` <a id="method-i-initialize"></a> <a id="initialize-instance_method"></a>
+- **@return** [Solver] a new instance of Solver

data/doc/Branchproof/Constraints.md

@@ -0,0 +1,98 @@
+# Module Branchproof::Constraints <a id="module-Branchproof-Constraints"></a>
+
+|  |  |
+| --- | --- |
+| **Defined in** | lib/branchproof/constraints.rb |
+
+Normalizes simple atomic conditions into subject/operator/value records and
+decides, conservatively, whether a set of required condition truths can hold
+at the same time.
+
+The module never evaluates application code. It only inspects the syntax of a
+condition, and it answers "contradictory" only when the contradiction follows
+from the normalized constraints alone. Every other shape stays unrepresented,
+which leaves the owning decision-table rule reachability `unknown`.
+
+## Constants
+### `COMPARISON_OPERATORS` <a id="constant-COMPARISON_OPERATORS"></a> <a id="COMPARISON_OPERATORS-constant"></a>
+Not documented.
+
+### `FALSEY_TYPES` <a id="constant-FALSEY_TYPES"></a> <a id="FALSEY_TYPES-constant"></a>
+Not documented.
+
+### `FLIPPED` <a id="constant-FLIPPED"></a> <a id="FLIPPED-constant"></a>
+Not documented.
+
+### `LITERAL_TYPES` <a id="constant-LITERAL_TYPES"></a> <a id="LITERAL_TYPES-constant"></a>
+Not documented.
+
+### `NUMERIC_OPERATORS` <a id="constant-NUMERIC_OPERATORS"></a> <a id="NUMERIC_OPERATORS-constant"></a>
+Not documented.
+
+### `NUMERIC_TYPES` <a id="constant-NUMERIC_TYPES"></a> <a id="NUMERIC_TYPES-constant"></a>
+Not documented.
+
+### `OPERATORS` <a id="constant-OPERATORS"></a> <a id="OPERATORS-constant"></a>
+Not documented.
+
+### `REASONS` <a id="constant-REASONS"></a> <a id="REASONS-constant"></a>
+Not documented.
+
+### `REASON_MESSAGES` <a id="constant-REASON_MESSAGES"></a> <a id="REASON_MESSAGES-constant"></a>
+Not documented.
+
+### `SUBJECT_KINDS` <a id="constant-SUBJECT_KINDS"></a> <a id="SUBJECT_KINDS-constant"></a>
+Not documented.
+
+### `VERSION` <a id="constant-VERSION"></a> <a id="VERSION-constant"></a>
+Not documented.
+
+## Public Class Methods
+### `comparison_constraint(node, name)` <a id="method-c-comparison_constraint"></a> <a id="comparison_constraint-class_method"></a>
+Not documented.
+
+### `for_node(node)` <a id="method-c-for_node"></a> <a id="for_node-class_method"></a>
+Derives the normalized constraint of one atomic condition, or nil when the
+expression is outside the supported vocabulary.
+
+### `literal_for(node)` <a id="method-c-literal_for"></a> <a id="literal_for-class_method"></a>
+String equality stays unsupported in v1 so that encoding and mutability
+questions cannot turn into an impossibility claim.
+
+### `message(reason)` <a id="method-c-message"></a> <a id="message-class_method"></a>
+Not documented.
+
+### `mixed_numeric_literals?(left, right)` <a id="method-c-mixed_numeric_literals-3F"></a> <a id="mixed_numeric_literals?-class_method"></a>
+- **@return** [Boolean]
+
+### `nil_constraint(node)` <a id="method-c-nil_constraint"></a> <a id="nil_constraint-class_method"></a>
+Not documented.
+
+### `numeric?(literal)` <a id="method-c-numeric-3F"></a> <a id="numeric?-class_method"></a>
+- **@return** [Boolean]
+
+### `same_literal?(left, right)` <a id="method-c-same_literal-3F"></a> <a id="same_literal?-class_method"></a>
+- **@return** [Boolean]
+
+### `simple_call?(node)` <a id="method-c-simple_call-3F"></a> <a id="simple_call?-class_method"></a>
+- **@return** [Boolean]
+
+### `single_argument(node)` <a id="method-c-single_argument"></a> <a id="single_argument-class_method"></a>
+Not documented.
+
+### `subject_for(node)` <a id="method-c-subject_for"></a> <a id="subject_for-class_method"></a>
+Only unambiguously identifiable storage locations become subjects. Method-call
+receivers stay unsupported: a repeated call may return a different value or
+have side effects (see the v1 constraint scope).
+
+### `subject_key(subject)` <a id="method-c-subject_key"></a> <a id="subject_key-class_method"></a>
+Not documented.
+
+### `symbolize(value)` <a id="method-c-symbolize"></a> <a id="symbolize-class_method"></a>
+Not documented.
+
+### `usable?(constraint)` <a id="method-c-usable-3F"></a> <a id="usable?-class_method"></a>
+- **@return** [Boolean]
+
+### `valid_literal_value?(literal)` <a id="method-c-valid_literal_value-3F"></a> <a id="valid_literal_value?-class_method"></a>
+- **@return** [Boolean]

data/doc/Branchproof/CoverageIndex.md

@@ -8,6 +8,9 @@
 Derives condition- and test-oriented rows from one report document.
 
 ## Attributes
+### `alternatives` [R] <a id="attribute-i-alternatives"></a> <a id="alternatives-instance_method"></a>
+Returns the value of attribute alternatives.
+
 ### `conditions` [R] <a id="attribute-i-conditions"></a> <a id="conditions-instance_method"></a>
 Returns the value of attribute conditions.
 
@@ -15,5 +18,8 @@ Returns the value of attribute conditions.
 Returns the value of attribute tests.
 
 ## Public Instance Methods
+### `decision_tables()` <a id="method-i-decision_tables"></a> <a id="decision_tables-instance_method"></a>
+Not documented.
+
 ### `initialize(document:)` <a id="method-i-initialize"></a> <a id="initialize-instance_method"></a>
 - **@return** [CoverageIndex] a new instance of CoverageIndex

data/doc/Branchproof/DecisionSyntax.md

@@ -0,0 +1,22 @@
+# Module Branchproof::DecisionSyntax <a id="module-Branchproof-DecisionSyntax"></a>
+
+|  |  |
+| --- | --- |
+| **Defined in** | lib/branchproof/decision_syntax.rb |
+
+Discovers control-flow expressions whose truth is not represented by an
+ordinary Prism IfNode.  The records intentionally contain byte ranges and
+scalar metadata only; Prism nodes must not escape the source pass.
+
+## Constants
+### `AND_WRITE_NODE_CLASSES` <a id="constant-AND_WRITE_NODE_CLASSES"></a> <a id="AND_WRITE_NODE_CLASSES-constant"></a>
+Not documented.
+
+### `OR_WRITE_NODE_CLASSES` <a id="constant-OR_WRITE_NODE_CLASSES"></a> <a id="OR_WRITE_NODE_CLASSES-constant"></a>
+Not documented.
+
+## Public Instance Methods
+### `flow_decisions_for(program, bytes, source_id, file_reasons = [], encoding = "UTF-8", nodes: = nil)` <a id="method-i-flow_decisions_for"></a> <a id="flow_decisions_for-instance_method"></a>
+nodes: flow-decision nodes already collected by a caller's own AST walk
+(Source merges this discovery into one pass). Falls back to its own walk when
+nothing is passed in, so this method still works standalone.