branchproof 0.11.0 → 0.12.0

data/lib/branchproof/fallback_runtime.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Branchproof
+  # Records which operand of a fallback chain supplied the value. Only truthy
+  # operands are recorded; `||` itself decides whether evaluation continues.
+  module FallbackRuntime
+    def fallback_operand(decision_id, index, implicit, value)
+      return value unless value
+
+      implicit ? flow_path(decision_id, index) : flow_select(decision_id, index)
+      value
+    end
+  end
+end

data/lib/branchproof/fallback_syntax.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Branchproof
+  # A value-context `||` chain that ends in an always-truthy literal returns
+  # the first truthy operand and is never false. It is inventoried as
+  # alternatives (which operand supplied the value), not as a Boolean decision.
+  module FallbackSyntax
+    # A jump never supplies a value, so it cannot be a fallback operand.
+    JUMP_NODES = [Prism::ReturnNode, Prism::BreakNode, Prism::NextNode, Prism::RedoNode,
+                  Prism::RetryNode].freeze
+    private_constant :JUMP_NODES
+
+    private
+
+    def fallback_chain?(node)
+      return false unless symbolic_or?(node)
+
+      operands = fallback_operands(node)
+      last = operands.last
+      literal_truth(last) == true && !last.is_a?(Prism::TrueNode) &&
+        operands[0...-1].none? do |operand|
+          logical_operand?(operand) || jump_operand?(operand) || contextual_operand?(operand)
+        end
+    end
+
+    # Only reached for OrNodes already gated by fallback_chain? in Source#decisions_for phase two.
+    # rubocop:disable-next Metrics/AbcSize -- alternative/instrumentation assembly mirrors DecisionSyntax#flow_details.
+    def flow_details(node, bytes, encoding)
+      return super unless node.is_a?(Prism::OrNode)
+
+      operands = fallback_operands(node)
+      alternatives = operands.map do |operand|
+        location = operand.location
+        { expression: text_value(bytes.byteslice(location.start_offset, location.length), encoding),
+          byte_start: location.start_offset, byte_length: location.length }
+      end
+      instrumentation = { type: "fallback", operands: operands.map { |operand| byte_range(operand.location) } }
+      kind = operands.length == 2 ? "implicit" : "multiway"
+      [kind, "fallback", alternatives, instrumentation, unsupported_reasons(node, bytes)]
+    end
+
+    # `a || b || c` parses as `(a || b) || c`, so the chain grows to the left.
+    def fallback_operands(node)
+      operands = []
+      loop do
+        operands << node.right
+        node = node.left
+        break unless symbolic_or?(node)
+      end
+      operands << node
+      operands.reverse!
+    end
+
+    def symbolic_or?(node)
+      node.is_a?(Prism::OrNode) && node.operator_loc.slice == "||"
+    end
+
+    def logical_operand?(operand)
+      operand = unwrap_predicate(operand)
+      boolean_node?(operand) || unary_not?(operand)
+    end
+
+    def jump_operand?(operand)
+      tail = tail_statement(operand)
+      JUMP_NODES.any? { |type| tail.is_a?(type) }
+    end
+
+    def contextual_operand?(operand)
+      operand = unwrap_predicate(operand)
+      operand.is_a?(Prism::MatchLastLineNode) || operand.is_a?(Prism::InterpolatedMatchLastLineNode) ||
+        operand.is_a?(Prism::FlipFlopNode)
+    end
+
+    # A `(...)` or `begin...end` operand evaluates to its last statement, so a
+    # trailing jump there ends the operand too. Only the last statement
+    # matters: an earlier jump would already end evaluation inside its own
+    # construct (such as `if`), which is fine as an operand.
+    def tail_statement(node)
+      loop do
+        body = case node
+               when Prism::ParenthesesNode then node.body&.body
+               when Prism::BeginNode then node.statements&.body
+               end
+        return node if body.nil? || body.empty?
+
+        node = body.last
+      end
+    end
+  end
+end

data/lib/branchproof/focused_report.rb

