branchproof 0.7.0 → 0.8.0

data/lib/branchproof/focused_report.rb

@@ -6,16 +6,23 @@ require "pathname"
 module Branchproof
   # Terminal renderings grouped around conditions or tests.
   class FocusedReport
-    def initialize(document:, view:, level:, missing_only: false)
+    DECISION_TABLE_LABELS = { "true" => "T", "false" => "F", "dont_care" => "-" }.freeze
+
+    def initialize(document:, view:, level:, missing_only: false, coordinator: nil)
       @document = document || {}
       @view = view.to_sym
-      raise ArgumentError, "view must be :conditions or :tests" unless %i[conditions tests].include?(@view)
+      unless (Report::VIEWS - [:decisions]).include?(@view)
+        raise ArgumentError, "view must be :conditions, :tests, or :decision_tables"
+      end
 
       @level = level.to_i
       @missing_only = missing_only ? true : false
       @index = CoverageIndex.new(document: @document)
       @tests = @index.tests.to_h { |test| [test[:id].to_s, test] }
-      @coordinator = Report.from_document(document: @document, level: @level)
+      @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)
     end
 
     def render
@@ -39,14 +46,19 @@ module Branchproof
       lines << "Empty groups mean no recorded completed observation."
       lines << ""
       lines.concat(@coordinator.coverage_ladder_lines)
-      if @view == :conditions
+      case @view
+      when :conditions
         render_conditions(lines)
         render_alternatives(lines)
+      when :decision_tables
+        render_decision_tables(lines)
       else
         render_tests(lines)
       end
-      render_unowned(lines)
-      render_unsupported(lines)
+      unless @view == :decision_tables
+        render_unowned(lines)
+        render_unsupported(lines)
+      end
       Array(fetch(@document, :diagnostics)).each do |diagnostic|
         lines << "Diagnostic: #{@coordinator.diagnostic_message(diagnostic)}"
       end
@@ -117,6 +129,64 @@ module Branchproof
       end
     end
 
