rubocop-rspec_parity 1.5.0 → 1.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4c9e27c87b24c7df00daa4eb0a88c31644a7f9986b384d5c875d42bb8358d071
-  data.tar.gz: aaeab2c5bccca24e24c39250299235ec3a46950f48bee5181a575b2cf45ef683
+  metadata.gz: f70e06a85873dc993a895443df9bab8892de60d0cc75573ffdc6487245c09dcf
+  data.tar.gz: 7d8baed7d58b13d98fb7b7e14084c3c81dcb1905df3bacfc52772dcb65ba7dbd
 SHA512:
-  metadata.gz: 858ae886ee9a32d83cd0a8695f0e5d0acc8758af31802ef5fdfe3d4686860dc40991adfa29cacb5a24a4191a9d94011e531b35edccbc40b8300b83c2c46b2996
-  data.tar.gz: 7d1184d3ea750869fcf9d655865e3a1d7b93a3d30f2292bc8e57fbd6cb4166e8da9a8ee274c54ccb9d2f825039911b230ede34731be80f9ade8c98dd3a59e8df
+  metadata.gz: 66ae9ef49f40f4323af10a733c9c1eb6bbc7a49883b3f00619fda6610c22b035ca53aa9e6b259259df8c7a5cb49aded12d56e8b96082074036f4fd9dc960baf3
+  data.tar.gz: 18635158b5155856049fdbfd33aaeb732b013d729467f1aefd8751873f997411b78a4d1489fa692ef64b0030691a6141b8ab6c6ca28e95398ea5d87201d0b3e7

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 ## [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
+Updated: `SufficientContexts` violation message now explains that each branch needs one `context` or `it`, and that compound conditions like `a && b` need a scenario per operand
+
 ## [1.5.0] - 2026-05-21
 
 Added: `SufficientContexts` now inlines branches from private/protected helpers that are called from exactly one site in the same class (controlled by the new `TraceSingleUsePrivateMethods` config key, default `true`). Violation messages list the helpers whose branches were counted.

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

@@ -42,8 +42,9 @@ module RuboCop
         include DepartmentConfig
         include SpecFileFinder
 
-        MSG = "Method `%<method_name>s` has %<branches>d %<branch_word>s but only %<contexts>d %<context_word>s " \
-              "in spec. Add %<missing>d more %<missing_word>s to cover all branches."
+        MSG = "Method `%<method_name>s` has %<branches>d %<branch_word>s but the spec covers only " \
+              "%<contexts>d %<scenario_word>s. Add %<missing>d more %<missing_word>s " \
+              "(one `context` or `it` per branch; compound conditions like `a && b` need a scenario per operand)."
 
         TRACED_SUFFIX = " (including branches from: %<traced>s)"
 
@@ -59,6 +60,27 @@ module RuboCop
           /^autosave_/
         ].freeze
 
+        # 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)
@@ -80,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)
@@ -121,19 +144,19 @@ module RuboCop
                            branches: branches,
                            branch_word: pluralize("branch", branches),
                            contexts: contexts,
-                           context_word: pluralize("context", contexts),
+                           scenario_word: pluralize("scenario", contexts),
                            missing: missing,
-                           missing_word: pluralize("context", missing))
+                           missing_word: pluralize("scenario", missing))
           message += format(TRACED_SUFFIX, traced: traced_methods.join(", ")) if traced_methods.any?
           message
         end
 
         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)
@@ -159,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)
@@ -184,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
@@ -231,21 +301,38 @@ module RuboCop
 
         def count_contexts_for_method(spec_content, method_name)
           method_pattern = Regexp.escape(method_name)
-          context_count, has_examples, has_direct_examples = parse_spec_content(spec_content, method_pattern)
+          result = parse_spec_content(spec_content, method_pattern)
+
+          scenario_count(
+            result.context_count, result.example_count,
+            has_examples: result.has_examples, has_direct_examples: result.has_direct_examples
+          )
+        end
+
+        # A test scenario is the smaller unit between "a context block" and "an
+        # `it`/`example`". A single context whose examples each exercise a branch
+        # covers as many scenarios as it has examples, so the scenario count is
+        # the larger of the context-based count and the raw example count. Empty
+        # placeholder contexts (no examples) still count via the context-based
+        # path, so this never under-counts relative to the old behaviour.
+        def scenario_count(context_count, example_count, has_examples:, has_direct_examples:)
+          context_based =
+            if context_count.positive? && has_direct_examples
+              context_count + 1
+            elsif context_count.zero? && has_examples
+              1
+            else
+              context_count
+            end
 
-          if context_count.positive? && has_direct_examples
-            context_count + 1
-          elsif context_count.zero? && has_examples
-            1
-          else
-            context_count
-          end
+          [context_based, example_count].max
         end
 
         # rubocop:disable Metrics/MethodLength
         def parse_spec_content(spec_content, method_pattern) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
           in_method_block = false
           context_count = 0
+          example_count = 0
           has_examples = false
           has_direct_examples = false
           base_indent = 0
@@ -269,6 +356,7 @@ module RuboCop
                 context_count += 1
               elsif nested_example?(line)
                 has_examples = true
+                example_count += 1
                 child_indent ||= current_indent
                 has_direct_examples = true if current_indent == child_indent
               end
@@ -277,7 +365,7 @@ module RuboCop
             end
           end
 
-          [context_count, has_examples, has_direct_examples]
+          ParsedSpec.new(context_count, example_count, has_examples, has_direct_examples)
         end
         # rubocop:enable Metrics/MethodLength
 
@@ -307,7 +395,6 @@ module RuboCop
 
           case word
           when "branch" then "branches"
-          when "context" then "contexts"
           else "#{word}s"
           end
         end
@@ -447,6 +534,7 @@ module RuboCop
           # Count contexts/describes and examples at the top level (under class describe)
           base_indent = lines[describe_line_index].match(/^(\s*)/)[1].length
           context_count = 0
+          example_count = 0
           has_examples = false
           has_direct_examples = false
           child_indent = nil
@@ -462,18 +550,13 @@ module RuboCop
               context_count += 1
             elsif line.match?(/^\s*(?:it|example|specify)\s+/)
               has_examples = true
+              example_count += 1
               child_indent ||= indent
               has_direct_examples = true if indent == child_indent
             end
           end
 
-          if context_count.positive? && has_direct_examples
-            context_count + 1
-          elsif context_count.zero? && has_examples
-            1
-          else
-            context_count
-          end
+          scenario_count(context_count, example_count, has_examples:, has_direct_examples:)
         end
         # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
       end

data/lib/rubocop/rspec_parity/version.rb

@@ -2,6 +2,6 @@
 
 module RuboCop
   module RSpecParity
-    VERSION = "1.5.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.5.0
+  version: 1.7.0
 platform: ruby
 authors:
 - Povilas Jurcys