@@ -14,7 +14,7 @@ module Branchproof
                    selection: nil)
       @document = document || {}
       @view = view.to_sym
-      unless (Report::VIEWS - [:decisions]).include?(@view)
+      unless (Report::VIEWS - %i[decisions summary]).include?(@view)
         raise ArgumentError, "view must be :conditions, :tests, or :decision_tables"
       end
 
@@ -27,7 +27,8 @@ module Branchproof
         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
+      @matching_decision_ids = @selection.decision_filter_active? ? @selection.selected_decision_ids(@document) : nil
+      @matching_decision_id_set = @matching_decision_ids&.to_h { |id| [id, true] }
     end
 
     def render
@@ -51,8 +52,11 @@ module Branchproof
       lines << "Empty groups mean no recorded completed observation."
       lines << ""
       render_focus_notice(lines)
+      lines << "Whole-run coverage and policy:" if @selection.decision_ids
       lines.concat(@coordinator.coverage_ladder_lines)
       lines.concat(@coordinator.coverage_policy_lines)
+      lines.concat(@coordinator.changed_scope_lines) if @selection.decision_ids
+      lines.concat(@coordinator.collation_lines)
       case @view
       when :conditions
         render_conditions(lines)
@@ -64,7 +68,8 @@ module Branchproof
       render_unowned(lines)
       render_unsupported(lines)
       Array(fetch(@document, :diagnostics)).each do |diagnostic|
-        lines << "Diagnostic: #{@coordinator.diagnostic_message(diagnostic)}"
+        prefix = @selection.decision_ids ? "Run-wide diagnostic" : "Diagnostic"
+        lines << "#{prefix}: #{@coordinator.diagnostic_message(diagnostic)}"
       end
       lines.join("\n") << "\n"
     end
@@ -94,7 +99,8 @@ module Branchproof
         render_group(lines, "Short-circuited in", row[:short_circuited], row)
         lines << "  Unattributed observations: #{row[:unattributed]}" if row[:unattributed].to_i.positive?
         if @level >= 2 && row[:supporting_set].any?
-          lines << "  Supporting test set: #{row[:supporting_set].map { |id| test_label(id) }.join(", ")}"
+          heading = @selection.decision_ids ? "Whole-run supporting test set" : "Supporting test set"
+          lines << "  #{heading}: #{row[:supporting_set].map { |id| test_label(id) }.join(", ")}"
           lines << "  Tests outside this MC/DC evidence set may provide other coverage."
         end
         render_constraint(lines, row) if @level >= 3 && row[:constraint_result]
@@ -112,7 +118,9 @@ module Branchproof
         end
         lines << ""
       end
-      lines << "No missing conditions" if @missing_only && rows.empty? && focus_match_exists?
+      lines << "No missing conditions" if @missing_only && rows.empty? && focus_match_exists? &&
+                                          !empty_changed_scope? &&
+                                          (!@selection.decision_ids || @coordinator.changed_coverage_available?)
       render_alternatives(lines, alternatives)
     end
 
@@ -142,7 +150,11 @@ module Branchproof
       rows, hidden = limit_rows(all_rows)
       append_limit_summary(lines, hidden, "decision")
       rendered = 0
-      impossible = @index.decision_tables.sum { |row| row[:impossible_rules].to_i }
+      impossible = if @selection.decision_filter_active?
+                     all_rows.sum { |row| row[:impossible_rules].to_i }
+                   else
+                     @index.decision_tables.sum { |row| row[:impossible_rules].to_i }
+                   end
       rows.each do |row|
         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"
@@ -163,7 +175,10 @@ module Branchproof
         rules.each { |rule| render_decision_table_rule(lines, row, rule) }
         lines << ""
       end
-      lines << "No missing decision-table rules" if @missing_only && rendered.zero?
+      lines << "No missing decision-table rules" if @missing_only && rendered.zero? && focus_match_exists? &&
+                                                    !empty_changed_scope? &&
+                                                    (!@selection.decision_ids ||
+                                                     @coordinator.changed_coverage_available?)
       return unless impossible.positive?
 
       lines << "#{impossible} statically impossible rule#{"s" unless impossible == 1} excluded"
