rubocop-rspec_parity 1.6.0 → 1.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2fc4286fcc69b46b490ae21db9ce9681ca7dd25577521e329d0bc3d89b33940a
-  data.tar.gz: da7872a16a143f8d44a178c7b1912996c8d5213fb1538a8f4231e9ceedf361dc
+  metadata.gz: f70e06a85873dc993a895443df9bab8892de60d0cc75573ffdc6487245c09dcf
+  data.tar.gz: 7d8baed7d58b13d98fb7b7e14084c3c81dcb1905df3bacfc52772dcb65ba7dbd
 SHA512:
-  metadata.gz: 3d9f782158d6c053256401c6b687eb8b22dd1780f444b42783609b428ea0f82898a33e5c502818df86be8e56847a7be8012a99ead9c3aaffe91e5420d7be5a66
-  data.tar.gz: 44b7a03a46444bcacbec096e659fd435dc288278ba1f14d72d87311d1bca1b4feb32643c68c6fcb3ff2fbb5be1118adddddb8e4ec164b4d710cc00efbb287bc5
+  metadata.gz: 66ae9ef49f40f4323af10a733c9c1eb6bbc7a49883b3f00619fda6610c22b035ca53aa9e6b259259df8c7a5cb49aded12d56e8b96082074036f4fd9dc960baf3
+  data.tar.gz: 18635158b5155856049fdbfd33aaeb732b013d729467f1aefd8751873f997411b78a4d1489fa692ef64b0030691a6141b8ab6c6ca28e95398ea5d87201d0b3e7

data/CHANGELOG.md

@@ -1,5 +1,9 @@
 ## [Unreleased]
 
+## [1.7.0] - 2026-06-11
+
+Fixed: `SufficientContexts` no longer over-counts chains of guard clauses (`return`/`raise`/`next ... if/unless`). A sequence of guards shares a single "all guards pass" fall-through, so that happy path is counted once for the whole method instead of once per guard. Each `&&`/`||` inside a guard condition is still counted as a distinct way for the guard to fire (one scenario per operand).
+
 ## [1.6.0] - 2026-06-11
 
 Fixed: `SufficientContexts` now counts each `it`/`example` within a single context as a separate scenario, so specs that cover branches with multiple examples (instead of separate contexts) no longer trigger false violations

data/lib/rubocop/cop/rspec_parity/private_method_call_graph.rb

@@ -8,7 +8,9 @@ module RuboCop
       # private/protected helpers that are called from exactly one place in
       # the same container.
       class PrivateMethodCallGraph # rubocop:disable Metrics/ClassLength
-        Result = Struct.new(:branches, :traced_methods)
+        # `branch_tally` is whatever the branch_counter returns (a BranchTally),
+        # or nil when nothing was inlined. It must respond to `+` and `total`.
+        Result = Struct.new(:branch_tally, :traced_methods)
 
         DYNAMIC_DISPATCH_SENDS = %i[send public_send __send__].freeze
         EVAL_METHODS = %i[class_eval instance_eval module_eval].freeze
@@ -28,13 +30,13 @@ module RuboCop
         end
 
         def inlinable_from(method_node, branch_counter)
-          return Result.new(0, []) unless @container
-          return Result.new(0, []) if dynamic_dispatch?
+          return Result.new(nil, []) unless @container
+          return Result.new(nil, []) if dynamic_dispatch?
 
           build! unless @built
 
           key = key_for(method_node)
-          return Result.new(0, []) unless @methods.key?(key)
+          return Result.new(nil, []) unless @methods.key?(key)
 
           traverse(key, branch_counter)
         end
@@ -42,7 +44,7 @@ module RuboCop
         private
 
         def traverse(start_key, branch_counter)
-          state = { visited: Set.new([start_key]), total: 0, traced: [] }
+          state = { visited: Set.new([start_key]), tally: nil, traced: [] }
           stack = callees_of(start_key)
           until stack.empty?
             key = stack.shift
@@ -51,7 +53,7 @@ module RuboCop
             visit_callee(key, branch_counter, state)
             stack.concat(callees_of(key))
           end
-          Result.new(state[:total], sorted_names(state[:traced]))
+          Result.new(state[:tally], sorted_names(state[:traced]))
         end
 
         def callees_of(key)
@@ -60,10 +62,10 @@ module RuboCop
 
         def visit_callee(key, branch_counter, state)
           state[:visited] << key
-          count = branch_counter.call(@methods[key][:node])
-          return unless count.positive?
+          tally = branch_counter.call(@methods[key][:node])
+          return unless tally.total.positive?
 
-          state[:total] += count
+          state[:tally] = state[:tally] ? state[:tally] + tally : tally
           state[:traced] << key
         end
 

data/lib/rubocop/cop/rspec_parity/sufficient_contexts.rb

@@ -63,6 +63,24 @@ module RuboCop
         # Tallies extracted from a spec's text for a single method describe block.
         ParsedSpec = Struct.new(:context_count, :example_count, :has_examples, :has_direct_examples)
 