+    # One block per Boolean decision that carries a decision table. With
+    # --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
+      rendered = 0
+      impossible = 0
+      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"
+
+        rendered += 1
+        lines << "Decision: #{row[:decision_expression]}"
+        lines << "Location: #{location(row[:relative_path], row[:line], unavailable: "decision line unavailable")}"
+        lines << "Context: #{row[:context]}" unless row[:context].to_s.empty?
+        if row[:status].to_s != "calculated"
+          lines << "Decision Table: NOT CALCULATED"
+          lines << "Reason: #{row[:reason]}"
+          lines << ""
+          next
+        end
+        lines << "Decision Table: #{row[:covered_rules]}/#{row[:required_rules]} rules covered" \
+                 "#{" (#{row[:percentage]}%)" unless row[:percentage].nil?}"
+        lines << "Reachability: not analyzed" unless row[:reachability_analyzed]
+        rules.each { |rule| render_decision_table_rule(lines, row, rule) }
+        lines << ""
+      end
+      lines << "No missing decision-table rules" if @missing_only && rendered.zero?
+      return unless impossible.positive?
+
+      lines << "#{impossible} statically impossible rule#{"s" unless impossible == 1} excluded"
+    end
+
+    def render_decision_table_rule(lines, row, rule)
+      signature = rule[:conditions].map { |item| DECISION_TABLE_LABELS.fetch(item.to_s, item.to_s) }.join
+      status = rule[:coverage].to_s.upcase
+      lines << "  #{rule[:label]} #{signature} => #{rule[:outcome] ? "T" : "F"}  #{status}"
+      row[:conditions].each_with_index do |expression, index|
+        requirement = @coordinator.decision_table_requirement(rule[:conditions][index])
+        next if requirement.nil?
+
+        lines << "    #{expression} = #{requirement}"
+      end
+      lines << "    #{@coordinator.decision_table_expected_heading(row)} #{rule[:outcome] ? "true" : "false"}"
+      if rule[:coverage].to_s == "covered"
+        owners = Array(rule[:tests]).map { |id| test_label(id) }
+        owners << "unattributed" if rule[:unattributed_count].to_i.positive?
+        lines << "    Tests: #{owners.empty? ? "none recorded" : owners.uniq.join(", ")}"
+      else
+        lines << "    Tests: NOT COVERED"
+      end
+      lines << "    Reachability: #{@coordinator.decision_table_reachability(rule)}"
+      return if rule[:reachability_reason].to_s.empty?
+
+      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
@@ -271,9 +341,7 @@ module Branchproof
       return id.to_s unless test
 
       label = "#{test[:name]} (#{location(test[:relative_path], test[:line])})"
-      duplicates = @index.tests.count do |row|
-        [row[:name], row[:relative_path], row[:line]] == [test[:name], test[:relative_path], test[:line]]
-      end
+      duplicates = @test_name_counts[[test[:name], test[:relative_path], test[:line]]]
       duplicates > 1 ? "#{label} [#{id}]" : label
     end
 

data/lib/branchproof/instrumenter.rb

@@ -14,17 +14,14 @@ module Branchproof
     def rewrite(unit:)
       bytes = unit.fetch(:original_bytes).dup.force_encoding(Encoding::BINARY)
       reasons = Array(unit[:support_reasons])
-      unless supported_unit?(unit, reasons)
-        return result(bytes, diagnostics: [diagnostic("unsupported_source", reasons.join(", "))])
-      end
+      return result(bytes, diagnostics: [diagnostic("unsupported_source", reasons.join(", "))]) unless supported?(unit)
 
       decisions = Array(unit[:decisions]).select { |decision| supported?(decision) }
+      encloses, enclosed = build_enclosures(decisions)
       edits = decisions.filter_map do |decision|
-        next if decisions.any? do |outer|
-          encloses_decision?(outer, decision)
-        end
+        next if enclosed[decision]
 
-        decision_edit(bytes, decision, decisions)
+        decision_edit(bytes, decision, encloses)
       end
       if decisions.any? && edits.empty?
         return result(bytes,
@@ -34,35 +31,44 @@ module Branchproof
 
       rewritten = apply_edits(bytes, edits)
       begin
-        RubyVM::InstructionSequence.compile(rewritten, unit[:absolute_path] || "(branchproof)",
-                                            unit[:real_path] || unit[:absolute_path] || "(branchproof)", 1)
+        iseq = RubyVM::InstructionSequence.compile(rewritten, unit[:absolute_path] || "(branchproof)",
+                                                   unit[:real_path] || unit[:absolute_path] || "(branchproof)", 1)
       rescue SyntaxError => e
-        return result(bytes, diagnostics: [diagnostic("invalid_rewrite", e.message)])
+        return result(rewritten, diagnostics: [diagnostic("invalid_rewrite", e.message)])
       end
-      result(rewritten.force_encoding(unit[:original_bytes].encoding), changed: rewritten != bytes)
+      result(rewritten.force_encoding(unit[:original_bytes].encoding), changed: edits.any?, iseq: iseq)
     end
 
     private
 
-    def supported_unit?(unit, _reasons)
-      status = unit[:support_status]
+    def supported?(record)
+      status = record[:support_status]
       status.nil? || status.to_s.casecmp("supported").zero?
     end
 
-    def supported?(decision)
-      status = decision[:support_status]
-      status.nil? || status.to_s.casecmp("supported").zero?
+    # Precompute, once, which decisions each decision encloses (and whether it is
+    # itself enclosed by any other), so rendering never re-scans the full decision
+    # list at every recursion level. Safe because `encloses_decision?` containment
+    # is transitive: if the encloses map for `decision` says it contains X, that
+    # holds true within any nested subset that already contains `decision`.
+    def build_enclosures(decisions)
+      encloses = {}.compare_by_identity
+      enclosed = {}.compare_by_identity
+      decisions.each do |outer|
+        contained = decisions.select { |inner| encloses_decision?(outer, inner) }
+        encloses[outer] = contained
+        contained.each { |inner| enclosed[inner] = true }
+      end
+      [encloses, enclosed]
     end
 
-    def decision_edit(bytes, decision, all_decisions)
+    def decision_edit(bytes, decision, encloses)
       start = decision[:byte_start]
       length = decision[:byte_length]
       return nil unless valid_range?(bytes, start, length)
 
-      nested = all_decisions.select do |candidate|
-        encloses_decision?(decision, candidate)
-      end
-      expression = render_decision(bytes, decision, nested)
+      nested = encloses[decision] || []
+      expression = render_decision(bytes, decision, nested, encloses)
       {
         start: start,
         finish: start + length,
@@ -70,7 +76,9 @@ module Branchproof
       }
     end
 
-    def render_range(bytes, start, length, decision, nested)
+    def render_range(bytes, decision, nested, encloses)
+      start = decision[:byte_start]
+      length = decision[:byte_length]
       conditions = Array(decision[:conditions]).sort_by { |condition| condition[:byte_start] }
       cursor = start
       chunks = []
@@ -80,15 +88,15 @@ module Branchproof
         next unless valid_range?(bytes, cstart, clen) && cstart >= start && cstart + clen <= start + length
 
         chunks << bytes.byteslice(cursor, cstart - cursor)
-        original = render_children(bytes, cstart, clen, nested)
+        original = render_children(bytes, cstart, clen, nested, encloses)
         chunks << condition_wrapper(decision[:id], condition[:index], original)
         cursor = cstart + clen
       end
-      chunks << render_children(bytes, cursor, length - (cursor - start), nested)
+      chunks << render_children(bytes, cursor, length - (cursor - start), nested, encloses)
       chunks.join
     end
 
-    def render_children(bytes, start, length, nested)
+    def render_children(bytes, start, length, nested, encloses)
       children = nested.select do |child|
         contains?(start, length, child[:byte_start], child[:byte_length])
       end
@@ -98,8 +106,8 @@ module Branchproof
       children.sort_by! { |child| -child[:byte_start] }
       output = bytes.byteslice(start, length)
       children.each do |child|
-        descendants = nested.select { |candidate| encloses_decision?(child, candidate) }
-        child_text = render_decision(bytes, child, descendants)
+        descendants = encloses[child] || []
+        child_text = render_decision(bytes, child, descendants, encloses)
         offset = child[:byte_start] - start
         output[offset, child[:byte_length]] = child_text
       end
@@ -114,11 +122,11 @@ module Branchproof
       (outer[:kind] || "boolean") == "boolean" && inner[:kind] != "boolean" && !inner[:kind].nil?
     end
 
-    def render_decision(bytes, decision, nested)
+    def render_decision(bytes, decision, nested, encloses)
       if decision[:instrumentation]
-        render_flow(bytes, decision, nested)
+        render_flow(bytes, decision, nested, encloses)
       else
-        expression = render_range(bytes, decision[:byte_start], decision[:byte_length], decision, nested)
+        expression = render_range(bytes, decision, nested, encloses)
         frame(decision[:id], expression)
       end
     end
@@ -133,10 +141,13 @@ module Branchproof
         "#{RUNTIME}.leave(#{decision_id.inspect}); end; end)"
     end
 
+    # Mutates `bytes` in place: it is already a fresh copy made at the top of
+    # rewrite, so there is no need to copy it again before splicing edits in.
     def apply_edits(bytes, edits)
-      edits.sort_by { |edit| -edit[:start] }.each_with_object(bytes.dup) do |edit, output|
-        output[edit[:start]...edit[:finish]] = edit[:text]
+      edits.sort_by { |edit| -edit[:start] }.each do |edit|
+        bytes[edit[:start]...edit[:finish]] = edit[:text]
       end
+      bytes
     end
 
     def valid_range?(bytes, start, length)
@@ -153,8 +164,8 @@ module Branchproof
       start.is_a?(Integer) && length.is_a?(Integer) && start >= 0 && length >= 0
     end
 
-    def result(bytes, changed: false, diagnostics: [])
-      { bytes: bytes, changed: changed, diagnostics: diagnostics }.freeze
+    def result(bytes, changed: false, diagnostics: [], iseq: nil)
+      { bytes: bytes, changed: changed, diagnostics: diagnostics, iseq: iseq }.freeze
     end
 
     def diagnostic(code, message)

data/lib/branchproof/limits.rb

@@ -6,6 +6,7 @@ module Branchproof
     KEYS = %i[
       conditions_per_decision vectors_per_decision owner_associations_per_run
       tests_per_run exact_candidates exact_search_nodes constraint_search_states
+      max_conditions_for_decision_table decision_table_rules_per_decision
     ].freeze
     DEFAULTS = {
       conditions_per_decision: 64,
@@ -14,7 +15,9 @@ module Branchproof
       tests_per_run: 50_000,
       exact_candidates: 32,
       exact_search_nodes: 100_000,
-      constraint_search_states: 10_000
+      constraint_search_states: 10_000,
+      max_conditions_for_decision_table: 12,
+      decision_table_rules_per_decision: 4096
     }.freeze
 
     module_function

data/lib/branchproof/loader.rb

@@ -5,8 +5,6 @@ require "digest"
 module Branchproof
   # Owns the process-local CRuby compilation hook when the VM exposes it.
   class Loader
-    STATUS_KEYS = %i[status reason].freeze
-
     def initialize(inventory:, instrumenter:)
       @inventory = inventory
       @instrumenter = instrumenter
@@ -41,7 +39,7 @@ module Branchproof
     def load_iseq(path)
       return nil unless @installed
 
-      unit = @units[canonical(path)]
+      unit = @units[path] || @units[canonical(path)]
       return nil unless unit
 
       bytes = File.binread(path)
@@ -61,6 +59,8 @@ module Branchproof
         return nil
       end
 
+      return rewritten[:iseq] if reusable_iseq?(unit, rewritten)
+
       RubyVM::InstructionSequence.compile(
         rewritten[:bytes], unit[:real_path] || canonical(path), unit[:real_path] || canonical(path), 1,
         compile_options(unit)
@@ -108,13 +108,14 @@ module Branchproof
     end
 
     def preloaded_target?
-      @units.keys.any? { |path| $LOADED_FEATURES.any? { |feature| canonical(feature) == path } }
+      loaded = $LOADED_FEATURES.each_with_object(Set.new) { |feature, set| set << canonical(feature) }
+      @units.keys.any? { |path| loaded.include?(canonical(path)) }
     end
 
     def index_units(inventory)
       Array(inventory[:source_units]).each_with_object({}) do |unit, index|
-        path = unit[:absolute_path] || unit[:real_path]
-        index[canonical(path)] = unit if path
+        index[unit[:absolute_path]] = unit if unit[:absolute_path]
+        index[unit[:real_path]] = unit if unit[:real_path]
       end
     end
 
@@ -136,6 +137,17 @@ module Branchproof
       unit[:compile_options] || {}
     end
 
+    # The instrumenter already compiled the rewritten source once to validate it.
+    # Reuse that instruction sequence instead of compiling again, but only when
+    # it was built with the exact file/path/options this loader would use:
+    # real_path present and equal to absolute_path (so the instrumenter's file
+    # and path arguments match what we pass below), and no custom compile
+    # options (the instrumenter compiles without any).
+    def reusable_iseq?(unit, rewritten)
+      rewritten[:iseq] && compile_options(unit).empty? &&
+        unit[:real_path] && unit[:absolute_path] == unit[:real_path]
+    end
+
     def status(state, reason)
       { status: state.to_s, reason: reason&.to_s }.freeze
     end

data/lib/branchproof/minimizer.rb

@@ -140,15 +140,18 @@ module Branchproof
     end
 
     def greedy(ids, candidates, target)
+      positions = ids.each_with_index.to_h
       chosen = []
+      chosen_set = Set.new
       covered = Set.new
       until covered >= target
-        available = ids.reject { |candidate| chosen.include?(candidate) }
-        id = available.max_by { |candidate| [(candidates[candidate] - covered).length, -ids.index(candidate)] }
+        available = ids.reject { |candidate| chosen_set.include?(candidate) }
+        id = available.max_by { |candidate| [(candidates[candidate] - covered).length, -positions[candidate]] }
         break unless id
         break if (candidates[id] - covered).empty?
 
         chosen << id
+        chosen_set << id
         covered |= candidates[id]
       end
       chosen.sort.reverse_each do |candidate|
@@ -159,16 +162,20 @@ module Branchproof
       chosen.sort
     end
 
-    def result(objective, scope, target, selected, status, lower, visited, reasons, candidates = {})
-      necessary = candidates.keys.reject do |candidate|
-        others = candidates.reject { |key, _| key == candidate }.values.reduce(Set.new, :|)
-        covers?(others, target)
-      end
-      interchangeable = candidates.keys.select do |candidate|
-        candidates.fetch(candidate).intersect?(target) && candidates.reject do |key, _|
-          key == candidate
-        end.values.reduce(Set.new, :|) >= target
+    # For each target obligation, how many candidates cover it. An obligation
+    # covered by exactly one candidate makes that candidate irreplaceable.
+    def coverage_counts(candidates)
+      candidates.each_value.with_object(Hash.new(0)) do |signs, counts|
+        signs.each { |obligation| counts[obligation] += 1 }
       end
+    end
+
+    def result(objective, scope, target, selected, status, lower, visited, reasons, candidates = {})
+      counts = coverage_counts(candidates)
+      necessary = candidates.select { |_, signs| signs.any? { |obligation| counts[obligation] == 1 } }.keys
+      interchangeable = candidates.select do |_, signs|
+        !signs.empty? && signs.none? { |obligation| counts[obligation] == 1 }
+      end.keys
       { objective: objective, scope_decision_ids: scope,
         target_obligations: target.to_a.sort_by do |decision, index, sign|
           [decision.to_s, index.to_i, sign ? 1 : 0]
@@ -189,8 +196,6 @@ module Branchproof
       value&.to_i&.positive? ? value.to_i : default
     end
 
-    def covers?(set, target) = set >= target
-
     def value(vector, index) = (vector[:values] || vector["values"])[index]
     def id(record, key) = record[key].nil? ? record[key.to_s] : record[key]
     def records(record, key) = Array(id(record, key))

data/lib/branchproof/minitest_adapter.rb

@@ -13,10 +13,6 @@ module Branchproof
       @tests = {}
     end
 
-    def capabilities
-      { serial: true, phases: true }.freeze
-    end
-
     def run(test_files:, runner_args:, on_complete:, before_load: nil)
       raise ArgumentError, "test_files must be an Array" unless test_files.is_a?(Array)
       raise ArgumentError, "on_complete must respond to call" unless on_complete.respond_to?(:call)
@@ -158,12 +154,7 @@ module Branchproof
       record = @tests[test_id]
       return unless record
 
-      skipped = test.failures.any? do |failure|
-        (failure.respond_to?(:skipped?) && failure.skipped?) ||
-          (defined?(Minitest::Skip) && failure.respond_to?(:error) && failure.error.is_a?(Minitest::Skip)) ||
-          failure.class.name.to_s.include?("Skip")
-      end
-      record[:status] = if skipped
+      record[:status] = if test.skipped?
                           "skipped"
                         else
                           (test.failures.empty? ? "passed" : "failed")
@@ -182,17 +173,21 @@ module Branchproof
     end
 
     def test_id_for(test)
+      return test.instance_variable_get(:@branchproof_test_id) if test.instance_variable_defined?(:@branchproof_test_id)
+
       source = begin
         test.method(test.name).source_location
       rescue NameError
         nil
       end
-      if defined?(Branchproof::Records)
-        Branchproof::Records.id(adapter: "minitest", class_name: test.class.name, method_name: test.name,
-                                source: source)
-      else
-        "minitest:#{test.class}:#{test.name}:#{source}"
-      end
+      id = if defined?(Branchproof::Records)
+             Branchproof::Records.id(adapter: "minitest", class_name: test.class.name, method_name: test.name,
+                                     source: source)
+           else
+             "minitest:#{test.class}:#{test.name}:#{source}"
+           end
+      test.instance_variable_set(:@branchproof_test_id, id)
+      id
     end
 
     def register_test(test)

data/lib/branchproof/records.rb

@@ -43,6 +43,8 @@ module Branchproof
     end
 
     def deep_freeze(value)
+      return value if value.frozen?
+
       case value
       when Hash
         value.transform_values { |item| deep_freeze(item) }.freeze