branchproof 0.5.0 → 0.7.0

data/doc/README.md

@@ -1,10 +1,10 @@
 # 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, and modified condition/decision
+coverage (MC/DC) 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.
@@ -126,6 +126,50 @@ Additional tests outside this MC/DC evidence set may improve coverage.
 The test execution still runs once for the selected level. Use `--format
 json` when a consumer needs the complete identifiers and versioned schema.
 
+### Coverage ladder
+
+Each successful `analyze` run calculates four criteria from the same completed
+observations. The report shows their status for each supported decision and
+aggregate counts with explicit denominators:
+
+| Criterion | Requirement | Aggregate denominator |
+| --- | --- | --- |
+| Decision | The decision produced both true and false | Supported decisions |
+| 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 |
+
+For `logged_in? && admin?`, observations `[F-] => F` and `[TT] => T` give:
+
+```text
+Decision                    PASS
+Condition                   FAIL (3/4 values observed)
+Condition/Decision          FAIL
+MC/DC                       FAIL (1/2 conditions proven)
+```
+
+The skipped `admin?` in `[F-]` counts as neither true nor false. Conditions
+that did evaluate count toward Condition Coverage even when their value was
+masked by another condition. Here, the two observations prove independence
+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.
+Unsupported decisions are excluded from every denominator, while
+unexecuted supported decisions remain in scope. Empty denominators are N/A.
+
+Reports retain the observations and owning tests for each decision outcome
+and condition value. Missing values describe required runtime observations,
+not application inputs or a guarantee that the path is reachable. Unattributed
+observations can provide truth-value evidence without identifying a test;
+the report's completeness and diagnostics still apply.
+
+JSON stores aggregate counts under `analysis.coverage`, per-decision results
+under `analysis.decisions[].coverage`, and condition value evidence under
+`analysis.decisions[].condition_results[].coverage`. Existing MC/DC witness
+pairs, counterpart constraints, and raw vectors remain available. Statuses
+distinguish `covered`, `partial`, `unexecuted`, and `unsupported` results.
+
 ### Find missing cases
 
 Use `--missing-only` to focus the terminal report on conditions that still
@@ -175,15 +219,17 @@ test inputs; they do not by themselves prove a bug in the application.
 
 The levels select how much of the one-run result is displayed:
 
-* Level 1 reports observed vectors grouped by their raw decision outcomes.
+* Level 1 reports the coverage ladder and observed vectors grouped by their
+  raw decision outcomes.
 * Level 2 includes the smallest supporting sets found for vectors and tests.
 * Level 3 (the default) includes condition independence witnesses and
   counterpart constraints, as well as the Level 1 and 2 evidence.
 
-Level 2 and Level 3 compute from the same captured run. They do not rerun the
-test suite. 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.
+All levels calculate the same criteria from one captured run. The level
+controls displayed evidence, not the coverage criterion; JSON retains the
+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
 
@@ -232,7 +278,8 @@ artifacts when you need to retain multiple runs.
 The `report` command reads the saved document without loading the application
 or running tests. It uses locations and metadata captured in the report, so
 rendering remains useful after the original checkout has moved or been
-removed. Level 1 reports observations; levels 2 and 3 require corresponding
+removed. New snapshots retain the ladder at every level. Legacy snapshots
+without analysis can still be rendered at Level 1; levels 2 and 3 require
 analysis in the saved report. The repository ignores `.branchproof/`; choose a
 different path and CI artifact policy when a project needs to retain reports.
 Saved JSON includes existing raw metadata such as test names and expressions;
@@ -274,26 +321,77 @@ 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
-
-Ordinary Ruby ternaries use the same predicate instrumentation and `&&`/`||`
-condition trees as supported `if` decisions. For example:
-
-```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.
+### Supported decision forms
+
+Every decision has a stable `kind` and `context` in JSON. The Boolean ladder
+applies to the following forms:
+
+| 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.2`; saved schema `1.0` and `1.1` reports remain
+readable. Expanded discovery changes coverage denominators, so compare reports
+with their supported syntax scope in mind.
 
 ### Limits
 

