branchproof 0.5.0 → 0.7.0

data/lib/branchproof/focused_report.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-# rubocop:disable Metrics/ClassLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+# rubocop:disable Metrics/ClassLength, Metrics/AbcSize, Metrics/BlockLength, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
 require "pathname"
 
 module Branchproof
@@ -23,7 +23,11 @@ module Branchproof
       completeness = fetch(@document, :completeness) || {}
       evidence = fetch(@document, :observations) || {}
       lines = ["Branchproof focused view: #{@view}", "Tests: #{fetch(baseline, :status) || "INCOMPLETE"}",
-               "Values: T=true, F=false, -=short-circuited"]
+               (if @index.alternatives.empty?
+                  "Values: T=true, F=false, -=short-circuited"
+                else
+                  "Values: Boolean T=true/F=false; flow T=selected, F=not-selected, -=skipped"
+                end)]
       if completeness.values.include?(false) || fetch(baseline, :status).to_s != "PASSED"
         lines << "Warning: failed or incomplete run; observations and proof evidence may be unavailable."
       end
@@ -34,7 +38,13 @@ module Branchproof
       end
       lines << "Empty groups mean no recorded completed observation."
       lines << ""
-      @view == :conditions ? render_conditions(lines) : render_tests(lines)
+      lines.concat(@coordinator.coverage_ladder_lines)
+      if @view == :conditions
+        render_conditions(lines)
+        render_alternatives(lines)
+      else
+        render_tests(lines)
+      end
       render_unowned(lines)
       render_unsupported(lines)
       Array(fetch(@document, :diagnostics)).each do |diagnostic|
@@ -52,7 +62,17 @@ module Branchproof
         lines << "Condition: #{row[:expression]}"
         lines << "Location: #{location(row[:relative_path], row[:line], unavailable: "condition line unavailable")}"
         lines << "Decision: #{row[:decision_expression]} (condition #{row[:index]})"
-        lines << "MC/DC: #{@level == 1 ? "NOT CALCULATED" : (row[:status] || "NOT_PROVEN")}"
+        lines << "Kind: #{row[:kind]}"
+        lines << "Context: #{row[:context]}" unless row[:context].to_s.empty?
+        status = if @level == 1 && !coverage_available?
+                   "NOT CALCULATED"
+                 else
+                   row[:status] || "NOT_PROVEN"
+                 end
+        lines << "MC/DC: #{status}"
+        if @level >= 2
+          lines.concat(@coordinator.condition_coverage_evidence(decision_id: row[:decision_id], condition_id: row[:id]))
+        end
         render_group(lines, "Evaluated true by", row[:observed_true], row)
         render_group(lines, "Evaluated false by", row[:observed_false], row)
         render_group(lines, "Short-circuited in", row[:short_circuited], row)
@@ -79,6 +99,11 @@ module Branchproof
       lines << "No missing conditions" if @missing_only && rows.empty?
     end
 
+    def coverage_available?
+      analysis = fetch(@document, :analysis)
+      analysis && fetch(analysis, :coverage)
+    end
+
     def render_constraint(lines, row)
       lines << @coordinator.condition_explanation(decision_id: row[:decision_id], condition_id: row[:id])
     end
@@ -92,16 +117,52 @@ module Branchproof
       end
     end
 
+    def render_alternatives(lines)
+      rows = @index.alternatives
+      rows = rows.select { |row| row[:missing] || row[:status].to_s != "covered" } if @missing_only && @level > 1
+      rows.each do |row|
+        lines << "Alternative #{row[:index]}: #{row[:expression]}"
+        lines << "Location: #{location(row[:relative_path], row[:line],
+                                       unavailable: "alternative location unavailable")}"
+        lines << "Decision: #{row[:decision_expression]} (alternative #{row[:index]})"
+        lines << "Kind: #{row[:kind]}"
+        lines << "Context: #{row[:context]}" unless row[:context].to_s.empty?
+        lines << "Selection: #{row[:status] || "NOT_CALCULATED"}"
+        lines << "MC/DC: N/A (not applicable)"
+        render_alternative_group(lines, "Selected by", row[:selected])
+        render_alternative_group(lines, "Not selected by", row[:not_selected])
+        render_alternative_group(lines, "Skipped in", row[:skipped])
+        if row[:missing]
+          lines << "  Missing alternative: #{row[:expression]}"
+          lines << "  Need selection of: #{row[:expression]}"
+        end
+        lines << ""
+      end
+      lines << "No missing alternatives" if @missing_only && rows.empty?
+    end
+
+    def render_alternative_group(lines, heading, evidence)
+      evidence ||= {}
+      ids = Array(evidence[:test_ids]).map { |id| test_label(id) }
+      ids << "unattributed" if evidence[:unattributed_count].to_i.positive?
+      lines << "  #{heading}: #{ids.empty? ? "none recorded" : ids.uniq.join(", ")}"
+    end
+
     def render_tests(lines)
       rows = @index.tests
       missing_ids = @index.conditions.reject { |row| row[:status].to_s.upcase == "PROVEN" }.map { |row| row[:id] }
