rubocop-rspec_parity 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2e75d169afdb6caa654d618ae15b194b3329b53c1151ce2cc492ed521a513327
-  data.tar.gz: 7ae507090fa12baa552224b911b5f50fb98096f87181880c98395b93368009cf
+  metadata.gz: f9e0dc1e3be84865d59b94dfae0d55c808bb307c2bfefd5f85bc66921048afbe
+  data.tar.gz: e6abf7807ddc099af831d46b90e5c18913c76f0be754553dbffef0c83f723eba
 SHA512:
-  metadata.gz: 4c7e2fda565eafad49f2d7017edc91df2f12c200c821f59313afdc4c0e8221c7136e9197010a21ff6b2819c91b7a5cd72c7f71936aea2321ad389638bd830f70
-  data.tar.gz: b67f7496c9f0c483c82af7691579b3c9bb21efed23a4d7d50d70dac5fc5e3b2b7b531ecab0aedc660579fbbed659b1c38db0bf563c2f09ebf2f05be1d68665ae
+  metadata.gz: c434bf6e258c007681582e7666184bd5233ba260ab60f981e46140f7a420a28e6079ecc506810728f552e2aaacc3aa71f181df6d684e6fd8f8f28d4279ee2b8f
+  data.tar.gz: 4671da5c79fe882e1cc8808764430d819b30646594d39aadc774559eb1055c01903b869577bf38139f8a32acc9f6a10f72afcde256cc49bb7d88324785ece872

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 ## [Unreleased]
 
+## [1.1.0] - 2026-02-06
+
+Added: Support for checking wildcard spec files (`<model>_*_spec.rb`) in addition to base spec file, with automatic class validation
+Added: `SkipMethodDescribeFor` configuration for `PublicMethodHasSpec` and `SufficientContexts` cops to allow single-method classes (like service objects) to skip method describe blocks in specs
+Added: `DescribeAliases` configuration for mapping describe strings to alias describe patterns
+
 ## [1.0.0] - 2026-01-27
 
 Added: `IgnoreMemoization` configuration option for `SufficientContexts` cop to ignore memoization patterns like `@var ||=` and `return @var if defined?(@var)`

data/README.md

@@ -54,6 +54,126 @@ RSpec.describe UserCreator do
 end
 ```
 
+#### SkipMethodDescribeFor Configuration
+
+For service objects and similar patterns with a single public method, you can skip the method describe block:
+
+```yaml
+RSpecParity/PublicMethodHasSpec:
+  SkipMethodDescribeFor:
+    - 'app/services/**/*'
+    - 'app/operations/**/*'
+
+RSpecParity/SufficientContexts:
+  SkipMethodDescribeFor:
+    - 'app/services/**/*'
+    - 'app/operations/**/*'
+```
+
+With this configuration:
+
+```ruby
+# app/services/user_creator.rb
+class UserCreator
+  def call(params)
+    User.create(params)
+  end
+
+  private
+
+  def validate(params)
+    # Private helper - doesn't count
+  end
+end
+
+# spec/services/user_creator_spec.rb - Valid!
+RSpec.describe UserCreator do
+  it 'creates a user' do
+    # test implementation
+  end
+
+  context 'when invalid params' do
+    it 'raises error' do
+    end
+  end
+end
+```
+
+**Requirements:**
+- Class must have exactly ONE public method
+- Spec must contain at least one example (`it`, `example`, or `specify`)
+- Traditional method describes still work if you prefer them
+
+**How it works:**
+- `PublicMethodHasSpec`: Instead of requiring `describe '#call'`, it just checks that examples exist
+- `SufficientContexts`: Counts top-level contexts/examples instead of looking inside method describes
+
+#### DescribeAliases Configuration
+
+When an instance method is tested via a class method (e.g., service objects where `def call` is tested via `describe '.call'`, or jobs where `def perform` is tested via `describe '.perform_later'`), you can configure describe aliases:
+
+```yaml
+RSpecParity/PublicMethodHasSpec:
+  DescribeAliases:
+    '#call': '.call'
+    '#perform':
+      - '.perform_later'
+      - '.perform_now'
+
+RSpecParity/SufficientContexts:
+  DescribeAliases:
+    '#call': '.call'
+    '#perform':
+      - '.perform_later'
+      - '.perform_now'
+```
+
+With this configuration:
+
+```ruby
+# app/services/user_creator.rb
+class UserCreator
+  def call(params)
+    User.create(params)
+  end
+end
+
+# spec/services/user_creator_spec.rb - Valid!
+# The alias '#call' => '.call' allows .call to satisfy #call
+RSpec.describe UserCreator do
+  describe '.call' do
+    it 'creates a user' do
+      # test implementation
+    end
+  end
+end
+```
+
+```ruby
+# app/jobs/user_job.rb
+class UserJob
+  def perform(params)
+    process(params)
+  end
+end
+
+# spec/jobs/user_job_spec.rb - Valid!
+# The alias '#perform' => ['.perform_later', '.perform_now'] allows either
+RSpec.describe UserJob do
+  describe '.perform_later' do
+    it 'processes params' do
+      # test implementation
+    end
+  end
+end
+```
+
+**Notes:**
+- Keys use `#` for instance method describes, `.` for class method describes
+- Values can be a single string or an array of strings
+- Aliases are unidirectional: `'#call': '.call'` allows `.call` to satisfy `#call`, but not vice versa
+- `SufficientContexts` aggregates contexts from both the original and alias describe blocks
+
 ### RSpecParity/SufficientContexts
 
 Ensures specs have at least as many contexts as the method has branches.