data/lib/branchproof/analyzer.rb

@@ -30,11 +30,13 @@ module Branchproof
         proven_count: proven,
         eligible_count: eligible,
         completeness: completeness(decisions),
-        diagnostics: decisions.flat_map { |decision| decision[:diagnostics] } + @invalid_diagnostics
+        diagnostics: decisions.flat_map { |decision| decision[:diagnostics] } + @invalid_diagnostics,
+        coverage: aggregate_coverage(decisions)
       }.freeze
     end
 
     def pair?(decision_id:, condition_index:, left:, right:)
+      return false if alternative_decision_for_id?(decision_id)
       return false unless compatible_vectors?(left, right, decision_id)
       return false unless observed?(left, condition_index) && observed?(right, condition_index)
       return false if value(left, condition_index) == value(right, condition_index)
@@ -51,6 +53,8 @@ module Branchproof
       decision = records(@inventory, :decisions).find { id(_1, :id) == decision_id }
       return @missing_cache[cache_key] = nil unless decision
 
+      return @missing_cache[cache_key] = nil if alternative_decision?(decision)
+
       support_status = id(decision, :support_status).to_s
       return @missing_cache[cache_key] = nil unless support_status.empty? || support_status.upcase == "SUPPORTED"
 
@@ -93,11 +97,13 @@ module Branchproof
     private
 
     def analyze_decision(decision)
+      return analyze_alternative_decision(decision) if alternative_decision?(decision)
+
       decision_id = id(decision, :id)
       unless id(decision, :support_status).to_s.empty? || id(decision, :support_status).to_s.upcase == "SUPPORTED"
         return {
           decision_id: decision_id, effective_masks_by_vector: {}, condition_results: [], witness_buckets: {},
-          conditions: [], unsupported: true,
+          conditions: [], unsupported: true, coverage: unsupported_coverage,
           completeness: { observation: true, attribution: true, analysis: true },
           diagnostics: [diagnostic("unsupported_decision", "warning", decision_id, nil)]
         }
@@ -136,9 +142,13 @@ module Branchproof
                     nil
                   else
                     (true_ids.empty? || false_ids.empty? ? "missing_effective_sign" : "no_independent_pair")
-                  end
+                  end,
+          coverage: condition_coverage(index, vectors)
         }
       end
+      decision_coverage = decision_coverage(vectors)
+      condition_coverage_summary = condition_summary(results)
+      mcdc = mcdc_coverage(results)
       {
         decision_id: decision_id,
         effective_masks_by_vector: masks,
@@ -146,11 +156,211 @@ module Branchproof
         witness_buckets: buckets,
         edge_table: edge_table(decision[:tree]),
         conditions: conditions(decision),
+        coverage: { decision: decision_coverage, condition: condition_coverage_summary,
+                    condition_decision: conjunction_coverage(decision_coverage, condition_coverage_summary),
+                    mcdc: mcdc },
         completeness: { observation: true, attribution: true, analysis: !@analysis_invalid },
         diagnostics: []
       }
     end
 