@@ -213,7 +228,9 @@ module Branchproof
         end
         lines << ""
       end
-      lines << "No missing alternatives" if @missing_only && rows.empty? && focus_match_exists?
+      lines << "No missing alternatives" if @missing_only && rows.empty? && focus_match_exists? &&
+                                            !empty_changed_scope? &&
+                                            (!@selection.decision_ids || @coordinator.changed_coverage_available?)
     end
 
     def render_alternative_group(lines, heading, evidence)
@@ -340,10 +357,16 @@ module Branchproof
     def render_focus_notice(lines)
       return unless @selection.focus_active?
 
+      focus_label = if @selection.decision_ids
+                      @coordinator.display_scope_path(@selection.focus_label)
+                    else
+                      @selection.focus_label
+                    end
+      no_match = @selection.decision_ids ? "no matching changed decisions" : "no matching decisions"
       lines << if @matching_decision_ids.empty?
-                 "Focus: no matching decisions for #{@selection.focus_label}"
+                 "Focus: #{no_match} for #{focus_label}"
                else
-                 "Focus: #{@selection.focus_label}"
+                 "Focus: #{focus_label}"
                end
     end
 
@@ -360,9 +383,17 @@ module Branchproof
       !@selection.focus_active? || !@matching_decision_ids.empty?
     end
 
+    def empty_changed_scope?
+      @selection.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?
+      if @selection.decision_filter_active?
+        rows = rows.select do |row|
+          @matching_decision_id_set.key?(row[:decision_id].to_s)
+        end
+      end
       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,
@@ -372,7 +403,11 @@ module Branchproof
 
     def filtered_alternatives
       rows = @index.alternatives
-      rows = rows.select { |row| @matching_decision_ids.include?(row[:decision_id].to_s) } if @selection.focus_active?
+      if @selection.decision_filter_active?
+        rows = rows.select do |row|
+          @matching_decision_id_set.key?(row[:decision_id].to_s)
+        end
+      end
       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,
@@ -397,7 +432,11 @@ module Branchproof
 
     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?
+      if @selection.decision_filter_active?
+        rows = rows.select do |row|
+          @matching_decision_id_set.key?(row[:decision_id].to_s)
+        end
+      end
       rows = rows.select do |row|
         !@missing_only || row[:status].to_s != "calculated" || row[:rules].any? do |rule|
           rule[:coverage].to_s == "missing"
@@ -410,15 +449,12 @@ module Branchproof
       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 }
+      if @selection.decision_filter_active?
+        ids = selected_observation_ids
         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)
+            ids[:conditions].key?(observation[:condition_id].to_s) ||
+              ids[:alternatives].key?(observation[:alternative_id].to_s)
           end
         end
       end
@@ -430,15 +466,38 @@ module Branchproof
     end
 
     def test_observations(row, missing_ids, missing_alternative_ids)
-      return row[:observations] unless @missing_only
+      observations = row[:observations]
+      if @selection.decision_ids
+        ids = selected_observation_ids
+        observations = observations.select do |observation|
+          ids[:conditions].key?(observation[:condition_id].to_s) ||
+            ids[:alternatives].key?(observation[:alternative_id].to_s)
+        end
+      end
+      return observations unless @missing_only
 
-      row[:observations].select do |observation|
+      observations.select do |observation|
         missing_ids.include?(observation[:condition_id]) ||
           missing_alternative_ids.include?(observation[:alternative_id])
       end
     end
 
+    def selected_observation_ids
+      @selected_observation_ids ||= begin
+        conditions = {}
+        alternatives = {}
+        @index.conditions.each do |row|
+          conditions[row[:id].to_s] = true if @matching_decision_id_set.key?(row[:decision_id].to_s)
+        end
+        @index.alternatives.each do |row|
+          alternatives[row[:alternative_id].to_s] = true if @matching_decision_id_set.key?(row[:decision_id].to_s)
+        end
+        { conditions: conditions, alternatives: alternatives }
+      end
+    end
+
     def location(path, line, unavailable: "location unavailable")
