rubocop-rspec_parity 0.1.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d97c9609bdd7e3ee9d2693e548eaf8f4e18af613449fc807b78f40386f8aad55
-  data.tar.gz: f2f86bfac2c25c6c88c250f5c48a1a8ca7215b4265fbbb549dfe784359e42c91
+  metadata.gz: 2e75d169afdb6caa654d618ae15b194b3329b53c1151ce2cc492ed521a513327
+  data.tar.gz: 7ae507090fa12baa552224b911b5f50fb98096f87181880c98395b93368009cf
 SHA512:
-  metadata.gz: 0f176130a0935ee6b3f3f22dabf39f21b8aafbe7335585cad02281366ed298d936559dd745809f77ff977210429715e3294f10b33dc2c245c9f1d3e3f6a347e0
-  data.tar.gz: c0083330fd6fa6e3874488476b878159d203559c3cf21967f86a7175c8e4acae8c7dac213e9a552117b7ba43083fc45dd1e0a90200595c97e34c91c5f6dda85e
+  metadata.gz: 4c7e2fda565eafad49f2d7017edc91df2f12c200c821f59313afdc4c0e8221c7136e9197010a21ff6b2819c91b7a5cd72c7f71936aea2321ad389638bd830f70
+  data.tar.gz: b67f7496c9f0c483c82af7691579b3c9bb21efed23a4d7d50d70dac5fc5e3b2b7b531ecab0aedc660579fbbed659b1c38db0bf563c2f09ebf2f05be1d68665ae

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 ## [Unreleased]
 
+## [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)`
+Fixed: `SufficientContexts` cop now works with absolute file paths
+Removed: `NoLetBang` cop
+
 ## [0.1.0] - 2026-01-15
 
 - Initial release

data/CLAUDE.md

@@ -14,6 +14,43 @@
    - All RuboCop violations are resolved
    - All RSpec tests pass
    - No new warnings or errors are introduced
+   - CHANGELOG.md has been updated if applicable (see below)
+
+## Changelog Management
+
+**Update CHANGELOG.md ONLY for:**
+- New features (Added)
+- Bug fixes (Fixed)
+- Deprecations (Deprecated)
+- Removed features (Removed)
+- Dependency updates (Updated)
+
+**DO NOT update for:**
+- Refactoring or code quality improvements
+- Minor documentation updates
+- Internal implementation changes
+
+**Format (compact, one line per change):**
+```
+Added: Allow passing custom decorator build strategy
+Fixed: Better handle render in controller hooks
+Updated: GraphQL and gems version dependencies
+Removed: NoLetBang cop
+```
+
+**During Release:**
+- Move items from `[Unreleased]` to: `## [X.Y.Z] - YYYY-MM-DD`
+- Leave `[Unreleased]` empty
+
+## Release Process
+
+To release a new version:
+1. Update version in `lib/rubocop/rspec_parity/version.rb`
+2. Update CHANGELOG.md (move [Unreleased] items to new version section)
+3. Run tests: `bundle exec rspec && bundle exec rubocop`
+4. Use rake task to release: `bundle exec rake release`
+   - This will create a git tag, push commits/tags, and push the gem to rubygems.org
+5. **DO NOT** manually run `gem build` or `gem push` - use the rake task
 
 ## Git Commits
 

data/README.md

@@ -9,7 +9,6 @@ This plugin provides these custom cops:
 - **RSpecParity/FileHasSpec**: Ensures every Ruby file in your app directory has a corresponding spec file
 - **RSpecParity/PublicMethodHasSpec**: Ensures every public method has spec test coverage
 - **RSpecParity/SufficientContexts**: Ensures specs have at least as many contexts as the method has branches (if/elsif/else, case/when, &&, ||, ternary operators)
-- **RSpecParity/NoLetBang**: Disallows the use of `let!` in specs, encouraging explicit setup
 
 ## Examples
 
@@ -96,44 +95,21 @@ RSpec.describe UserCreator do
     end
   end
 end
-```
-
-### RSpecParity/NoLetBang
-
-Disallows the use of `let!` in specs, encouraging explicit setup.
-
-```ruby
-# bad
-RSpec.describe User do
-  let!(:user) { create(:user) }
 
-  it 'does something' do
-    expect(user).to be_valid
-  end
+# Memoization patterns are ignored by default
+def cached_value
+  @cached_value ||= expensive_operation  # Not counted as a branch
 end
 
-# good - use let with explicit reference
-RSpec.describe User do
-  let(:user) { create(:user) }
-
-  it 'does something' do
-    expect(user).to be_valid  # Explicit reference
-  end
+def cached_value
+  return @cached_value if defined?(@cached_value)  # Not counted as a branch
+  @cached_value = expensive_operation
 end
+```
 
-# good - use before block when setup is needed
-RSpec.describe User do
-  let(:user) { build(:user) }
-
-  before do
-    user.save!  # Explicit setup in before block
-  end
+**Configuration options:**
 
-  it 'does something' do
-    expect(user).to be_persisted
-  end
-end
-```
+- `IgnoreMemoization` (default: `true`) - When enabled, common memoization patterns like `@var ||=` and `return @var if defined?(@var)` are not counted as branches. Set to `false` if you want to count these as branches.
 
 ## Assumptions
 