+    def analyze_alternative_decision(decision)
+      decision_id = id(decision, :id)
+      unless id(decision, :support_status).to_s.empty? || id(decision, :support_status).to_s.upcase == "SUPPORTED"
+        return {
+          decision_id: decision_id, kind: id(decision, :kind), effective_masks_by_vector: {},
+          condition_results: [], witness_buckets: {},
+          conditions: [], alternatives: alternatives(decision), unsupported: true,
+          coverage: unsupported_alternative_coverage,
+          completeness: { observation: true, attribution: true, analysis: true },
+          diagnostics: [diagnostic("unsupported_decision", "warning", decision_id, nil)]
+        }
+      end
+
+      vectors = @vectors.filter_map { |vector| valid_vector(vector, decision) }
+      rows = alternatives(decision).map do |alternative|
+        index = id(alternative, :index).to_i
+        selected = vectors.select { |vector| value(vector, index) == true }
+        not_selected = vectors.select { |vector| value(vector, index) == false }
+        skipped = vectors.select { |vector| value(vector, index).nil? }
+        {
+          alternative_id: id(alternative, :id), index: id(alternative, :index),
+          expression: id(alternative, :expression),
+          selected: alternative_evidence_bucket(selected),
+          not_selected: alternative_evidence_bucket(not_selected),
+          skipped: alternative_evidence_bucket(skipped)
+        }
+      end
+      missing = rows.filter_map { |row| row[:alternative_id] unless row[:selected][:observed] }
+      covered = rows.count { |row| row[:selected][:observed] }
+      {
+        decision_id: decision_id, kind: id(decision, :kind), effective_masks_by_vector: {},
+        condition_results: [], witness_buckets: {},
+        conditions: [], alternatives: alternatives(decision), unsupported: false,
+        coverage: { alternative: { status: coverage_status(covered, rows.length), covered_alternatives: covered,
+                                   required_alternatives: rows.length, alternatives: rows,
+                                   missing_alternatives: missing },
+                    mcdc: { status: "not_applicable" } },
+        completeness: { observation: true, attribution: true, analysis: !@analysis_invalid }, diagnostics: []
+      }
+    end
+
+    def unsupported_alternative_coverage
+      { alternative: { status: "unsupported", covered_alternatives: 0, required_alternatives: 0,
+                       alternatives: [], missing_alternatives: [] }, mcdc: { status: "unsupported" } }
+    end
+
+    def alternative_evidence_bucket(vectors)
+      evidence = vectors.map { |vector| provenance(vector) }
+      { observed: !vectors.empty?, vector_ids: evidence.map { |item| item[:vector_id] }.uniq.sort,
+        test_ids: evidence.flat_map { |item| item[:test_ids] }.uniq.sort,
+        unattributed_count: evidence.sum { |item| item[:unattributed_count] } }
+    end
+
+    def alternative_decision?(decision)
+      kind = id(decision, :kind).to_s
+      !kind.empty? && kind != "boolean"
+    end
+
+    def alternative_decision_for_id?(decision_id)
+      decision = records(@inventory, :decisions).find { |item| id(item, :id) == decision_id }
+      decision && alternative_decision?(decision)
+    end
+
+    def alternatives(decision)
+      records(decision, :alternatives)
+    end
+
+    def unsupported_coverage
+      { decision: { status: "unsupported", true_observed: false, false_observed: false,
+                    covered_outcomes: 0, required_outcomes: 2, outcomes: [], missing_outcomes: [] },
+        condition: { status: "unsupported", covered_values: 0, required_values: 0,
+                     covered_conditions: 0, condition_count: 0 },
+        condition_decision: { status: "unsupported" },
+        mcdc: { status: "unsupported", proven_conditions: 0, condition_count: 0 } }
+    end
+
+    def provenance(vector)
+      { vector_id: id(vector, :id).to_s,
+        test_ids: Array(id(vector, :test_ids)).map(&:to_s).uniq.sort,
+        unattributed_count: id(vector, :unattributed_count).to_i }
+    end
+
+    def evidence_bucket(value, vectors)
+      matching = vectors.select do |vector|
+        observed?(vector, value[:index]) && self.value(vector, value[:index]) == value[:value]
+      end
+      evidence = matching.map { |vector| provenance(vector) }
+      { value: value[:value], observed: !matching.empty?,
+        vector_ids: evidence.flat_map { |item| item[:vector_id] }.uniq.sort,
+        test_ids: evidence.flat_map { |item| item[:test_ids] }.uniq.sort,
+        unattributed_count: evidence.sum { |item| item[:unattributed_count] } }
+    end
+
+    def condition_coverage(index, vectors)
+      observed_vectors = vectors.select { |vector| observed?(vector, index) }
+      values = [true, false].map do |item|
+        evidence_bucket({ index: index, value: item }, observed_vectors)
+      end
+      covered = values.count { |entry| entry[:observed] }
+      { status: coverage_status(covered, 2), true_observed: values[0][:observed],
+        false_observed: values[1][:observed], covered_values: covered, required_values: 2,
+        values: values, missing_values: values.reject { |entry| entry[:observed] }.map { |entry| entry[:value] } }
+    end
+
+    def decision_coverage(vectors)
+      outcomes = [false, true].map do |value|
+        matching = vectors.select { |vector| outcome(vector) == value }
+        evidence = matching.map { |vector| provenance(vector) }
+        { value: value, observed: !matching.empty?,
+          vector_ids: evidence.flat_map { |item| item[:vector_id] }.uniq.sort,
+          test_ids: evidence.flat_map { |item| item[:test_ids] }.uniq.sort,
+          unattributed_count: evidence.sum { |item| item[:unattributed_count] } }
+      end
+      covered = outcomes.count { |entry| entry[:observed] }
+      { status: coverage_status(covered, 2), true_observed: outcomes[1][:observed],
+        false_observed: outcomes[0][:observed], covered_outcomes: covered, required_outcomes: 2,
+        outcomes: outcomes,
+        missing_outcomes: outcomes.reject { |entry| entry[:observed] }.map { |entry| entry[:value] } }
+    end
+
+    def condition_summary(results)
+      values = results.sum { |result| result[:coverage][:covered_values] }
+      count = results.length
+      { status: coverage_status(values, count * 2), covered_values: values,
+        required_values: count * 2,
+        covered_conditions: results.count { |result| result[:coverage][:status] == "covered" },
+        condition_count: count }
+    end
+
+    def mcdc_coverage(results)
+      proven = results.count { |result| result[:status] == "PROVEN" }
+      observed = results.any? { |result| result[:coverage][:covered_values].positive? }
+      status = if !observed
+                 "unexecuted"
+               elsif proven == results.length
+                 "covered"
+               else
+                 "partial"
+               end
+      { status: status, proven_conditions: proven, condition_count: results.length }
+    end
+
+    def conjunction_coverage(decision, condition)
+      status = if decision[:status] == "covered" && condition[:status] == "covered"
+                 "covered"
+               elsif decision[:status] == "unexecuted" && condition[:status] == "unexecuted"
+                 "unexecuted"
+               else
+                 "partial"
+               end
+      { status: status }
+    end
+
+    def coverage_status(covered, required)
+      return "unexecuted" if covered.zero?
+      return "covered" if covered == required
+
+      "partial"
+    end
+
+    def aggregate_coverage(decisions)
+      supported = decisions.reject { |decision| decision[:unsupported] }
+      boolean_supported = supported.reject { |decision| alternative_decision?(decision) }
+      decision_covered = boolean_supported.count do |decision|
+        decision[:coverage][:decision][:status] == "covered"
+      end
+      condition_decision_covered = boolean_supported.count do |decision|
+        decision[:coverage][:condition_decision][:status] == "covered"
+      end
+      condition_count = boolean_supported.sum { |decision| decision[:coverage][:condition][:condition_count] }
+      condition_values = boolean_supported.sum { |decision| decision[:coverage][:condition][:covered_values] }
+      covered_conditions = boolean_supported.sum do |decision|
+        decision[:coverage][:condition][:covered_conditions]
+      end
+      proven = boolean_supported.sum { |decision| decision[:coverage][:mcdc][:proven_conditions] }
+      percentage = ->(covered, required) { required.zero? ? nil : (covered.to_f / required * 100).round(2) }
+      { decision: { covered_decisions: decision_covered, supported_decisions: boolean_supported.length,
+                    percentage: percentage.call(decision_covered, boolean_supported.length) },
+        condition: { covered_values: condition_values, required_values: condition_count * 2,
+                     covered_conditions: covered_conditions, condition_count: condition_count,
+                     percentage: percentage.call(condition_values, condition_count * 2) },
+        condition_decision: { covered_decisions: condition_decision_covered,
+                              supported_decisions: boolean_supported.length,
+                              percentage: percentage.call(condition_decision_covered, boolean_supported.length) },
+        mcdc: { proven_conditions: proven, supported_conditions: condition_count,
+                percentage: percentage.call(proven, condition_count) },
+        alternative: alternative_aggregate(decisions) }
+    end
+
+    def alternative_aggregate(decisions)
+      flow = decisions.select { |decision| !decision[:unsupported] && alternative_decision?(decision) }
+      required = flow.sum { |decision| decision.dig(:coverage, :alternative, :required_alternatives).to_i }
+      covered = flow.sum { |decision| decision.dig(:coverage, :alternative, :covered_alternatives).to_i }
+      { covered_alternatives: covered, required_alternatives: required,
+        supported_decisions: flow.length, percentage: required.zero? ? nil : (covered.to_f / required * 100).round(2) }
+    end
+
     def valid_vector(vector, decision)
       return nil unless id(vector, :decision_id) == id(decision, :id)
 