-      rows.each { |row| render_test_row(lines, row, missing_ids) }
+      missing_alternative_ids = @index.alternatives.select { |row| row[:missing] || row[:status].to_s != "covered" }
+                                      .map { |row| row[:alternative_id] }
+      rows.each { |row| render_test_row(lines, row, missing_ids, missing_alternative_ids) }
     end
 
-    def render_test_row(lines, row, missing_ids)
+    def render_test_row(lines, row, missing_ids, missing_alternative_ids = [])
       observations = row[:observations]
       if @missing_only
-        observations = observations.select { |observation| missing_ids.include?(observation[:condition_id]) }
+        observations = observations.select do |observation|
+          missing_ids.include?(observation[:condition_id]) ||
+            missing_alternative_ids.include?(observation[:alternative_id])
+        end
         return if observations.empty?
       end
       lines << "Test: #{row[:name]}"
@@ -117,31 +178,51 @@ module Branchproof
         lines << "  No recorded completed condition observations"
         return
       end
-      observations.group_by { |observation| observation[:condition_id] }.each_value do |items|
+      grouped = observations.group_by { |observation| observation[:alternative_id] || observation[:condition_id] }
+      grouped.each_value do |items|
         observation = items.first
-        observed_values = items.map { |item| item[:value] }.uniq
-        label = observed_values.all?(&:nil?) ? "short-circuited-only" : "evaluated"
-        label += "; owns canonical witness evidence" if @level > 1 && items.any? { |item| item[:owns_witness] }
         phases = items.flat_map { |item| item[:phases] }.uniq.sort.join(", ")
-        signs = values(values: observed_values)
-        condition_location = location(observation[:relative_path], observation[:line],
-                                      unavailable: "condition line unavailable")
-        lines << "  #{observation[:expression]} (#{condition_location}): #{signs}; #{label}; " \
-                 "phases: #{phases}"
+        if observation[:alternative_id]
+          states = items.map { |item| item[:alternative_state] }.uniq.join(", ")
+          alternative_location = location(observation[:relative_path], observation[:line],
+                                          unavailable: "alternative location unavailable")
+          lines << "  Alternative #{observation[:alternative_id]}: #{observation[:expression]} " \
+                   "(#{alternative_location}): #{states}; phases: #{phases}"
+        else
+          observed_values = items.map { |item| item[:value] }.uniq
+          label = observed_values.all?(&:nil?) ? "short-circuited-only" : "evaluated"
+          label += "; owns canonical witness evidence" if @level > 1 && items.any? { |item| item[:owns_witness] }
+          signs = values(values: observed_values)
+          condition_location = location(observation[:relative_path], observation[:line],
+                                        unavailable: "condition line unavailable")
+          lines << "  #{observation[:expression]} (#{condition_location}): #{signs}; #{label}; " \
+                   "phases: #{phases}"
+        end
       end
     end
 
     def render_unowned(lines)
       rows = @index.conditions
       rows = rows.reject { |row| row[:status] == "PROVEN" } if @missing_only
-      { "Unexecuted conditions" => rows.select { |row| row[:unexecuted] },
-        "Unattributed evidence" => rows.select { |row| row[:unattributed].positive? } }.each do |heading, conditions|
+      groups = { "Unexecuted conditions" => rows.select { |row| row[:unexecuted] },
+                 "Unattributed evidence" => rows.select { |row| row[:unattributed].positive? } }
+      alternative_rows = @index.alternatives
+      alternative_rows = alternative_rows.reject { |row| row[:status].to_s == "covered" } if @missing_only
+      unless alternative_rows.empty?
+        groups["Unexecuted alternatives"] = alternative_rows.select do |row|
+          row[:selected][:observed] == false && row[:not_selected][:observed] == false
+        end
+        groups["Unattributed alternative evidence"] = alternative_rows.select do |row|
+          %i[selected not_selected skipped].any? { |state| row[state][:unattributed_count].to_i.positive? }
+        end
+      end
+      groups.each do |heading, conditions|
         next if conditions.empty?
 
         lines << "#{heading}:"
         conditions.each do |row|
