branchproof 0.10.0 → 0.11.0

data/lib/branchproof/coverage_policy.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+# rubocop:disable Metrics/ClassLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity, Metrics/ParameterLists
+
+module Branchproof
+  # Evaluates configured coverage thresholds against the aggregate Analyzer
+  # coverage counts without relying on rounded percentage fields.
+  class CoveragePolicy
+    CRITERIA = {
+      "decision" => { numerator: "covered_decisions", denominator: "supported_decisions" },
+      "condition" => { numerator: "covered_values", denominator: "required_values" },
+      "condition_decision" => { numerator: "covered_decisions", denominator: "supported_decisions" },
+      "mcdc" => { numerator: "proven_conditions", denominator: "supported_conditions" },
+      "decision_table" => { numerator: "covered_rules", denominator: "required_rules" }
+    }.freeze
+    COMPLETENESS_FIELDS = %w[observation attribution analysis].freeze
+
+    class << self
+      def normalize(minimum)
+        raise ArgumentError, "minimum must be a hash" unless minimum.is_a?(Hash)
+
+        minimum.each_with_object({}) do |(key, threshold), normalized|
+          unless key.is_a?(String) || key.is_a?(Symbol)
+            raise ArgumentError, "unknown coverage criterion: #{key.inspect}"
+          end
+
+          criterion = key.to_s
+          raise ArgumentError, "unknown coverage criterion: #{criterion}" unless CRITERIA.key?(criterion)
+          raise ArgumentError, "duplicate coverage criterion: #{criterion}" if normalized.key?(criterion)
+
+          validate_threshold!(criterion, threshold)
+          normalized[criterion] = threshold
+        end
+      end
+
+      private
+
+      def validate_threshold!(criterion, threshold)
+        valid_type = threshold.is_a?(Integer) || threshold.is_a?(Float)
+        valid_float = !threshold.is_a?(Float) || threshold.finite?
+        unless valid_type && valid_float
+          raise ArgumentError, "coverage minimum for #{criterion} must be a finite number"
+        end
+        return if (0..100).cover?(threshold)
+
+        raise ArgumentError, "coverage minimum for #{criterion} must be between 0 and 100"
+      end
+    end
+
+    def initialize(minimum:)
+      @minimum = self.class.normalize(minimum)
+    end
+
+    def call(document:)
+      return { minimum: @minimum.dup, status: "passed", gates: [] } if @minimum.empty?
+
+      global_reason = availability_reason(document)
+      gates = @minimum.map do |criterion, threshold|
+        evaluate_gate(criterion, threshold, document, global_reason)
+      end
+
+      status = if gates.any? { |gate| gate[:status] == "unavailable" }
+                 "unavailable"
+               elsif gates.any? { |gate| gate[:status] == "failed" }
+                 "failed"
+               else
+                 "passed"
+               end
+
+      { minimum: @minimum.dup, status: status, gates: gates }
+    end
+
+    private
+
+    def availability_reason(document)
+      return "document_unavailable" unless document.is_a?(Hash)
+
+      baseline = value(document, :baseline)
+      baseline_passed = baseline.is_a?(Hash) && value(baseline, :status).to_s.upcase == "PASSED"
+      return "baseline_unavailable" unless baseline_passed && value(baseline, :finalized) == true
+      return "incomplete_document" unless complete?(value(document, :completeness))
+
+      observations = value(document, :observations) || value(document, :evidence)
+      return "incomplete_observations" if incomplete_section?(observations)
+
+      analysis = value(document, :analysis)
+      return "incomplete_analysis" if incomplete_section?(analysis)
+
+      nil
+    end
+
+    def complete?(completeness)
+      return false unless completeness.is_a?(Hash)
+
+      COMPLETENESS_FIELDS.all? { |field| value(completeness, field) == true }
+    end
+
+    def incomplete_section?(section)
+      section.is_a?(Hash) && key_present?(section, :completeness) && !complete?(value(section, :completeness))
+    end
+
+    def evaluate_gate(criterion, threshold, document, global_reason)
+      return gate(criterion, threshold, nil, nil, "unavailable", global_reason) if global_reason
+
+      coverage = value(value(document, :analysis), :coverage)
+      row = value(coverage, criterion)
+      return gate(criterion, threshold, nil, nil, "unavailable", "missing_coverage_count") unless row.is_a?(Hash)
+
+      mapping = CRITERIA.fetch(criterion)
+      numerator = value(row, mapping.fetch(:numerator))
+      denominator = value(row, mapping.fetch(:denominator))
+
+      if criterion == "decision_table"
+        not_calculated = value(row, :not_calculated_decisions)
+        unless not_calculated.nil?
+          unless valid_count?(not_calculated)
+            return gate(criterion, threshold, numerator, denominator, "unavailable", "invalid_coverage_count")
+          end
+          if not_calculated.positive?
+            return gate(criterion, threshold, numerator, denominator, "unavailable", "decision_table_not_calculated")
+          end
+        end
+      end
+
+      if numerator.nil? || denominator.nil?
+        return unavailable_gate(criterion, threshold, numerator, denominator, "missing_coverage_count")
+      end
+      unless valid_count?(numerator) && valid_count?(denominator)
+        return unavailable_gate(criterion, threshold, numerator, denominator, "invalid_coverage_count")
+      end
+      return unavailable_gate(criterion, threshold, numerator, denominator, "zero_denominator") if denominator.zero?
+      if numerator > denominator
+        return unavailable_gate(criterion, threshold, numerator, denominator, "invalid_coverage_count")
+      end
+
+      status = numerator * 100 >= denominator * Rational(threshold.to_s) ? "passed" : "failed"
+      gate(criterion, threshold, numerator, denominator, status, nil)
+    end
+
+    def valid_count?(value)
+      value.is_a?(Integer) && value >= 0
+    end
+
+    def gate(criterion, threshold, numerator, denominator, status, reason)
+      { criterion: criterion, numerator: numerator, denominator: denominator, minimum: threshold,
+        status: status, reason: reason }
+    end
+
+    def unavailable_gate(criterion, threshold, numerator, denominator, reason)
+      gate(criterion, threshold, numerator, denominator, "unavailable", reason)
+    end
+
+    def value(hash, key)
+      return nil unless hash.respond_to?(:key?)
+      return hash[key] if hash.key?(key)
+
+      alternate = key.is_a?(Symbol) ? key.to_s : key.to_sym
+      return hash[alternate] if hash.key?(alternate)
+
+      nil
+    end
+
+    def key_present?(hash, key)
+      hash.key?(key) || hash.key?(key.to_s) || hash.key?(key.to_sym)
+    end
+  end
+end
+
+# rubocop:enable Metrics/ClassLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity, Metrics/ParameterLists