@@ -180,7 +390,11 @@ module Branchproof
         return nil
       end
 
-      effective_mask(vector, id(decision, :id), decision[:tree])
+      if alternative_decision?(decision)
+        handle_alternative_vector(vector, decision)
+      else
+        effective_mask(vector, id(decision, :id), decision[:tree])
+      end
       decision_source.nil? ? vector : vector.merge(source_id: decision_source)
     rescue ArgumentError
       @analysis_invalid = true
@@ -188,6 +402,36 @@ module Branchproof
       nil
     end
 
+    # rubocop:disable-next Naming/PredicateMethod -- raises on malformed flow vectors
+    def handle_alternative_vector(vector, decision)
+      values = values_for(vector)
+      expected = alternatives(decision).length
+      raise ArgumentError, "invalid alternative vector shape" unless values.length == expected
+
+      observations = values.each_with_index.filter_map { |item, index| [index, item] unless item.nil? }
+      raise ArgumentError, "invalid alternative trace" unless valid_alternative_trace?(decision, observations,
+                                                                                       outcome(vector))
+
+      true
+    end
+
+    def valid_alternative_trace?(decision, observations, result)
+      return false unless result == true
+
+      expected = alternatives(decision).length
+      return false unless expected.positive?
+      if id(decision, :kind).to_s == "implicit"
+        return expected == 2 && observations.length == 2 &&
+               observations.map(&:first) == [0, 1] && observations.map(&:last).count(true) == 1
+      end
+
+      return false unless observations.length.between?(1, expected)
+
+      observations.each_with_index.all? do |(index, value), position|
+        index == position && value == (position == observations.length - 1)
+      end
+    end
+
     def effective_mask(vector, decision_id, tree = nil)
       decision = records(@inventory, :decisions).find { id(_1, :id) == decision_id } unless tree
       tree ||= decision && decision[:tree]
