rubocop-rspec_parity 2.0.0 → 2.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2bda6248c84f44ce1e039baac11b9e6b3075c3feb13bb4e06a9e804ff26436a6
-  data.tar.gz: ebc0e696c427bd033637609d7f1ad4aaa66c603a9ca1ed82adb09d2857c99161
+  metadata.gz: 888fb83446806d8a28fecfc45aaeef7c72183e95214cc9e12b63d3f98e0c746a
+  data.tar.gz: 56d460393929a8ca3e990cef75441f49fa0be2cf0c814e151ab911b0392e2162
 SHA512:
-  metadata.gz: 102aceedd06b6db82be97c0a45d95a57e22cb1b1ab7427875c6137f98dcfcc87b862cd2cc26dfc14d8f5604a24702166db12b6f94c1835f7e0395fd98082d556
-  data.tar.gz: ca83d65bb73322941c49160de66943b2e1c6c93f35db372ef8cb559e5ea2cf3bdf1d3cc31151e654c8d19b620ceb1f4ee2f6dbf5ef8a8213277bd243c7104111
+  metadata.gz: 4dbc71657523c23118ff2bd823991ceea9aa635b02f35e3da8324e3e0dafc851c263af485991e9897ebf4efbaffc15518099a1c6a2ed69c84b290968229e3d4a
+  data.tar.gz: ce9de4bb85bf234ea735755b65b28ba6021eb5fd99a054a483c18e4c82d67d37ab51454b77e7750a5aa15ba163eb62e243ac3478f7766ea0676ba7744e1b365d

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 ## [Unreleased]
 
+## [2.0.2] - 2026-06-18
+
+Fixed: `PublicMethodHasSpec` now treats a public class method and a public instance method that share a name (the service-object `def self.call` delegating to `def call`) as one logical method — a single `describe '.call'` or `describe '#call'` satisfies both instead of each requiring its own.
+Fixed: `PublicMethodHasSpec` offense message no longer repeats a describe alias (e.g. `describe '#call' or describe '.call' or describe '.call'`) when a configured alias collides with the flexible-prefix expansion.
+
+## [2.0.1] - 2026-06-18
+
+Fixed: `PublicMethodHasSpec` relaxed validation for single-public-method classes (e.g. service objects) no longer passes when the spec's only method-style `describe`/`context` covers a different method — if a method describe is present it must describe the actual public method.
+
 ## [2.0.0] - 2026-06-18
 
 Added: `SufficientContexts` now pinpoints which branch is untested — its message names one uncovered branch and the `# rspec_parity:covers <branch>` annotation to add, and the bundled `rspec-parity-cover` executable lists all of a method's gaps as paste-ready context stubs. Annotations are opt-in (new `CoversAnnotations` config key, default `true`).

data/README.md