@@ -169,12 +289,16 @@ RSpecParity/FileHasSpec:
 
 RSpecParity/PublicMethodHasSpec:
   Enabled: true
+  SkipMethodDescribeFor: []  # Paths where single-method classes don't need method describe
+  DescribeAliases: {}  # Map describe strings to aliases, e.g. '#call': '.call'
   Include:
     - 'app/**/*.rb'
 
 RSpecParity/SufficientContexts:
   Enabled: true
   IgnoreMemoization: true  # Set to false to count memoization patterns as branches
+  SkipMethodDescribeFor: []  # Paths where single-method classes use top-level contexts
+  DescribeAliases: {}  # Map describe strings to aliases, e.g. '#call': '.call'
   Include:
     - 'app/**/*.rb'
   Exclude:

data/config/default.yml

@@ -13,6 +13,8 @@ RSpecParity/FileHasSpec:
 RSpecParity/PublicMethodHasSpec:
   Description: 'Checks that each public method has a corresponding spec test.'
   Enabled: true
+  SkipMethodDescribeFor: []
+  DescribeAliases: {}
   Include:
     - 'app/**/*.rb'
   Exclude:
@@ -24,6 +26,8 @@ RSpecParity/SufficientContexts:
   Description: 'Ensures specs have at least as many contexts as the method has branches.'
   Enabled: true
   IgnoreMemoization: true
+  SkipMethodDescribeFor: []
+  DescribeAliases: {}
   Include:
     - 'app/**/*.rb'
   Exclude:

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "spec_file_finder"
+
 module RuboCop
   module Cop
     module RSpecParity
@@ -10,7 +12,9 @@ module RuboCop
       #
       #   # good - public method `perform` has describe '#perform' in spec
       #
-      class PublicMethodHasSpec < Base
+      class PublicMethodHasSpec < Base # rubocop:disable Metrics/ClassLength
+        include SpecFileFinder
+
         MSG = "Missing spec for public method `%<method_name>s`. " \
               "Expected describe '#%<method_name>s' or describe '.%<method_name>s' in %<spec_path>s"
 
@@ -19,6 +23,12 @@ module RuboCop
         EXCLUDED_PATTERNS = [/^before_/, /^after_/, /^around_/, /^validate_/, /^autosave_/].freeze
         VISIBILITY_METHODS = { private: :private, protected: :protected, public: :public }.freeze
 