@@ -213,6 +457,10 @@ module Branchproof
 
         return [value, 1 << index, offset + 1]
       end
+      if type == :not
+        child_result, child_mask, consumed = replay(node.fetch(:child), values, offset)
+        return [!child_result, child_mask, consumed]
+      end
       left_result, left_mask, consumed = replay(node.fetch(:left), values, offset)
       return [left_result, left_mask, consumed] if (type == :and && !left_result) || (type == :or && left_result)
 
@@ -312,6 +560,8 @@ module Branchproof
         return { entry: entry, true_exits: [edges[0]], false_exits: [edges[1]], all_bits: 1 << index, edges: edges }
       end
       type = id(node, :type).to_sym
+      return build_graph(node.fetch(:child), false_destination, true_destination) if type == :not
+
       right = build_graph(node[:right], true_destination, false_destination)
       if type == :and
         left = build_graph(node[:left], right[:entry], false_destination)
@@ -327,7 +577,9 @@ module Branchproof
     end
 
     def impose_path(node, target, target_value, constraints)
-      return true if id(node, :type).to_sym == :atom && id(node, :index) == target
+      type = id(node, :type).to_sym
+      return true if type == :atom && id(node, :index) == target
+      return impose_path(node.fetch(:child), target, target_value, constraints) if type == :not
 
       left = node[:left]
       right = node[:right]