@@ -249,7 +249,24 @@ context 'when staff' do # rspec_parity:covers user.staff?
 end
 ```
 
-Re-run and the message advances to the next uncovered branch. Annotations are opt-in and only ever raise coverage — they never create a new violation, and each one covers exactly one branch. A mistyped label is reported with a did-you-mean suggestion.
+Re-run and the message advances to the next uncovered branch. Annotations are opt-in and only ever raise coverage — they never create a new violation. A mistyped label is reported with a did-you-mean suggestion.
+
+Each annotation covers exactly one branch, and the normal expectation is one annotation per context — one context, one scenario, one branch. In rare cases a single context genuinely exercises several branches at once; you can then list more than one branch on it, either as separate comments or with a `;`-separated list:
+
+```ruby
+context 'when fully privileged' do
+  # rspec_parity:covers user.admin?
+  # rspec_parity:covers user.staff?
+  it { is_expected.to be_allowed }
+end
+
+# or, equivalently, on one line:
+context 'when fully privileged' do # rspec_parity:covers user.admin?; user.staff?
+  it { is_expected.to be_allowed }
+end
+```
+
+Reach for this only when the branches really are covered together — multiple annotations on a context that only tests one path inflate coverage and defeat the point of the check.
 
 Long conditions can push the comment past `Layout/LineLength`; exempt these comments rather than editing the label:
 

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

@@ -29,7 +29,7 @@ module RuboCop
           return if inside_inner_class?(node)
 
           instance_method = !inside_eigenclass?(node) && !inside_class_methods_block?(node)
-          flexible_prefix = instance_method && module_with_dual_access?(node)
+          flexible_prefix = (instance_method && module_with_dual_access?(node)) || dual_scope_method?(node)
           check_method_has_spec(node, instance_method: instance_method, flexible_prefix: flexible_prefix)
         end
 
@@ -38,7 +38,7 @@ module RuboCop
           return if EXCLUDED_HOOK_METHODS.include?(node.method_name.to_s)
           return if inside_inner_class?(node)
 
-          check_method_has_spec(node, instance_method: false)
+          check_method_has_spec(node, instance_method: false, flexible_prefix: dual_scope_method?(node))
         end
 
         private
@@ -151,6 +151,42 @@ module RuboCop
           node.each_ancestor.find { |n| n.class_type? || n.module_type? }
         end
 
+        # A class method and an instance method that share a name (the common
+        # service-object `def self.call` -> `new(...).call` plus the `def call`
+        # it delegates to) describe one logical operation. A single
+        # `describe '.call'` or `describe '#call'` should satisfy both, so we
+        # check the method with a flexible `#`/`.` prefix.
+        def dual_scope_method?(node)
+          class_node = find_class_or_module(node)
+          return false unless class_node&.body
+
+          instance_names, class_names = scope_method_names(class_node)
+          name = node.method_name
+          instance_names.include?(name) && class_names.include?(name)
+        end
+
+        def scope_method_names(class_node)
+          instance = []
+          klass = []
+          scope_children(class_node).each { |child| classify_scope_method(child, instance, klass) }
+          [instance, klass]
+        end
+
+        def classify_scope_method(child, instance, klass)
+          case child&.type
+          when :def then instance << child.method_name
+          when :defs then klass << child.method_name if child.children.first&.self_type?
+          when :sclass then collect_eigenclass_method_names(child, klass)
+          end
+        end
+
+        def collect_eigenclass_method_names(node, klass)
+          return unless node.children.first&.self_type? && node.body
+
+          body_children = node.body.begin_type? ? node.body.children : [node.body]
+          body_children.each { |child| klass << child.method_name if child.def_type? }
+        end
+
         def targeted_visibility(scope, method_name)
           return nil unless scope.body
 
@@ -219,8 +255,9 @@ module RuboCop
 
           # Check if relaxed validation applies
           if matches_skip_path? && count_public_methods(node) == 1
-            # For single-method classes in configured paths, just check for examples
-            return if spec_paths.any? { |spec_path| spec_has_examples?(spec_path, class_name) }
+            # For single-method classes in configured paths, the method describe is optional —
+            # but if one is present, it must describe the actual public method, not a private/random one.
+            return if relaxed_spec_valid?(spec_paths, class_name, method_name, instance_method, flexible_prefix)
           elsif spec_paths.any? do |sp|
                   spec_covers_method?(sp, method_name, instance_method, flexible_prefix: flexible_prefix)
                 end
@@ -233,6 +270,25 @@ module RuboCop
         end
         # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
 
+        # Relaxed validation for single-public-method classes in skip paths.
+        # Passes when the spec describes the class with examples AND either has no
+        # method-style describe/context block at all, or has one that covers the public method.
+        def relaxed_spec_valid?(spec_paths, class_name, method_name, instance_method, flexible_prefix)
+          return false unless spec_paths.any? { |sp| spec_has_examples?(sp, class_name) }
+          return true unless spec_paths.any? { |sp| spec_has_method_describe?(sp) }
+
+          spec_paths.any? do |sp|
+            spec_covers_method?(sp, method_name, instance_method, flexible_prefix: flexible_prefix)
+          end
+        end
+
+        # Detects a method-style block, e.g. describe '#foo' / context '.bar'
+        # (the char right after the quote is a `#` or `.` prefix), as opposed to a
+        # plain descriptive string or a class constant.
+        def spec_has_method_describe?(spec_path)
+          File.read(spec_path).match?(/(?:describe|context)\s+['"][#.][^'"]+['"]/)
+        end
+
         def spec_covers_method?(spec_path, method_name, instance_method, flexible_prefix: false)
           return true if method_tested_in_spec?(spec_path, method_name, instance_method)
           return true if flexible_prefix && method_tested_in_spec?(spec_path, method_name, !instance_method)
@@ -265,7 +321,7 @@ module RuboCop
               describes << "describe '#{alias_desc}'"
             end
           end
-          describes.join(" or ")
+          describes.uniq.join(" or ")
         end
 
         def prefixes_for(instance_method, flexible_prefix)

data/lib/rubocop/rspec_parity/version.rb

@@ -2,6 +2,6 @@
 
 module RuboCop
   module RSpecParity
-    VERSION = "2.0.0"
+    VERSION = "2.0.2"
   end
 end

metadata

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