+        # Branch tally split into guard-clause "fire" branches vs. every other
+        # branch. A sequence of guard clauses (`return/raise/next ... if/unless`)
+        # shares a single "all guards pass" fall-through, so that happy path is
+        # counted once for the whole method (see #branches_from) rather than once
+        # per guard — which previously inflated guard-heavy methods.
+        BranchTally = Struct.new(:guard, :regular) do
+          def +(other)
+            BranchTally.new(guard + other.guard, regular + other.regular)
+          end
+
+          def total
+            guard + regular
+          end
+        end
+
+        # Node types whose presence as a one-armed `if` body makes it a guard clause.
+        GUARD_TERMINATOR_TYPES = %i[return break next redo retry].freeze
+
         def initialize(config = nil, options = nil)
           super
           @ignore_memoization = cop_config.fetch("IgnoreMemoization", true)
@@ -84,13 +102,14 @@ module RuboCop
           return unless in_covered_directory?
           return if excluded_method?(method_name(node))
 
-          branches = count_branches(node)
+          tally = branch_tally(node)
           traced_methods = []
           if @trace_single_use_private
             extra = inlined_branches(node)
-            branches += extra.branches
+            tally += extra.branch_tally if extra.branch_tally
             traced_methods = extra.traced_methods
           end
+          branches = branches_from(tally)
           return if branches < 2 # Only check methods with branches
 
           class_name = extract_class_name(node)
@@ -134,10 +153,10 @@ module RuboCop
 
         def inlined_branches(node)
           container = find_class_or_module(node)
-          return PrivateMethodCallGraph::Result.new(0, []) unless container
+          return PrivateMethodCallGraph::Result.new(nil, []) unless container
 
           graph = (@call_graphs[container] ||= PrivateMethodCallGraph.new(container))
-          graph.inlinable_from(node, method(:count_branches))
+          graph.inlinable_from(node, method(:branch_tally))
         end
 
         def method_name(node)
@@ -163,17 +182,75 @@ module RuboCop
           processed_source.path
         end
 
-        def count_branches(node)
-          branches = 0
+        # Total scenario count from a tally. Guard clauses share one "all guards
+        # pass" fall-through; count it once, but only when guards are the sole
+        # branching — otherwise the happy path is already represented by the
+        # other branches and adding it would over-count.
+        def branches_from(tally)
+          total = tally.total
+          total += 1 if tally.guard.positive? && tally.regular.zero?
+          total
+        end
+
+        def branch_tally(node) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
+          guard = 0
+          regular = 0
           elsif_nodes = collect_elsif_nodes(node)
+          guard_operators = collect_guard_condition_operators(node)
 
           node.each_descendant do |descendant|
             next if elsif_nodes.include?(descendant)
             next if should_skip_node?(descendant)
 
-            branches += branch_count_for_node(descendant)
+            case descendant.type
+            when :if
+              guard_clause?(descendant) ? guard += 1 : regular += count_if_branches(descendant)
+            when :case then regular += count_case_branches(descendant)
+            when :and, :or then guard_operators.include?(descendant) ? guard += 1 : regular += 1
+            when :or_asgn, :and_asgn then regular += 2 # ||= and &&= create 2 branches (set vs already set)
+            when :send then regular += send_node_branch_count(descendant)
+            end
           end
-          branches
+
+          BranchTally.new(guard, regular)
+        end
+
+        # A guard clause is a one-armed `if`/`unless` whose single body exits the
+        # method early (`return`/`raise`/`next`/`break`/...). Its non-exit path is
+        # the shared fall-through, so it is not a branch of its own.
+        def guard_clause?(node)
+          return false unless node.if_type?
+
+          present = [node.if_branch, node.else_branch].compact
+          return false unless present.size == 1
+
+          guard_terminator?(present.first)
+        end
+
+        def guard_terminator?(node)
+          return false unless node
+          return true if GUARD_TERMINATOR_TYPES.include?(node.type)
+          return true if node.send_type? && (node.method?(:raise) || node.method?(:throw))
+          return guard_terminator?(node.children.last) if node.begin_type?
+
+          false
+        end
+
+        # The `&&`/`||` nodes that live inside a guard clause's condition. Each
+        # such operator is a distinct way for the guard to fire (one scenario per
+        # operand), so it counts as a guard branch rather than an "other" branch.
+        def collect_guard_condition_operators(node)
+          operators = Set.new
+          node.each_descendant(:if) do |if_node|
+            next unless guard_clause?(if_node)
+
+            condition = if_node.condition
+            next unless condition
+
+            operators.add(condition) if condition.and_type? || condition.or_type?
+            condition.each_descendant(:and, :or) { |op| operators.add(op) }
+          end
+          operators
         end
 
         def collect_elsif_nodes(node)
@@ -188,17 +265,6 @@ module RuboCop
           @ignore_memoization && memoization_pattern?(node)
         end
 
-        def branch_count_for_node(node)
-          case node.type
-          when :if then count_if_branches(node)
-          when :case then count_case_branches(node)
-          when :and, :or then 1
-          when :or_asgn, :and_asgn then 2 # ||= and &&= create 2 branches (set vs already set)
-          when :send then send_node_branch_count(node)
-          else 0
-          end
-        end
-
         def send_node_branch_count(node)
           node.method?(:&) || node.method?(:|) ? 1 : 0
         end

data/lib/rubocop/rspec_parity/version.rb

@@ -2,6 +2,6 @@
 
 module RuboCop
   module RSpecParity
-    VERSION = "1.6.0"
+    VERSION = "1.7.0"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-rspec_parity
 version: !ruby/object:Gem::Version
-  version: 1.6.0
+  version: 1.7.0
 platform: ruby
 authors:
 - Povilas Jurcys