+      path = @coordinator.display_scope_path(path) if @selection.decision_ids
       return "location unavailable" if path.to_s.empty?
       return "#{path}: #{unavailable}" if line.nil?
 

data/lib/branchproof/git_changes.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+require "open3"
+require "pathname"
+
+module Branchproof
+  # Reads the tracked working-tree delta from a validated commit to the current
+  # index and worktree. Untracked files are intentionally outside this scope.
+  # rubocop:disable-next Metrics/ClassLength -- Git capture phases share one validated process context.
+  class GitChanges
+    def initialize(root:, ref:)
+      raise ArgumentError, "root must be an absolute path" unless root.is_a?(String) && Pathname.new(root).absolute?
+      raise ArgumentError, "ref must be a non-empty String" unless ref.is_a?(String) && !ref.empty?
+
+      @root = File.realpath(root)
+      @ref = ref
+    rescue SystemCallError => e
+      raise ArgumentError, "project root is unavailable: #{e.message}"
+    end
+
+    # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength -- Capture order is security-sensitive.
+    def call(include_patch_lines: false)
+      git_root = git_text("rev-parse", "--show-toplevel").strip
+      git_root = File.realpath(git_root)
+      project_prefix = relative_prefix(git_root, @root)
+      base = git_text("rev-parse", "--verify", "--end-of-options", "#{@ref}^{commit}").strip
+      unless base.match?(/\A(?:[0-9a-f]{40}|[0-9a-f]{64})\z/i)
+        raise ArgumentError, "Git did not resolve ref #{@ref.inspect} to a commit"
+      end
+
+      reject_unmerged_index!
+
+      files = name_status(base).filter_map do |entry|
+        project_entry(entry, git_root, project_prefix, base, include_patch_lines)
+      end
+      unless include_patch_lines
+        files = files.map do |file|
+          file.merge(hunks: file[:hunks].map { |hunk| hunk.slice(:old_start, :old_count, :new_start, :new_count) })
+        end
+      end
+      Records.build(version: "1.0", requested_ref: @ref, base_commit: base,
+                    comparison: "tracked_worktree", untracked: "excluded",
+                    status: files.empty? ? "empty" : "complete", files: files)
+    rescue ArgumentError
+      raise
+    rescue StandardError => e
+      raise ArgumentError, "cannot compare Git changes: #{e.message}"
+    end
+
+    private
+
+    def git_text(*arguments)
+      output, status = Open3.capture2e("git", *arguments, chdir: @root)
+      return output if status.success?
+
+      detail = output.strip
+      if arguments.first == "rev-parse" && arguments.include?("--show-toplevel")
+        raise git_error("project root is not inside a Git repository", detail)
+      end
+      if arguments.first == "rev-parse"
+        raise git_error("invalid or unresolved Git commit reference #{@ref.inspect}", detail)
+      end
+
+      raise git_error("Git command failed", detail)
+    end
+
+    def git_error(message, detail)
+      ArgumentError.new(detail.empty? ? message : "#{message}: #{detail}")
+    end
+
+    def relative_prefix(git_root, project_root)
+      prefix = Pathname.new(project_root).relative_path_from(Pathname.new(git_root)).to_s
+      return "" if prefix == "."
+      return prefix if prefix != ".." && !prefix.start_with?("../")
+
+      raise ArgumentError, "project root must be inside its Git repository"
+    end
+
+    def reject_unmerged_index!
+      output, status = Open3.capture2("git", "ls-files", "-u", "-z", chdir: @root)
+      raise ArgumentError, "cannot inspect Git index for merge conflicts" unless status.success?
+      return if output.empty?
+
+      raise ArgumentError,
+            "cannot compare changes while the Git index has unresolved merge entries"
+    end
+
+    # rubocop:disable-next Metrics/AbcSize, Metrics/MethodLength -- Parses Git's NUL-delimited rename protocol.
+    def name_status(base)
+      output = git_text("diff", "--no-ext-diff", "--no-textconv", "--no-color", "--name-status", "-z",
+                        "--find-renames", base, "--")
+      fields = output.split("\0", -1)
+      entries = []
+      index = 0
+      while index < fields.length - 1
+        status = fields[index]
+        index += 1
+        if status.start_with?("R", "C")
+          old_path, new_path = fields[index, 2]
+          index += 2
+          entries << { status: status, old_path: safe_path(old_path), path: safe_path(new_path) }
+        else
+          path = fields[index]
+          index += 1
+          entries << { status: status, path: safe_path(path) }
+        end
+      end
+      entries
+    end
+
+    def safe_path(path)
+      path = path.dup.force_encoding(Encoding::UTF_8)
+      raise ArgumentError, "Git reported a path that is not valid UTF-8" unless path.valid_encoding?
+      raise ArgumentError, "Git reported an unsafe path" if path.empty? || path.include?("\0") || path.start_with?("/")
+
+      segments = path.split("/")
+      raise ArgumentError, "Git reported an unsafe path" if segments.include?("..") || segments.include?(".")
+
+      path
+    end
+
+    # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity -- Handles project-boundary rename cases.
+    def project_entry(entry, git_root, project_prefix, base, include_patch_lines)
+      current_git_path = entry[:path]
+      old_git_path = entry[:old_path]
+      current_relative = within_project(current_git_path, project_prefix)
+      old_relative = old_git_path && within_project(old_git_path, project_prefix)
+      return if current_relative.nil? && old_relative.nil?
+
+      # A rename crossing the project boundary is represented only when one
+      # side belongs to this project; current paths remain the selection key.
+      path = current_relative || old_relative
+      old_path = old_relative if old_git_path && current_relative && old_relative != current_relative
+      diff_path = current_git_path || old_git_path
+      hunks = patch_hunks(base, diff_path, git_root)
+      base_path = old_git_path || current_git_path unless entry[:status] == "A"
+      old_bytes = git_blob(base, base_path, git_root) if include_patch_lines && base_path
+      status = if entry[:status].start_with?("R", "C") && current_relative.nil?
+                 "D"
+               elsif entry[:status].start_with?("R", "C") && old_relative.nil?
+                 "A"
+               else
+                 entry[:status]
+               end
+      { status: status, path: path, old_path: old_path, hunks: hunks, old_bytes: old_bytes }.compact
+    end
+
+    def within_project(path, prefix)
+      return path if prefix.empty?
+      return if path == prefix
+      return path.delete_prefix("#{prefix}/") if path.start_with?("#{prefix}/")
+
+      nil
+    end
+
+    # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity -- Collects patch boundaries and line context together.
+    def patch_hunks(base, path, git_root)
+      literal_path = ":(literal)#{path}"
+      output, status = Open3.capture2("git", "diff", "--no-ext-diff", "--no-textconv", "--no-color", "--unified=0",
+                                      base, "--", literal_path, chdir: git_root)
+      raise ArgumentError, "cannot read Git patch for #{path.inspect}" unless status.success?
+
+      hunks = []
+      current = nil
+      output.each_line do |line|
+        match = line.match(/\A@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/)
+        if match
+          current = { old_start: match[1].to_i, old_count: (match[2] || "1").to_i,
+                      new_start: match[3].to_i, new_count: (match[4] || "1").to_i,
+                      old_lines: [], new_lines: [] }
+          hunks << current
+        elsif current && line.start_with?("-") && !line.start_with?("---")
+          current[:old_lines] << line.delete_prefix("-").delete_suffix("\n")
+        elsif current && line.start_with?("+") && !line.start_with?("+++")
+          current[:new_lines] << line.delete_prefix("+").delete_suffix("\n")
+        end
+      end
+      hunks
+    end
+
+    def git_blob(base, path, git_root)
+      output, status = Open3.capture2("git", "cat-file", "blob", "#{base}:#{path}", chdir: git_root)
+      raise ArgumentError, "cannot read base content for #{path.inspect}" unless status.success?
+
+      output
+    end
+  end
+end