-          lines << "  #{row[:expression]} (#{location(row[:relative_path], row[:line],
-                                                      unavailable: "condition line unavailable")})"
+          unavailable = row[:alternative_id] ? "alternative location unavailable" : "condition line unavailable"
+          lines << "  #{row[:expression]} (#{location(row[:relative_path], row[:line], unavailable: unavailable)})"
         end
       end
     end
@@ -202,4 +283,4 @@ module Branchproof
   end
 end
 
-# rubocop:enable Metrics/ClassLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+# rubocop:enable Metrics/ClassLength, Metrics/AbcSize, Metrics/BlockLength, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity

data/lib/branchproof/instrumenter.rb

@@ -1,10 +1,14 @@
 # frozen_string_literal: true
 
+require_relative "flow_instrumentation"
+
 module Branchproof
   # Applies the smallest possible source edits around inventoried expressions.
   # The edits are deliberately textual: Prism owns the ranges, while this class
   # never evaluates application code or introduces a Ruby scope.
   class Instrumenter
+    include FlowInstrumentation
+
     RUNTIME = "::Branchproof::Runtime"
 
     def rewrite(unit:)
@@ -17,8 +21,7 @@ module Branchproof
       decisions = Array(unit[:decisions]).select { |decision| supported?(decision) }
       edits = decisions.filter_map do |decision|
         next if decisions.any? do |outer|
-          outer != decision && contains?(outer[:byte_start], outer[:byte_length], decision[:byte_start],
-                                         decision[:byte_length])
+          encloses_decision?(outer, decision)
         end
 
         decision_edit(bytes, decision, decisions)
@@ -57,13 +60,13 @@ module Branchproof
       return nil unless valid_range?(bytes, start, length)
 
       nested = all_decisions.select do |candidate|
-        candidate != decision && contains?(start, length, candidate[:byte_start], candidate[:byte_length])
+        encloses_decision?(decision, candidate)
       end
-      expression = render_range(bytes, start, length, decision, nested)
+      expression = render_decision(bytes, decision, nested)
       {
         start: start,
         finish: start + length,
-        text: frame(decision[:id], expression)
+        text: expression
       }
     end
 
@@ -90,24 +93,36 @@ module Branchproof
         contains?(start, length, child[:byte_start], child[:byte_length])
       end
       children = children.reject do |child|
-        nested.any? do |candidate|
-          candidate != child && contains?(candidate[:byte_start], candidate[:byte_length], child[:byte_start],
-                                          child[:byte_length])
-        end
+        children.any? { |candidate| encloses_decision?(candidate, child) }
       end
       children.sort_by! { |child| -child[:byte_start] }
       output = bytes.byteslice(start, length)
       children.each do |child|
-        child_text = render_range(bytes, child[:byte_start], child[:byte_length], child, nested.reject do |item|
-          item.equal?(child)
-        end)
-        child_text = frame(child[:id], child_text)
+        descendants = nested.select { |candidate| encloses_decision?(child, candidate) }
+        child_text = render_decision(bytes, child, descendants)
         offset = child[:byte_start] - start
         output[offset, child[:byte_length]] = child_text
       end
       output
     end
 
+    def encloses_decision?(outer, inner)
+      return false if outer.equal?(inner) || outer == inner
+      return false unless contains?(outer[:byte_start], outer[:byte_length], inner[:byte_start], inner[:byte_length])
+      return true unless outer[:byte_start] == inner[:byte_start] && outer[:byte_length] == inner[:byte_length]
+
+      (outer[:kind] || "boolean") == "boolean" && inner[:kind] != "boolean" && !inner[:kind].nil?
+    end
+
+    def render_decision(bytes, decision, nested)
+      if decision[:instrumentation]
+        render_flow(bytes, decision, nested)
+      else
+        expression = render_range(bytes, decision[:byte_start], decision[:byte_length], decision, nested)
+        frame(decision[:id], expression)
+      end
+    end
+
     def condition_wrapper(decision_id, index, expression)
       "#{RUNTIME}.condition(#{decision_id.inspect}, #{index}, (#{expression}))"
     end