branchproof 0.6.0 → 0.7.0

data/lib/branchproof/analyzer.rb

@@ -36,6 +36,7 @@ module Branchproof
     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)
@@ -52,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"
 
@@ -94,6 +97,8 @@ 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 {
@@ -159,6 +164,73 @@ module Branchproof
       }
     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: [] },
@@ -254,29 +326,39 @@ module Branchproof
 
     def aggregate_coverage(decisions)
       supported = decisions.reject { |decision| decision[:unsupported] }
-      decision_covered = supported.count do |decision|
+      boolean_supported = supported.reject { |decision| alternative_decision?(decision) }
+      decision_covered = boolean_supported.count do |decision|
         decision[:coverage][:decision][:status] == "covered"
       end
-      condition_decision_covered = supported.count do |decision|
+      condition_decision_covered = boolean_supported.count do |decision|
         decision[:coverage][:condition_decision][:status] == "covered"
       end
-      condition_count = supported.sum { |decision| decision[:coverage][:condition][:condition_count] }
-      condition_values = supported.sum { |decision| decision[:coverage][:condition][:covered_values] }
-      covered_conditions = supported.sum do |decision|
+      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 = supported.sum { |decision| decision[:coverage][:mcdc][:proven_conditions] }
+      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: supported.length,
-                    percentage: percentage.call(decision_covered, supported.length) },
+      { 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: supported.length,
-                              percentage: percentage.call(condition_decision_covered, supported.length) },
+                              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) } }
+                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)
@@ -308,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
@@ -316,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]
@@ -341,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)
 
@@ -440,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)
@@ -455,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]
@@ -480,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
@@ -488,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
@@ -498,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
@@ -511,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/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:)

data/lib/branchproof/coverage_index.rb

@@ -7,7 +7,7 @@ require "pathname"
 module Branchproof
   # Derives condition- and test-oriented rows from one report document.
   class CoverageIndex
-    attr_reader :conditions, :tests
+    attr_reader :conditions, :alternatives, :tests
 
     def initialize(document:)
       @document = symbolize(document || {})
@@ -27,6 +27,7 @@ module Branchproof
         @tests_by_id[id] = (@tests_by_id[id] || {}).merge(test) unless id.empty?
       end
       @conditions = build_conditions.freeze
+      @alternatives = build_alternatives.freeze
       @tests = build_tests.freeze
     end
 
@@ -62,7 +63,7 @@ module Branchproof
             id: condition[:id], decision_id: decision[:id], index: condition[:index],
             expression: condition[:expression],
             line: condition[:line], column: condition[:column], relative_path: relative_path(source[:relative_path]),
-            decision_expression: decision[:expression],
+            decision_expression: decision[:expression], kind: decision_kind(decision), context: decision[:context],
             status: @document[:analysis] ? (result[:status] || "NOT_PROVEN") : "NOT CALCULATED",
             observed_true: test_ids(observations[true]), observed_false: test_ids(observations[false]),
             short_circuited: test_ids(observations[:short_circuited]),
@@ -80,12 +81,69 @@ module Branchproof
       end
     end
 
+    def build_alternatives
+      records(@inventory, :decisions).flat_map do |decision|
+        next [] if decision[:support_status].to_s == "UNSUPPORTED"
+        next [] if boolean_decision?(decision)
+
+        source = @source_units_by_id[decision[:source_id].to_s] || {}
+        coverage = symbolize(analysis_for(decision)[:coverage] || {})[:alternative] || {}
+        coverage_rows = records(coverage, :alternatives).to_h { |row| [row[:alternative_id].to_s, row] }
+        vectors = @vectors_by_decision[decision[:id].to_s] || []
+        records(decision, :alternatives).map do |alternative|
+          alternative = symbolize(alternative)
+          evidence = { selected: [], not_selected: [], skipped: [] }
+          vectors.each do |vector|
+            value = vector_values(vector)[alternative[:index].to_i]
+            state = if value.nil?
+                      :skipped
+                    else
+                      (value ? :selected : :not_selected)
+                    end
+            evidence[state] << vector
+          end
+          row = symbolize(coverage_rows[alternative[:id].to_s] || {})
+          {
+            id: alternative[:id], alternative_id: alternative[:id], decision_id: decision[:id],
+            index: alternative[:index], expression: alternative[:expression],
+            line: alternative[:line], column: alternative[:column],
+            relative_path: relative_path(source[:relative_path]),
+            decision_expression: decision[:expression], kind: decision_kind(decision),
+            context: decision[:context],
+            status: @document[:analysis] ? alternative_status(row, evidence) : "NOT CALCULATED",
+            selected: row[:selected] || evidence_bucket(evidence[:selected]),
+            not_selected: row[:not_selected] || evidence_bucket(evidence[:not_selected]),
+            skipped: row[:skipped] || evidence_bucket(evidence[:skipped]),
+            vectors: evidence, missing: missing_alternative?(coverage, alternative)
+          }
+        end
+      end
+    end
+
     def build_tests
       by_id = @tests_by_id.transform_values do |test|
         { id: test[:id], name: display_name(test), relative_path: test_location(test)[0], line: test_location(test)[1],
           status: test[:status], phases: Array(test[:phase_counts]).to_h.keys.sort,
           observations: [], owns_witness: false }
       end
+      @alternatives.each do |alternative|
+        alternative[:vectors].each do |kind, vectors|
+          vectors.each do |vector|
+            Array(vector[:test_ids]).each do |id|
+              row = by_id[id.to_s] ||= { id: id, name: id, relative_path: nil, line: nil, status: "unknown",
+                                         phases: [], observations: [], owns_witness: false }
+              phase_map = symbolize(vector[:phases_by_test] || {})
+              phases = phase_map[id.to_s] || phase_map[id.to_sym] || []
+              row[:phases] |= Array(phases).map(&:to_s)
+              row[:observations] << { alternative_id: alternative[:id], expression: alternative[:expression],
+                                      relative_path: alternative[:relative_path], line: alternative[:line],
+                                      value: kind == :skipped ? nil : (kind == :selected), kind: :alternative,
+                                      alternative_state: kind.to_s, phases: phases.map(&:to_s).sort,
+                                      owns_witness: false }
+            end
+          end
+        end
+      end
       @conditions.each do |condition|
         condition[:vectors].each do |kind, vectors|
           next if kind == :unattributed
@@ -118,6 +176,36 @@ module Branchproof
       @analysis_by_decision[decision[:id].to_s] || {}
     end
 
+    def boolean_decision?(decision)
+      decision_kind(decision) == "boolean"
+    end
+
+    def decision_kind(decision)
+      kind = decision[:kind].to_s
+      kind.empty? ? "boolean" : kind
+    end
+
+    def evidence_bucket(vectors)
+      evidence = vectors.map do |vector|
+        { vector_id: vector[:id].to_s, test_ids: Array(vector[:test_ids]).map(&:to_s).uniq.sort,
+          unattributed_count: vector[:unattributed_count].to_i }
+      end
+      { 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 missing_alternative?(coverage, alternative)
+      Array(coverage[:missing_alternatives]).map(&:to_s).include?(alternative[:id].to_s)
+    end
+
+    def alternative_status(row, evidence)
+      status = row[:status].to_s
+      return status unless status.empty?
+
+      evidence[:selected].empty? ? "unexecuted" : "covered"
+    end
+
     def supporting_set_for(decision_id)
       Array(@document[:minima] || @document["minima"]).filter_map do |minimum|
         minimum = symbolize(minimum)