data/lib/branchproof/evidence.rb

@@ -50,7 +50,9 @@ module Branchproof
       current = @tests[id] || { id: id, adapter: "unknown", name: id, source: nil, class_name: nil,
                                 method_name: nil, status: "unknown", phase_counts: {} }
       merged = current.merge(value).merge(id: id)
-      merged[:phase_counts] = (current[:phase_counts] || {}).merge(value[:phase_counts] || {})
+      merged[:phase_counts] = normalize_phase_counts(current[:phase_counts]).merge(
+        normalize_phase_counts(value[:phase_counts])
+      )
       @tests[id] = deep_dup(merged)
       status("registered", nil)
     end
@@ -172,7 +174,7 @@ module Branchproof
         @run_payloads[id] = Branchproof::Records.id(payload)
       end
       @run_ids |= incoming_runs
-      incoming.fetch(:tests, []).each { register_test(test: _1) }
+      incoming.fetch(:tests, []).each { merge_test(_1) }
       incoming.fetch(:vectors, []).each { merge_vector(_1) }
       @diagnostics.concat(incoming.fetch(:diagnostics, []))
       @abort_counts.merge!(incoming.fetch(:abort_counts, {})) { |_k, a, b| a.to_i + b.to_i }
@@ -337,6 +339,39 @@ module Branchproof
       end
     end
 
+    def merge_test(raw)
+      value = symbolize(raw)
+      value[:phase_counts] = normalize_phase_counts(value[:phase_counts])
+      id = (value[:id] || test_id(value)).to_s
+      unless @tests.key?(id)
+        register_test(test: value)
+        return unless @tests.key?(id)
+
+        return
+      end
+
+      current = @tests.fetch(id)
+      merged = current.merge(value).merge(id: id)
+      merged[:phase_counts] = sum_phase_counts(current[:phase_counts], value[:phase_counts])
+      @tests[id] = deep_dup(merged)
+    end
+
+    def normalize_phase_counts(value)
+      (value || {}).each_with_object({}) do |(phase, count), result|
+        key = phase.to_s
+        result[key] = result.fetch(key, 0) + count
+      end
+    end
+
+    def sum_phase_counts(*counts)
+      counts.each_with_object({}) do |phase_counts, result|
+        normalize_phase_counts(phase_counts).each do |phase, count|
+          result[phase] = result.fetch(phase, 0) + count
+        end
+        result
+      end
+    end
+
     def merge_error(incoming)
       return "unsupported schema" unless incoming[:schema_version].to_s == SCHEMA_VERSION
       return "criterion mismatch" unless incoming[:criterion_version].to_s == CRITERION_VERSION