@@ -198,16 +174,12 @@ RSpecParity/PublicMethodHasSpec:
 
 RSpecParity/SufficientContexts:
   Enabled: true
+  IgnoreMemoization: true  # Set to false to count memoization patterns as branches
   Include:
     - 'app/**/*.rb'
   Exclude:
     - 'app/assets/**/*'
     - 'app/views/**/*'
-
-RSpecParity/NoLetBang:
-  Enabled: true
-  Include:
-    - 'spec/**/*_spec.rb'
 ```
 
 Run RuboCop as usual:

data/config/default.yml

@@ -23,15 +23,10 @@ RSpecParity/PublicMethodHasSpec:
 RSpecParity/SufficientContexts:
   Description: 'Ensures specs have at least as many contexts as the method has branches.'
   Enabled: true
+  IgnoreMemoization: true
   Include:
     - 'app/**/*.rb'
   Exclude:
     - 'app/assets/**/*'
     - 'app/views/**/*'
     - 'app/javascript/**/*'
-
-RSpecParity/NoLetBang:
-  Description: 'Disallows the use of `let!` in specs.'
-  Enabled: true
-  Include:
-    - 'spec/**/*_spec.rb'

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

@@ -58,6 +58,11 @@ module RuboCop
           /^autosave_/
         ].freeze
 
+        def initialize(config = nil, options = nil)
+          super
+          @ignore_memoization = cop_config.fetch("IgnoreMemoization", true)
+        end
+
         def on_def(node)
           check_method(node)
         end
@@ -81,6 +86,7 @@ module RuboCop
           spec_content = File.read(spec_file)
           contexts = count_contexts_for_method(spec_content, method_name(node))
 
+          return if contexts.zero? # Method has no specs at all - PublicMethodHasSpec handles this
           return if contexts >= branches
 
           missing = branches - contexts
@@ -104,7 +110,11 @@ module RuboCop
         end
 
         def in_covered_directory?
-          COVERED_DIRECTORIES.any? { |dir| processed_source.path.start_with?(dir) }
+          path = processed_source.path
+          # Handle both absolute and relative paths
+          COVERED_DIRECTORIES.any? do |dir|
+            path.start_with?(dir) || path.include?("/#{dir}/") || path.match?(%r{/#{Regexp.escape(dir)}$})
+          end
         end
 
         def excluded_method?(method_name)
@@ -115,37 +125,50 @@ module RuboCop
 
         def spec_file_path
           path = processed_source.path
-          path.sub(%r{^app/}, "spec/").sub(/\.rb$/, "_spec.rb")
+          # Handle both absolute and relative paths
+          path.sub(%r{/app/}, "/spec/").sub(%r{^app/}, "spec/").sub(/\.rb$/, "_spec.rb")
         end
 
         def count_branches(node)
           branches = 0
-          elsif_nodes = Set.new
-
-          # First pass: collect all elsif nodes (if nodes in else branches)
-          node.each_descendant(:if) do |if_node|
-            elsif_nodes.add(if_node.else_branch) if if_node.else_branch&.if_type?
-          end
+          elsif_nodes = collect_elsif_nodes(node)
 
-          # Second pass: count branches, skipping elsif nodes
           node.each_descendant do |descendant|
             next if elsif_nodes.include?(descendant)
+            next if should_skip_node?(descendant)
 
             branches += branch_count_for_node(descendant)
           end
           branches
         end
 
+        def collect_elsif_nodes(node)
+          elsif_nodes = Set.new
+          node.each_descendant(:if) do |if_node|
+            elsif_nodes.add(if_node.else_branch) if if_node.else_branch&.if_type?
+          end
+          elsif_nodes
+        end
+
+        def should_skip_node?(node)
+          @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 :send then node.method?(:&) || node.method?(:|) ? 1 : 0
+          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
+
         def count_if_branches(node)
           # if/else is 2 branches, each elsif adds 1
           branches = 2
@@ -164,37 +187,55 @@ module RuboCop
           when_count + (has_else ? 1 : 0)
         end
 
-        # rubocop:disable Metrics/MethodLength
         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)
+
+          # If no contexts but has examples, count as 1 scenario
+          context_count.zero? && has_examples ? 1 : context_count
+        end
+
+        # rubocop:disable Metrics/MethodLength
+        def parse_spec_content(spec_content, method_pattern)
           in_method_block = false
           context_count = 0
+          has_examples = false
           base_indent = 0
 
           spec_content.each_line do |line|
             current_indent = line[/^\s*/].length
 
-            # Entering a describe block for this method
             if matches_method_describe?(line, method_pattern)
               in_method_block = true
               base_indent = current_indent
-              # Don't count the describe itself, only nested contexts
               next
             end
 
-            # Process lines inside the method block
             if in_method_block
-              in_method_block = false if exiting_block?(line, current_indent, base_indent)
-              context_count += 1 if nested_context?(line)
+              context_count, has_examples, in_method_block = process_method_block_line(
+                line, current_indent, base_indent, context_count, has_examples
+              )
             elsif matches_context_pattern?(line, method_pattern)
               context_count += 1
             end
           end
 
-          context_count
+          [context_count, has_examples]
         end
-
         # rubocop:enable Metrics/MethodLength
+
+        def process_method_block_line(line, current_indent, base_indent, context_count, has_examples)
+          in_method_block = !exiting_block?(line, current_indent, base_indent)
+
+          if nested_context?(line)
+            context_count += 1
+          elsif nested_example?(line)
+            has_examples = true
+          end
+
+          [context_count, has_examples, in_method_block]
+        end
+
         def matches_method_describe?(line, method_pattern)
           line =~ /^\s*describe\s+['"](?:#|\.)?#{method_pattern}['"]/ ||
             line =~ /^\s*describe\s+:#{method_pattern}/
@@ -208,6 +249,10 @@ module RuboCop
           line =~ /^\s*(?:context|describe)\s+/
         end
 
+        def nested_example?(line)
+          line =~ /^\s*(?:it|example|specify)\s+/
+        end
+
         def exiting_block?(line, current_indent, base_indent)
           current_indent <= base_indent && line =~ /^\s*(?:describe|context|end)/
         end
@@ -221,6 +266,81 @@ module RuboCop
           else "#{word}s"
           end
         end
+
+        def memoization_pattern?(node)
+          # Pattern: @var ||= value
+          return true if or_asgn_ivar_pattern?(node)
+
+          # Pattern: return @var if defined?(@var)
+          return true if defined_check_pattern?(node)
+
+          # Pattern: @var = value if @var.nil? or similar
+          return true if nil_check_pattern?(node)
+
+          # Pattern: || with instance variable (part of @var ||= which creates both :or and :or_asgn nodes)
+          return true if or_with_ivar_pattern?(node)
+
+          false
+        end
+
+        # @var ||= value
+        def or_asgn_ivar_pattern?(node)
+          node.or_asgn_type? && node.children[0]&.ivasgn_type?
+        end
+
+        # return @var if defined?(@var)
+        def defined_check_pattern?(node)
+          return false unless node.if_type?
+
+          condition = node.condition
+          return false unless condition&.defined_type?
+
+          # Check if it's checking an instance variable
+          condition.children[0]&.ivar_type?
+        end
+
+        # @var = value if @var.nil? or @var = value unless @var
+        def nil_check_pattern?(node)
+          return false unless node.if_type?
+
+          condition = node.condition
+          body = node.body
+
+          # Check if body is an ivasgn
+          return false unless body&.ivasgn_type?
+
+          ivar_name = body.children[0]
+
+          # Check if condition checks the same ivar for nil
+          checks_same_ivar_for_nil?(condition, ivar_name)
+        end
+
+        def checks_same_ivar_for_nil?(condition, ivar_name)
+          return false unless condition
+
+          nil_check?(condition, ivar_name) || negation_check?(condition, ivar_name)
+        end
+
+        def nil_check?(condition, ivar_name)
+          return false unless condition.send_type? && condition.method?(:nil?)
+
+          condition.receiver&.ivar_type? && condition.receiver.children[0] == ivar_name
+        end
+
+        def negation_check?(condition, ivar_name)
+          return false unless condition.send_type? && condition.method?(:!)
+
+          receiver = condition.receiver
+          receiver&.ivar_type? && receiver.children[0] == ivar_name
+        end
+
+        # || operator with instance variable on left side
+        def or_with_ivar_pattern?(node)
+          return false unless node.or_type?
+
+          left = node.children[0]
+          left&.ivar_type?
+        end
       end
     end
   end

data/lib/rubocop/rspec_parity/version.rb

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

data/lib/rubocop_rspec_parity.rb

@@ -5,6 +5,5 @@ require "rubocop"
 require_relative "rubocop/rspec_parity"
 require_relative "rubocop/rspec_parity/version"
 require_relative "rubocop/rspec_parity/plugin"
-require_relative "rubocop/cop/rspec_parity/no_let_bang"
 require_relative "rubocop/cop/rspec_parity/public_method_has_spec"
 require_relative "rubocop/cop/rspec_parity/sufficient_contexts"

metadata

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

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

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpecParity
-      # Disallows the use of `let!` in specs.
-      #
-      # `let!` creates implicit setup that runs before each example,
-      # which can make tests harder to understand and debug.
-      # Prefer using `let` with explicit references or `before` blocks.
-      #
-      # @example
-      #   # bad
-      #   let!(:user) { create(:user) }
-      #
-      #   # good
-      #   let(:user) { create(:user) }
-      #
-      #   # good
-      #   before { create(:user) }
-      #
-      class NoLetBang < Base
-        MSG = "Do not use `let!`. Use `let` with explicit reference or `before` block instead."
-
-        # @!method let_bang?(node)
-        def_node_matcher :let_bang?, "(send nil? :let! ...)"
-
-        def on_send(node)
-          return unless let_bang?(node)
-
-          add_offense(node)
-        end
-      end
-    end
-  end
-end