+        def initialize(config = nil, options = nil)
+          super
+          @skip_method_describe_paths = cop_config.fetch("SkipMethodDescribeFor", [])
+          @describe_aliases = cop_config.fetch("DescribeAliases", {})
+        end
+
         def on_def(node)
           return unless checkable_method?(node) && public_method?(node)
 
@@ -82,24 +92,44 @@ module RuboCop
             EXCLUDED_PATTERNS.any? { |pattern| pattern.match?(method_name) }
         end
 
+        def source_file_path
+          processed_source.file_path
+        end
+
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
         def check_method_has_spec(node, instance_method:)
-          spec_path = expected_spec_path
-          return unless spec_path && File.exist?(spec_path)
+          class_name = extract_class_name(node)
+          return unless class_name
+
+          base_spec_path = expected_spec_path
+          spec_paths = find_valid_spec_files(class_name, base_spec_path)
+          return if spec_paths.empty?
 
           method_name = node.method_name.to_s
-          return if spec_covers_method?(spec_path, method_name, instance_method)
 
-          add_method_offense(node, method_name, spec_path)
+          # 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) }
+          elsif spec_paths.any? { |spec_path| spec_covers_method?(spec_path, method_name, instance_method) }
+            # Normal validation: check for method describe
+            return
+          end
+
+          add_method_offense(node, method_name, spec_paths.first)
         end
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
 
         def spec_covers_method?(spec_path, method_name, instance_method)
           return true if method_tested_in_spec?(spec_path, method_name, instance_method)
 
-          service_call_method?(method_name) && method_tested_in_spec?(spec_path, method_name, !instance_method)
-        end
-
-        def service_call_method?(method_name)
-          method_name == "call" && processed_source.file_path&.include?("/app/services/")
+          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)
+          end
         end
 
         def add_method_offense(node, method_name, spec_path)
@@ -142,6 +172,72 @@ module RuboCop
           app_index = path.split("/").index("app")
           app_index ? path.split("/")[0...app_index].join("/") : nil
         end