data/lib/branchproof/focused_report.rb

@@ -1,14 +1,17 @@
 # frozen_string_literal: true
 
-# rubocop:disable Metrics/ClassLength, Metrics/AbcSize, Metrics/BlockLength, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+# rubocop:disable Metrics/ClassLength, Metrics/AbcSize, Metrics/BlockLength, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/ParameterLists, Metrics/PerceivedComplexity
 require "pathname"
+require_relative "coverage_index"
+require_relative "report_selection"
 
 module Branchproof
   # Terminal renderings grouped around conditions or tests.
   class FocusedReport
     DECISION_TABLE_LABELS = { "true" => "T", "false" => "F", "dont_care" => "-" }.freeze
 
-    def initialize(document:, view:, level:, missing_only: false, coordinator: nil)
+    def initialize(document:, view:, level:, missing_only: false, coordinator: nil, focus: nil, top: nil,
+                   selection: nil)
       @document = document || {}
       @view = view.to_sym
       unless (Report::VIEWS - [:decisions]).include?(@view)
@@ -17,12 +20,14 @@ module Branchproof
 
       @level = level.to_i
       @missing_only = missing_only ? true : false
+      @selection = selection || ReportSelection.new(focus: focus, top: top)
       @index = CoverageIndex.new(document: @document)
       @tests = @index.tests.to_h { |test| [test[:id].to_s, test] }
       @test_name_counts = @index.tests.each_with_object(Hash.new(0)) do |test, counts|
         counts[[test[:name], test[:relative_path], test[:line]]] += 1
       end
       @coordinator = coordinator || Report.from_document(document: @document, level: @level)
+      @matching_decision_ids = @selection.focus_active? ? @selection.matching_decision_ids(@document) : nil
     end
 
     def render
@@ -45,20 +50,19 @@ module Branchproof
       end
       lines << "Empty groups mean no recorded completed observation."
       lines << ""
+      render_focus_notice(lines)
       lines.concat(@coordinator.coverage_ladder_lines)
+      lines.concat(@coordinator.coverage_policy_lines)
       case @view
       when :conditions
         render_conditions(lines)
-        render_alternatives(lines)
       when :decision_tables
         render_decision_tables(lines)
       else
         render_tests(lines)
       end
-      unless @view == :decision_tables
-        render_unowned(lines)
-        render_unsupported(lines)
-      end
+      render_unowned(lines)
+      render_unsupported(lines)
       Array(fetch(@document, :diagnostics)).each do |diagnostic|
         lines << "Diagnostic: #{@coordinator.diagnostic_message(diagnostic)}"
       end
@@ -68,8 +72,8 @@ module Branchproof
     private
 
     def render_conditions(lines)
-      rows = @index.conditions
-      rows = rows.reject { |row| row[:status].to_s.upcase == "PROVEN" } if @missing_only && @level > 1
+      rows, alternatives, hidden = condition_rows_for_display
+      append_limit_summary(lines, hidden, "condition/alternative row")
       rows.each do |row|
         lines << "Condition: #{row[:expression]}"
         lines << "Location: #{location(row[:relative_path], row[:line], unavailable: "condition line unavailable")}"
@@ -108,7 +112,8 @@ module Branchproof
         end
         lines << ""
       end
-      lines << "No missing conditions" if @missing_only && rows.empty?
+      lines << "No missing conditions" if @missing_only && rows.empty? && focus_match_exists?
+      render_alternatives(lines, alternatives)
     end
 
     def coverage_available?
@@ -133,11 +138,12 @@ module Branchproof
     # --missing-only only uncovered, non-impossible rules remain: a rule proven
     # impossible is not a missing obligation.
     def render_decision_tables(lines)