@@ -352,6 +604,8 @@ module Branchproof
 
         constraints << { condition_index: id(node, :index), value: desired }
         true
+      elsif id(node, :type).to_sym == :not
+        impose_subtree(node.fetch(:child), !desired, constraints)
       elsif desired == (id(node, :type).to_sym == :and)
         impose_subtree(node[:left], desired, constraints) && impose_subtree(node[:right], desired, constraints)
       else
@@ -360,7 +614,9 @@ module Branchproof
     end
 
     def evaluate(node, values)
-      return values[id(node, :index)] if id(node, :type).to_sym == :atom
+      type = id(node, :type).to_sym
+      return values[id(node, :index)] if type == :atom
+      return !evaluate(node.fetch(:child), values) if type == :not
 
       left = evaluate(node[:left], values)
       return left if id(node, :type).to_sym == :and && !left
@@ -370,11 +626,16 @@ module Branchproof
     end
 
     def evaluate_with_trace(node, values, trace = [])
-      if id(node, :type).to_sym == :atom
+      type = id(node, :type).to_sym
+      if type == :atom
         value = !values[id(node, :index)].nil? && values[id(node, :index)] != false
         trace << [id(node, :index), value]
         return [value, trace]
       end
+      if type == :not
+        child, = evaluate_with_trace(node.fetch(:child), values, trace)
+        return [!child, trace]
+      end
       left, = evaluate_with_trace(node[:left], values, trace)
       return [left, trace] if id(node, :type).to_sym == :and && !left
       return [left, trace] if id(node, :type).to_sym == :or && left
@@ -383,13 +644,12 @@ module Branchproof
     end
 
     def contains?(node, target)
-      if id(node,
-            :type).to_sym == :atom
-        id(node,
-           :index) == target
+      if id(node, :type).to_sym == :atom
+        id(node, :index) == target
+      elsif id(node, :type).to_sym == :not
+        contains?(node.fetch(:child), target)
       else
-        contains?(node[:left],
-                  target) || contains?(node[:right], target)
+        contains?(node[:left], target) || contains?(node[:right], target)
       end
     end
 

data/lib/branchproof/cli.rb

@@ -49,7 +49,7 @@ module Branchproof
                                             message: merge_status[:reason].to_s }]
         end
       end
-      if options[:level] >= 2 && value(baseline, :status).to_s == "PASSED"
+      if value(baseline, :status).to_s == "PASSED"
         analysis = Analyzer.new(inventory: inventory, evidence: evidence.snapshot, limits: options[:limits]).call
         baseline[:analysis] = analysis
         if options[:level] >= 2
@@ -70,7 +70,7 @@ module Branchproof
       diagnostics = Array(value(inventory, :diagnostics)) + Array(value(baseline, :diagnostics)) +
                     Array(value(evidence.snapshot,
                                 :diagnostics)) + Array(value(value(baseline, :analysis), :diagnostics))
-      analysis = options[:level] == 1 ? nil : value(baseline, :analysis)
+      analysis = value(baseline, :analysis)
       minima = options[:level] == 1 ? [] : Array(value(baseline, :minima))
       report = Report.new(inventory: inventory, evidence: value(baseline, :evidence) || evidence.snapshot,
                           analysis: analysis, minima: minima, baseline: baseline, diagnostics: diagnostics,

data/lib/branchproof/comparison.rb

@@ -7,7 +7,7 @@ module Branchproof
   # Compares two complete report documents without loading or executing the project.
   class Comparison
     SCHEMA_VERSION = "1.0"
-    SUPPORTED_REPORT_SCHEMAS = %w[1.0 1.1].freeze
+    SUPPORTED_REPORT_SCHEMAS = %w[1.0 1.1 1.2].freeze
     CRITERION_VERSION = "masking_occurrence_v1"
 
     def initialize(before:, after:)