+
+        def matches_skip_path?
+          return false if @skip_method_describe_paths.empty?
+
+          file_path = processed_source.file_path
+          return false unless file_path
+
+          @skip_method_describe_paths.any? do |pattern|
+            # Match against both absolute path and relative path
+            File.fnmatch?(pattern, file_path, File::FNM_PATHNAME | File::FNM_EXTGLOB) ||
+              File.fnmatch?(pattern, extract_relative_path(file_path), File::FNM_PATHNAME | File::FNM_EXTGLOB)
+          end
+        end
+
+        def extract_relative_path(file_path)
+          # Extract path starting from 'app/' directory
+          app_index = file_path.split("/").index("app")
+          return file_path unless app_index
+
+          file_path.split("/")[app_index..].join("/")
+        end
+
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+        def count_public_methods(node)
+          class_node = find_class_or_module(node)
+          return 0 unless class_node&.body
+
+          public_methods = []
+          visibility = :public
+
+          # Get all child nodes, handling both single method and begin-wrapped bodies
+          children = if class_node.body.begin_type?
+                       class_node.body.children
+                     else
+                       [class_node.body]
+                     end
+
+          children.each do |child|
+            next unless child
+
+            case child.type
+            when :send
+              visibility = VISIBILITY_METHODS[child.method_name] if VISIBILITY_METHODS.key?(child.method_name)
+            when :def
+              # Only count instance methods (def), not class methods (defs)
+              if visibility == :public
+                method_name = child.method_name.to_s
+                public_methods << method_name unless excluded_method?(method_name)
+              end
+            end
+          end
+
+          public_methods.size
+        end
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+
+        def spec_has_examples?(spec_path, class_name)
+          spec_content = File.read(spec_path)
+          escaped_class_name = Regexp.escape(class_name)
+
+          # Check that the spec describes the correct class
+          return false unless spec_content.match?(/(?:RSpec\.)?describe\s+#{escaped_class_name}(?:\s|,|do)/)
+
+          # Check for any it/example/specify blocks
+          spec_content.match?(/^\s*(?:it|example|specify)\s+/)
+        end
       end
     end
   end

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

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpecParity
+      # Shared module for finding and validating spec files
+      module SpecFileFinder
+        private
+
+        def extract_class_name(node)
+          class_node = find_class_or_module(node)
+
+          if class_node
+            # Get the class/module name from the AST
+            const_node = class_node.children[0]
+            return const_node.const_name if const_node.const_type?
+          end
+
+          # Fallback: infer class name from file path
+          infer_class_name_from_path
+        end
+
+        def find_class_or_module(node)
+          node.each_ancestor.find { |n| n.class_type? || n.module_type? }
+        end
+
+        def infer_class_name_from_path
+          path = source_file_path
+          return nil unless path
+
+          # Extract filename and convert to class name
+          # e.g., app/services/user_creator.rb → UserCreator
+          filename = File.basename(path, ".rb")
+          filename.split("_").map(&:capitalize).join
+        end
+
+        def find_valid_spec_files(class_name, base_spec_path)
+          return [] unless base_spec_path
+
+          valid_files = []
+
+          # Always include the base spec file if it exists (maintains original behavior)
+          valid_files << base_spec_path if File.exist?(base_spec_path)
+
+          # Also check for wildcard spec files (e.g., user_updates_spec.rb)
+          # But only include them if they describe the correct class
+          spec_dir = File.dirname(base_spec_path)
+          base_name = File.basename(base_spec_path, "_spec.rb")
+          wildcard_files = Dir.glob(File.join(spec_dir, "#{base_name}_*_spec.rb"))
+
+          wildcard_files.each do |file|
+            valid_files << file if File.exist?(file) && spec_describes_class?(file, class_name)
+          end
+
+          valid_files.uniq
+        end
+
+        def spec_describes_class?(spec_path, class_name)
+          spec_content = File.read(spec_path)
+          # Match RSpec.describe ClassName or describe ClassName
+          spec_content.match?(/(?:RSpec\.)?describe\s+#{Regexp.escape(class_name)}(?:\s|,|do)/)
+        end
+
+        def describe_aliases_for(describe_key)
+          value = @describe_aliases[describe_key]
+          return [] unless value
+
+          Array(value).map(&:to_s)
+        end
+
+        # Override this method in the including class
+        def source_file_path
+          processed_source.file_path
+        end
+      end
+    end
+  end
+end

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "spec_file_finder"
+
 module RuboCop
   module Cop
     module RSpecParity
@@ -36,6 +38,8 @@ module RuboCop
       #   context 'when creating a regular user' do
       #   end
       class SufficientContexts < Base # rubocop:disable Metrics/ClassLength
+        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."
 
@@ -61,6 +65,8 @@ module RuboCop
         def initialize(config = nil, options = nil)
           super
           @ignore_memoization = cop_config.fetch("IgnoreMemoization", true)
+          @skip_method_describe_paths = cop_config.fetch("SkipMethodDescribeFor", [])
+          @describe_aliases = cop_config.fetch("DescribeAliases", {})
         end
 
         def on_def(node)
@@ -73,18 +79,28 @@ module RuboCop
 
         private
 
-        def check_method(node) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+        def check_method(node) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
           return unless in_covered_directory?
           return if excluded_method?(method_name(node))
 
           branches = count_branches(node)
           return if branches < 2 # Only check methods with branches
 
-          spec_file = spec_file_path
-          return unless File.exist?(spec_file)
+          class_name = extract_class_name(node)
+          return unless class_name
+
+          base_spec_path = spec_file_path
+          spec_files = find_valid_spec_files(class_name, base_spec_path)
+          return if spec_files.empty?
 
-          spec_content = File.read(spec_file)
-          contexts = count_contexts_for_method(spec_content, method_name(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)) }
+                     end
 
           return if contexts.zero? # Method has no specs at all - PublicMethodHasSpec handles this
           return if contexts >= branches
@@ -123,6 +139,10 @@ module RuboCop
           EXCLUDED_PATTERNS.any? { |pattern| pattern.match?(method_name) }
         end
 
+        def source_file_path
+          processed_source.path
+        end
+
         def spec_file_path
           path = processed_source.path
           # Handle both absolute and relative paths
@@ -187,6 +207,15 @@ module RuboCop
           when_count + (has_else ? 1 : 0)
         end
 
+        def count_method_contexts(spec_content, mname)
+          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
+          end
+          count
+        end
+
         def count_contexts_for_method(spec_content, method_name)
           method_pattern = Regexp.escape(method_name)
           context_count, has_examples = parse_spec_content(spec_content, method_pattern)
@@ -341,6 +370,88 @@ module RuboCop
           left = node.children[0]
           left&.ivar_type?
         end
+
+        def matches_skip_path?
+          return false if @skip_method_describe_paths.empty?
+
+          path = processed_source.path
+          return false unless path
+
+          @skip_method_describe_paths.any? do |pattern|
+            File.fnmatch?(pattern, path, File::FNM_PATHNAME | File::FNM_EXTGLOB)
+          end
+        end
+
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+        def count_public_methods(node)
+          class_node = find_class_or_module(node)
+          return 0 unless class_node&.body
+
+          public_methods = []
+          visibility = :public
+          visibility_methods = { private: :private, protected: :protected, public: :public }
+
+          # Get all child nodes, handling both single method and begin-wrapped bodies
+          children = if class_node.body.begin_type?
+                       class_node.body.children
+                     else
+                       [class_node.body]
+                     end
+
+          children.each do |child|
+            next unless child
+
+            case child.type
+            when :send
+              visibility = visibility_methods[child.method_name] if visibility_methods.key?(child.method_name)
+            when :def
+              # Only count instance methods (def), not class methods (defs)
+              if visibility == :public
+                method_name = child.method_name.to_s
+                public_methods << method_name unless excluded_method?(method_name)
+              end
+            end
+          end
+
+          public_methods.size
+        end
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+
+        def find_class_or_module(node)
+          node.each_ancestor.find { |n| n.class_type? || n.module_type? }
+        end
+
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+        def count_top_level_contexts(spec_content, class_name)
+          # Find the class describe block
+          describe_pattern = /^\s*(?:RSpec\.)?describe\s+#{Regexp.escape(class_name)}(?:\s|,|do)/
+
+          lines = spec_content.lines
+          describe_line_index = lines.index { |line| line.match?(describe_pattern) }
+          return 0 unless describe_line_index
+
+          # 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
+          has_examples = false
+
+          lines[(describe_line_index + 1)..].each do |line|
+            indent = line.match(/^(\s*)/)[1].length
+            break if indent <= base_indent && !line.strip.empty? && line.match?(/^\s*(?:describe|context|end)/)
+
+            next unless indent > base_indent
+
+            if line.match?(/^\s*(?:context|describe)\s+/)
+              context_count += 1
+            elsif line.match?(/^\s*(?:it|example|specify)\s+/)
+              has_examples = true
+            end
+          end
+
+          # If no contexts but has examples, count as 1
+          context_count.zero? && has_examples ? 1 : context_count
+        end
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
       end
     end
   end

data/lib/rubocop/rspec_parity/version.rb

@@ -2,6 +2,6 @@
 
 module RuboCop
   module RSpecParity
-    VERSION = "1.0.0"
+    VERSION = "1.1.0"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-rspec_parity
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Povilas Jurcys
@@ -55,6 +55,7 @@ files:
 - config/default.yml
 - lib/rubocop-rspec_parity.rb
 - lib/rubocop/cop/rspec_parity/public_method_has_spec.rb
+- lib/rubocop/cop/rspec_parity/spec_file_finder.rb
 - lib/rubocop/cop/rspec_parity/sufficient_contexts.rb
 - lib/rubocop/rspec_parity.rb
 - lib/rubocop/rspec_parity/plugin.rb