-      rows = @index.decision_tables
+      all_rows = filtered_decision_tables
+      rows, hidden = limit_rows(all_rows)
+      append_limit_summary(lines, hidden, "decision")
       rendered = 0
-      impossible = 0
+      impossible = @index.decision_tables.sum { |row| row[:impossible_rules].to_i }
       rows.each do |row|
-        impossible += row[:impossible_rules].to_i
         rules = @missing_only ? row[:rules].select { |rule| rule[:coverage].to_s == "missing" } : row[:rules]
         next if @missing_only && rules.empty? && row[:status].to_s == "calculated"
 
@@ -187,9 +193,8 @@ module Branchproof
       lines << "    Reason: #{Constraints.message(rule[:reachability_reason])}"
     end
 
-    def render_alternatives(lines)
-      rows = @index.alternatives
-      rows = rows.select { |row| row[:missing] || row[:status].to_s != "covered" } if @missing_only && @level > 1
+    def render_alternatives(lines, rows = nil)
+      rows ||= filtered_alternatives
       rows.each do |row|
         lines << "Alternative #{row[:index]}: #{row[:expression]}"
         lines << "Location: #{location(row[:relative_path], row[:line],
@@ -208,7 +213,7 @@ module Branchproof
         end
         lines << ""
       end
-      lines << "No missing alternatives" if @missing_only && rows.empty?
+      lines << "No missing alternatives" if @missing_only && rows.empty? && focus_match_exists?
     end
 
     def render_alternative_group(lines, heading, evidence)
@@ -219,22 +224,22 @@ module Branchproof
     end
 
     def render_tests(lines)
-      rows = @index.tests
+      rows = filtered_tests
       missing_ids = @index.conditions.reject { |row| row[:status].to_s.upcase == "PROVEN" }.map { |row| row[:id] }
       missing_alternative_ids = @index.alternatives.select { |row| row[:missing] || row[:status].to_s != "covered" }
                                       .map { |row| row[:alternative_id] }
+      rows = rows.select do |row|
+        !@missing_only || test_observations(row, missing_ids, missing_alternative_ids).any?
+      end
+      rows, hidden = limit_rows(rows)
+      append_limit_summary(lines, hidden, "test")
       rows.each { |row| render_test_row(lines, row, missing_ids, missing_alternative_ids) }
     end
 
     def render_test_row(lines, row, missing_ids, missing_alternative_ids = [])
-      observations = row[:observations]
-      if @missing_only
-        observations = observations.select do |observation|
-          missing_ids.include?(observation[:condition_id]) ||
-            missing_alternative_ids.include?(observation[:alternative_id])
-        end
-        return if observations.empty?
-      end
+      observations = test_observations(row, missing_ids, missing_alternative_ids)
+      return if @missing_only && observations.empty?
+
       lines << "Test: #{row[:name]}"
       lines << "Location: #{location(row[:relative_path], row[:line], unavailable: "location unavailable")}"
       lines << "Status: #{row[:status] || "unknown"}"
@@ -291,6 +296,11 @@ module Branchproof
       groups.each do |heading, conditions|
         next if conditions.empty?
 
+        if @selection.active?
+          lines << "#{heading}: #{conditions.length} (run-wide)"
+          next
+        end
+
         lines << "#{heading}:"
         conditions.each do |row|
           unavailable = row[:alternative_id] ? "alternative location unavailable" : "condition line unavailable"
@@ -307,6 +317,12 @@ module Branchproof
       end
       return if excluded.empty?
 
+      if @selection.active?
+        noun = excluded.length == 1 ? "decision" : "decisions"
+        lines << "Unsupported conditions (MC/DC unavailable): #{excluded.length} #{noun} (run-wide)"
+        return
+      end
+
       lines << "Unsupported conditions (MC/DC unavailable):"
       excluded.each do |decision|
         source = sources[fetch(decision, :source_id)] || {}
@@ -321,6 +337,107 @@ module Branchproof
       end
     end
 
