rubocop-rspec_parity 1.4.4 → 1.4.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6f0344e2a2bf2511a1bc8739c4ccf449a59526efde141ea4d9209c07b1330be1
-  data.tar.gz: a5432ea9890d24e15815ddc8cdfcae8762cdd65b0de0ba9a77ab876d5cc20e53
+  metadata.gz: a1801f19d786c13a744e801e1ddcfaab61d6c690a4a98868600b18181fbaedab
+  data.tar.gz: 465d0ff6d064d1f8c65b6c8e8af60336ad78d75d21204228ebe4c4049c3e6bf2
 SHA512:
-  metadata.gz: 85859f89d3a1703a93be6165112cf703a3fbbaf76b32ac0a5b813a6cc585f7351786e58e476a6cb06a4ac70f4576107ebc1914b09dddece59c418c862b2fbc07
-  data.tar.gz: 62ed3e43cd3a38c9e71beb8e4f69b4800136102d878820eb2f5e679efa9a1dd01e2f11ba1a1f49d7a427d9f0c707fabb887249aa25e72221f37d2cfd98e8e46b
+  metadata.gz: 748e44075554a6f07b71992264df4a36a00c50fb5c4e53775d8668e911d3e5d8243de1b81d539fcf29896c8e24cd09b5dce3508b3736c6ac1878e4e404adf11c
+  data.tar.gz: 29f5dff55dc313461b945e26c73c6f4a81d72a41ff3de9721a830440536f770b6f3ed15ff0f65029126db8de933c33650244eb2cbba0bc7d5b83e96ee66755a2

data/CHANGELOG.md

@@ -1,5 +1,9 @@
 ## [Unreleased]
 
+## [1.4.5] - 2026-03-27
+
+Added: Allow both `#method` and `.method` notation in specs for modules using `extend self`, `module_function`, or `module_function :method_name`
+
 ## [1.4.4] - 2026-03-18
 
 Removed: Hardcoded directory lists in `PublicMethodHasSpec` and `SufficientContexts` cops; file selection now relies entirely on department-level `Include`/`Exclude` config

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

@@ -6,7 +6,7 @@ module RuboCop
       # Shared module for reading department-level configuration.
       # Provides config resolution (cop-level > department-level > default),
       # spec file path mappings, and shared describe aliases / skip paths.
-      module DepartmentConfig
+      module DepartmentConfig # rubocop:disable Metrics/ModuleLength
         SHARED_CONFIG_DEFAULTS = {
           "SpecFilePathMappings" => { "app/" => ["spec/"] },
           "DescribeAliases" => {},
@@ -98,6 +98,52 @@ module RuboCop
           end
           nil
         end
+
+        # Detects if a method is inside a module that makes instance methods
+        # callable as module-level methods (e.g., extend self, module_function).
+        def module_with_dual_access?(node)
+          enclosing = find_class_or_module(node)
+          return false unless enclosing&.module_type?
+
+          extend_self?(enclosing) || module_function_applies?(enclosing, node)
+        end
+
+        def extend_self?(module_node)
+          return false unless module_node.body
+
+          module_body_children(module_node).any? do |child|
+            child.send_type? && child.method_name == :extend && child.arguments.size == 1 &&
+              child.first_argument.self_type?
+          end
+        end
+
+        def module_function_applies?(module_node, target_node)
+          return false unless module_node.body
+
+          children = module_body_children(module_node)
+
+          targeted_module_function?(children, target_node) || section_module_function?(children, target_node)
+        end
+
+        def targeted_module_function?(children, target_node)
+          children.any? do |child|
+            child.send_type? && child.method_name == :module_function &&
+              child.arguments.any? { |arg| arg.sym_type? && arg.value == target_node.method_name }
+          end
+        end
+
+        def section_module_function?(children, target_node)
+          section_active = false
+          children.each do |child|
+            section_active = true if child.send_type? && child.method_name == :module_function && child.arguments.empty?
+            return true if section_active && child == target_node
+          end
+          false
+        end
+
+        def module_body_children(module_node)
+          module_node.body.begin_type? ? module_node.body.children : [module_node.body]
+        end
       end
     end
   end

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

@@ -28,7 +28,9 @@ module RuboCop
           return unless checkable_method?(node) && public_method?(node)
           return if inside_inner_class?(node)
 
-          check_method_has_spec(node, instance_method: !inside_eigenclass?(node) && !inside_class_methods_block?(node))
+          instance_method = !inside_eigenclass?(node) && !inside_class_methods_block?(node)
+          flexible_prefix = instance_method && module_with_dual_access?(node)
+          check_method_has_spec(node, instance_method: instance_method, flexible_prefix: flexible_prefix)
         end
 
         def on_defs(node)
@@ -197,7 +199,7 @@ module RuboCop
         end
 
         # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
-        def check_method_has_spec(node, instance_method:)
+        def check_method_has_spec(node, instance_method:, flexible_prefix: false)
           class_name = extract_class_name(node)
           return unless class_name
 
@@ -208,7 +210,10 @@ module RuboCop
           if spec_paths.empty?
             # No spec file exists — public method is untested
             report_path = all_expected.first
-            add_method_offense(node, method_name, report_path, instance_method: instance_method) if report_path
+            if report_path
+              add_method_offense(node, method_name, report_path, instance_method: instance_method,
+                                                                 flexible_prefix: flexible_prefix)
+            end
             return
           end
 
@@ -216,44 +221,61 @@ module RuboCop
           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) }