+    def render_focus_notice(lines)
+      return unless @selection.focus_active?
+
+      lines << if @matching_decision_ids.empty?
+                 "Focus: no matching decisions for #{@selection.focus_label}"
+               else
+                 "Focus: #{@selection.focus_label}"
+               end
+    end
+
+    def append_limit_summary(lines, hidden, unit)
+      return unless @selection.top
+
+      noun = hidden == 1 ? unit : "#{unit}s"
+      hidden_noun = hidden == 1 ? unit : "#{unit}s"
+      lines << "Display limit: top #{@selection.top} #{noun}; hidden #{hidden} #{hidden_noun} " \
+               "(not risk-ranked)"
+    end
+
+    def focus_match_exists?
+      !@selection.focus_active? || !@matching_decision_ids.empty?
+    end
+
+    def filtered_conditions
+      rows = @index.conditions
+      rows = rows.select { |row| @matching_decision_ids.include?(row[:decision_id].to_s) } if @selection.focus_active?
+      rows = rows.reject { |row| row[:status].to_s.upcase == "PROVEN" } if @missing_only && @level > 1
+      rows.sort_by do |row|
+        [row[:relative_path].to_s, row[:line].to_i, row[:column].to_i,
+         row[:decision_id].to_s, row[:index].to_i]
+      end
+    end
+
+    def filtered_alternatives
+      rows = @index.alternatives
+      rows = rows.select { |row| @matching_decision_ids.include?(row[:decision_id].to_s) } if @selection.focus_active?
+      rows = rows.select { |row| row[:missing] || row[:status].to_s != "covered" } if @missing_only && @level > 1
+      rows.sort_by do |row|
+        [row[:relative_path].to_s, row[:line].to_i, row[:column].to_i,
+         row[:decision_id].to_s, row[:index].to_i]
+      end
+    end
+
+    def condition_rows_for_display
+      conditions = filtered_conditions
+      alternatives = filtered_alternatives
+      return [conditions, alternatives, 0] unless @selection.top
+
+      combined = (conditions.map { |row| [:condition, row] } + alternatives.map { |row| [:alternative, row] })
+                 .sort_by do |kind, row|
+        [row[:relative_path].to_s, row[:line].to_i, row[:column].to_i, kind == :condition ? 0 : 1,
+         row[:decision_id].to_s, row[:index].to_i]
+      end
+      visible, hidden = @selection.limit(combined)
+      [visible.filter_map { |kind, row| row if kind == :condition },
+       visible.filter_map { |kind, row| row if kind == :alternative }, hidden]
+    end
+
+    def filtered_decision_tables
+      rows = @index.decision_tables
+      rows = rows.select { |row| @matching_decision_ids.include?(row[:decision_id].to_s) } if @selection.focus_active?
+      rows = rows.select do |row|
+        !@missing_only || row[:status].to_s != "calculated" || row[:rules].any? do |rule|
+          rule[:coverage].to_s == "missing"
+        end
+      end
+      rows.sort_by { |row| [row[:relative_path].to_s, row[:line].to_i, row[:decision_id].to_s] }
+    end
+
+    def filtered_tests
+      rows = @index.tests
+      return rows unless @selection.active?
+
+      if @selection.focus_active?
+        condition_ids = @index.conditions.select { |row| @matching_decision_ids.include?(row[:decision_id].to_s) }
+                              .map { |row| row[:id].to_s }
+        alternative_ids = @index.alternatives.select { |row| @matching_decision_ids.include?(row[:decision_id].to_s) }
+                                .map { |row| row[:alternative_id].to_s }
+        rows = rows.select do |row|
+          row[:observations].any? do |observation|
+            condition_ids.include?(observation[:condition_id].to_s) ||
+              alternative_ids.include?(observation[:alternative_id].to_s)
+          end
+        end
+      end
+      rows.sort_by { |row| [row[:relative_path].to_s, row[:line].to_i, row[:name].to_s, row[:id].to_s] }
+    end
+
+    def limit_rows(rows)
+      @selection.limit(rows)
+    end
+
+    def test_observations(row, missing_ids, missing_alternative_ids)
+      return row[:observations] unless @missing_only
+
+      row[:observations].select do |observation|
+        missing_ids.include?(observation[:condition_id]) ||
+          missing_alternative_ids.include?(observation[:alternative_id])
+      end
+    end
+
     def location(path, line, unavailable: "location unavailable")
       return "location unavailable" if path.to_s.empty?
       return "#{path}: #{unavailable}" if line.nil?
@@ -356,4 +473,4 @@ module Branchproof
   end
 end
 
-# rubocop:enable Metrics/ClassLength, Metrics/AbcSize, Metrics/BlockLength, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+# rubocop:enable Metrics/ClassLength, Metrics/AbcSize, Metrics/BlockLength, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/ParameterLists, Metrics/PerceivedComplexity