-          elsif spec_paths.any? { |spec_path| spec_covers_method?(spec_path, method_name, instance_method) }
+          elsif spec_paths.any? do |sp|
+                  spec_covers_method?(sp, method_name, instance_method, flexible_prefix: flexible_prefix)
+                end
             # Normal validation: check for method describe
             return
           end
 
-          add_method_offense(node, method_name, spec_paths.first, instance_method: instance_method)
+          add_method_offense(node, method_name, spec_paths.first, instance_method: instance_method,
+                                                                  flexible_prefix: flexible_prefix)
         end
         # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
 
-        def spec_covers_method?(spec_path, method_name, instance_method)
+        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)
 
-          prefix = instance_method ? "#" : "."
-          describe_key = "#{prefix}#{method_name}"
-          describe_aliases_for(describe_key).any? do |alias_desc|
-            alias_name = alias_desc.sub(/^[#.]/, "")
-            alias_instance = !alias_desc.start_with?(".")
-            method_tested_in_spec?(spec_path, alias_name, alias_instance)
+          spec_covers_via_aliases?(spec_path, method_name, instance_method, flexible_prefix)
+        end
+
+        def spec_covers_via_aliases?(spec_path, method_name, instance_method, flexible_prefix)
+          prefixes_for(instance_method, flexible_prefix).any? do |prefix|
+            describe_aliases_for("#{prefix}#{method_name}").any? do |alias_desc|
+              alias_name = alias_desc.sub(/^[#.]/, "")
+              method_tested_in_spec?(spec_path, alias_name, !alias_desc.start_with?("."))
+            end
           end
         end
 
-        def add_method_offense(node, method_name, spec_path, instance_method:)
-          prefix = instance_method ? "#" : "."
-          expected = expected_describes(prefix, method_name)
+        def add_method_offense(node, method_name, spec_path, instance_method:, flexible_prefix: false)
+          expected = expected_describes_for(method_name, instance_method, flexible_prefix)
           add_offense(
             node.loc.keyword.join(node.loc.name),
             message: format(MSG, method_name: method_name, expected: expected, spec_path: relative_spec_path(spec_path))
           )
         end
 
-        def expected_describes(prefix, method_name)
-          describes = ["describe '#{prefix}#{method_name}'"]
-          describe_aliases_for("#{prefix}#{method_name}").each do |alias_desc|
-            describes << "describe '#{alias_desc}'"
+        def expected_describes_for(method_name, instance_method, flexible_prefix)
+          describes = []
+          prefixes_for(instance_method, flexible_prefix).each do |prefix|
+            describes << "describe '#{prefix}#{method_name}'"
+            describe_aliases_for("#{prefix}#{method_name}").each do |alias_desc|
+              describes << "describe '#{alias_desc}'"
+            end
           end
           describes.join(" or ")
         end
 
+        def prefixes_for(instance_method, flexible_prefix)
+          if flexible_prefix
+            ["#", "."]
+          else
+            [instance_method ? "#" : "."]
+          end
+        end
+
         def method_tested_in_spec?(spec_path, method_name, instance_method)
           spec_content = File.read(spec_path)
           prefix = instance_method ? "#" : "."

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

@@ -84,13 +84,17 @@ module RuboCop
           spec_files = find_valid_spec_files(class_name, expected_spec_paths)
           return if spec_files.empty?
 
+          dual_access = node.def_type? && module_with_dual_access?(node)
+
           # Aggregate contexts from all valid spec files
           contexts = if matches_skip_path? && count_public_methods(node) == 1
                        # For single-method classes, count top-level contexts instead
                        spec_files.sum { |spec_file| count_top_level_contexts(File.read(spec_file), class_name) }
                      else
                        # Normal path: look for method describes
-                       spec_files.sum { |spec_file| count_method_contexts(File.read(spec_file), method_name(node)) }
+                       spec_files.sum do |spec_file|
+                         count_method_contexts(File.read(spec_file), method_name(node), dual_access: dual_access)
+                       end
                      end
 
           return if contexts.zero? # Method has no specs at all - PublicMethodHasSpec handles this
@@ -189,11 +193,14 @@ module RuboCop
           when_count + (has_else ? 1 : 0)
         end
 
-        def count_method_contexts(spec_content, mname)
+        def count_method_contexts(spec_content, mname, dual_access: false)
           count = count_contexts_for_method(spec_content, mname)
-          describe_aliases_for("##{mname}").each do |alias_desc|
-            alias_name = alias_desc.sub(/^[#.]/, "")
-            count += count_contexts_for_method(spec_content, alias_name) if alias_name != mname
+          prefixes = dual_access ? ["#", "."] : ["#"]
+          prefixes.each do |prefix|
+            describe_aliases_for("#{prefix}#{mname}").each do |alias_desc|
+              alias_name = alias_desc.sub(/^[#.]/, "")
+              count += count_contexts_for_method(spec_content, alias_name) if alias_name != mname
+            end
           end
           count
         end

data/lib/rubocop/rspec_parity/version.rb

@@ -2,6 +2,6 @@
 
 module RuboCop
   module RSpecParity
-    VERSION = "1.4.4"
+    VERSION = "1.4.5"
   end
 end

metadata

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