rubocop-rspec_parity 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d97c9609bdd7e3ee9d2693e548eaf8f4e18af613449fc807b78f40386f8aad55
+  data.tar.gz: f2f86bfac2c25c6c88c250f5c48a1a8ca7215b4265fbbb549dfe784359e42c91
+SHA512:
+  metadata.gz: 0f176130a0935ee6b3f3f22dabf39f21b8aafbe7335585cad02281366ed298d936559dd745809f77ff977210429715e3294f10b33dc2c245c9f1d3e3f6a347e0
+  data.tar.gz: c0083330fd6fa6e3874488476b878159d203559c3cf21967f86a7175c8e4acae8c7dac213e9a552117b7ba43083fc45dd1e0a90200595c97e34c91c5f6dda85e

data/.ruby-version

@@ -0,0 +1 @@
+4.0.1

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2026-01-15
+
+- Initial release

data/CLAUDE.md

@@ -0,0 +1,28 @@
+# Claude Instructions for rubocop-rspec_parity
+
+## Code Quality Rules
+
+1. **Never modify `.rubocop.yml`** unless the user explicitly asks to change RuboCop configuration. Always fix the code to satisfy linter rules rather than disabling or modifying the rules.
+
+2. **After any code change**, always run linters and specs:
+   ```bash
+   bundle exec rubocop
+   bundle exec rspec
+   ```
+
+3. **A task is only considered complete** when:
+   - All RuboCop violations are resolved
+   - All RSpec tests pass
+   - No new warnings or errors are introduced
+
+## Git Commits
+
+- Keep commit descriptions short but clear: 1-5 sentences
+- Focus on what changed and why, not implementation details
+
+## Project Structure
+
+- `lib/rubocop_rspec_parity.rb` - Main entry point
+- `lib/rubocop/cop/spec_rparity/` - Custom RuboCop cops
+- `config/default.yml` - Default cop configuration
+- `spec/` - RSpec tests

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,132 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, caste, color, religion, or sexual
+identity and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the overall
+  community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or advances of
+  any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email address,
+  without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official email address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+[INSERT CONTACT METHOD].
+All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series of
+actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or permanent
+ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior, harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within the
+community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.1, available at
+[https://www.contributor-covenant.org/version/2/1/code_of_conduct.html][v2.1].
+
+Community Impact Guidelines were inspired by
+[Mozilla's code of conduct enforcement ladder][Mozilla CoC].
+
+For answers to common questions about this code of conduct, see the FAQ at
+[https://www.contributor-covenant.org/faq][FAQ]. Translations are available at
+[https://www.contributor-covenant.org/translations][translations].
+
+[homepage]: https://www.contributor-covenant.org
+[v2.1]: https://www.contributor-covenant.org/version/2/1/code_of_conduct.html
+[Mozilla CoC]: https://github.com/mozilla/diversity
+[FAQ]: https://www.contributor-covenant.org/faq
+[translations]: https://www.contributor-covenant.org/translations

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Povilas Jurcys
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,235 @@
+# RuboCop RSpecParity
+
+A RuboCop plugin that enforces spec parity and best practices in RSpec test suites. This gem helps ensure your Ruby code has proper test coverage and follows RSpec conventions.
+
+## Features
+
+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
+
+### RSpecParity/FileHasSpec
+
+Ensures every Ruby file in your app directory has a corresponding spec file.
+
+```ruby
+# bad - app/models/user.rb exists but spec/models/user_spec.rb doesn't
+# This will trigger an offense
+
+# good - both files exist:
+# app/models/user.rb
+# spec/models/user_spec.rb
+```
+
+### RSpecParity/PublicMethodHasSpec
+
+Ensures every public method has spec test coverage.
+
+```ruby
+# bad - app/services/user_creator.rb
+class UserCreator
+  def create(params)  # No spec coverage for this method
+    User.create(params)
+  end
+end
+
+# good - app/services/user_creator.rb with spec/services/user_creator_spec.rb
+class UserCreator
+  def create(params)
+    User.create(params)
+  end
+end
+
+# spec/services/user_creator_spec.rb
+RSpec.describe UserCreator do
+  describe '#create' do
+    it 'creates a user' do
+      # test implementation
+    end
+  end
+end
+```
+
+### RSpecParity/SufficientContexts
+
+Ensures specs have at least as many contexts as the method has branches.
+
+```ruby
+# bad - app/services/user_creator.rb
+def create_user(params)
+  if params[:admin]
+    create_admin(params)
+  elsif params[:moderator]
+    create_moderator(params)
+  else
+    create_regular_user(params)
+  end
+end
+
+# spec/services/user_creator_spec.rb - only 1 context for 3 branches
+RSpec.describe UserCreator do
+  describe '#create_user' do
+    context 'when creating users' do
+      # Only one context for 3 branches - triggers offense
+    end
+  end
+end
+
+# good - 3 contexts for 3 branches
+RSpec.describe UserCreator do
+  describe '#create_user' do
+    context 'when admin' do
+      # tests admin branch
+    end
+
+    context 'when moderator' do
+      # tests moderator branch
+    end
+
+    context 'when regular user' do
+      # tests regular user branch
+    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
+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
+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
+
+  it 'does something' do
+    expect(user).to be_persisted
+  end
+end
+```
+
+## Assumptions
+
+These cops work based on the following conventions:
+
+- **File organization**: Each Ruby file has a corresponding spec file stored in the `spec/` directory, mirroring the same directory structure. For example, `app/models/user.rb` should have a spec at `spec/models/user_spec.rb`.
+- **Spec file naming**: Spec files use the `_spec.rb` suffix.
+- **Instance method specs**: Instance methods are tested using the convention `describe '#method_name' do`.
+- **Class method specs**: Class methods are tested using the convention `describe '.class_method' do`.
+- **Context blocks for branches**: The `SufficientContexts` cop counts `context` blocks within a method's `describe` block to ensure each branch path is tested.
+
+If your project uses different conventions, these cops may not work as expected.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'rubocop-rspec_parity', require: false
+```
+
+And then execute:
+
+```bash
+bundle install
+```
+
+Or install it directly:
+
+```bash
+gem install rubocop-rspec_parity
+```
+
+## Usage
+
+Add `rubocop-rspec_parity` to your `.rubocop.yml`:
+
+```yaml
+require:
+  - rubocop-rspec_parity
+
+# For RuboCop >= 1.72
+plugins:
+  - rubocop-rspec_parity
+```
+
+The default configuration enables all cops. You can customize them in your `.rubocop.yml`:
+
+```yaml
+RSpecParity/FileHasSpec:
+  Enabled: true
+  Include:
+    - 'app/**/*.rb'
+  Exclude:
+    - 'app/assets/**/*'
+    - 'app/views/**/*'
+
+RSpecParity/PublicMethodHasSpec:
+  Enabled: true
+  Include:
+    - 'app/**/*.rb'
+
+RSpecParity/SufficientContexts:
+  Enabled: true
+  Include:
+    - 'app/**/*.rb'
+  Exclude:
+    - 'app/assets/**/*'
+    - 'app/views/**/*'
+
+RSpecParity/NoLetBang:
+  Enabled: true
+  Include:
+    - 'spec/**/*_spec.rb'
+```
+
+Run RuboCop as usual:
+
+```bash
+bundle exec rubocop
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/povilasjurcys/rubocop-rspec_parity. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/povilasjurcys/rubocop-rspec_parity/blob/main/CODE_OF_CONDUCT.md).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the RuboCop RSpecParity project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/povilasjurcys/rubocop-rspec_parity/blob/main/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/config/default.yml

@@ -0,0 +1,37 @@
+# Default configuration for rubocop-rspec_parity
+
+RSpecParity/FileHasSpec:
+  Description: 'Checks that each Ruby file in the app directory has a corresponding spec file.'
+  Enabled: true
+  Include:
+    - 'app/**/*.rb'
+  Exclude:
+    - 'app/assets/**/*'
+    - 'app/views/**/*'
+    - 'app/javascript/**/*'
+
+RSpecParity/PublicMethodHasSpec:
+  Description: 'Checks that each public method has a corresponding spec test.'
+  Enabled: true
+  Include:
+    - 'app/**/*.rb'
+  Exclude:
+    - 'app/assets/**/*'
+    - 'app/views/**/*'
+    - 'app/javascript/**/*'
+
+RSpecParity/SufficientContexts:
+  Description: 'Ensures specs have at least as many contexts as the method has branches.'
+  Enabled: 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/no_let_bang.rb

@@ -0,0 +1,36 @@
+# 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

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

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpecParity
+      # Checks that each public method in a class has a corresponding spec test.
+      #
+      # @example
+      #   # bad - public method `perform` exists but no describe '#perform' in spec
+      #
+      #   # good - public method `perform` has describe '#perform' in spec
+      #
+      class PublicMethodHasSpec < Base
+        MSG = "Missing spec for public method `%<method_name>s`. " \
+              "Expected describe '#%<method_name>s' or describe '.%<method_name>s' in %<spec_path>s"
+
+        COVERED_DIRECTORIES = %w[models controllers services jobs mailers helpers].freeze
+        EXCLUDED_METHODS = %w[initialize].freeze
+        EXCLUDED_PATTERNS = [/^before_/, /^after_/, /^around_/, /^validate_/, /^autosave_/].freeze
+        VISIBILITY_METHODS = { private: :private, protected: :protected, public: :public }.freeze
+
+        def on_def(node)
+          return unless checkable_method?(node) && public_method?(node)
+
+          check_method_has_spec(node, instance_method: !inside_eigenclass?(node))
+        end
+
+        def on_defs(node)
+          return unless checkable_method?(node)
+
+          check_method_has_spec(node, instance_method: false)
+        end
+
+        private
+
+        def checkable_method?(node)
+          should_check_file? && !excluded_method?(node.method_name.to_s)
+        end
+
+        def inside_eigenclass?(node)
+          node.each_ancestor.any? { |a| a.sclass_type? && a.children.first&.self_type? }
+        end
+
+        def should_check_file?
+          path = processed_source.file_path
+          return false if path.nil? || !path.include?("/app/") || path.end_with?("_spec.rb")
+
+          COVERED_DIRECTORIES.any? { |dir| path.include?("/app/#{dir}/") }
+        end
+
+        def public_method?(node)
+          return false if node.nil?
+
+          class_or_module = find_class_or_module(node)
+          return true unless class_or_module
+
+          compute_visibility(class_or_module, node) == :public
+        end
+
+        def find_class_or_module(node)
+          node.each_ancestor.find { |n| n.class_type? || n.module_type? }
+        end
+
+        def compute_visibility(class_or_module, target_node)
+          visibility = :public
+          class_or_module.body&.each_child_node do |child|
+            break if child == target_node
+
+            visibility = update_visibility(child, visibility)
+          end
+          visibility
+        end
+
+        def update_visibility(child, current_visibility)
+          return current_visibility unless child.send_type?
+
+          VISIBILITY_METHODS.fetch(child.method_name, current_visibility)
+        end
+
+        def excluded_method?(method_name)
+          EXCLUDED_METHODS.include?(method_name) ||
+            EXCLUDED_PATTERNS.any? { |pattern| pattern.match?(method_name) }
+        end
+
+        def check_method_has_spec(node, instance_method:)
+          spec_path = expected_spec_path
+          return unless spec_path && File.exist?(spec_path)
+
+          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)
+        end
+
+        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/")
+        end
+
+        def add_method_offense(node, method_name, spec_path)
+          add_offense(
+            node.loc.keyword.join(node.loc.name),
+            message: format(MSG, method_name: method_name, spec_path: relative_spec_path(spec_path))
+          )
+        end
+
+        def method_tested_in_spec?(spec_path, method_name, instance_method)
+          spec_content = File.read(spec_path)
+          prefix = instance_method ? "#" : "."
+          test_patterns(prefix, method_name).any? { |pattern| spec_content.match?(pattern) }
+        end
+
+        def test_patterns(prefix, method_name)
+          escaped_prefix = Regexp.escape(prefix)
+          escaped_name = Regexp.escape(method_name)
+          [
+            /describe\s+['"]#{escaped_prefix}#{escaped_name}['"]/,
+            /context\s+['"]#{escaped_prefix}#{escaped_name}['"]/,
+            /it\s+['"](tests?|checks?|verifies?|validates?)\s+#{escaped_name}/i,
+            /describe\s+['"]#{escaped_name}['"]/
+          ]
+        end
+
+        def expected_spec_path
+          processed_source.file_path&.sub("/app/", "/spec/")&.sub(/\.rb$/, "_spec.rb")
+        end
+
+        def relative_spec_path(spec_path)
+          root = find_project_root
+          root ? spec_path.sub("#{root}/", "") : spec_path
+        end
+
+        def find_project_root
+          path = processed_source.file_path
+          return nil if path.nil?
+
+          app_index = path.split("/").index("app")
+          app_index ? path.split("/")[0...app_index].join("/") : nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,227 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpecParity
+      # Ensures that specs have at least as many contexts as the method has branches.
+      #
+      # This cop helps ensure thorough test coverage by checking that complex methods
+      # with multiple branches (if/elsif/else, case/when, &&, ||, ternary) have
+      # corresponding context blocks in their specs to test each branch.
+      #
+      # @example
+      #   # bad - method has 3 branches, spec has only 1 context
+      #   # app/services/user_creator.rb
+      #   def create_user(params)
+      #     if params[:admin]
+      #       create_admin(params)
+      #     elsif params[:moderator]
+      #       create_moderator(params)
+      #     else
+      #       create_regular_user(params)
+      #     end
+      #   end
+      #
+      #   # spec/services/user_creator_spec.rb
+      #   context 'when creating a user' do
+      #     # only one context for 3 branches
+      #   end
+      #
+      #   # good - method has 3 branches, spec has 3 contexts
+      #   # spec/services/user_creator_spec.rb
+      #   context 'when creating an admin' do
+      #   end
+      #   context 'when creating a moderator' do
+      #   end
+      #   context 'when creating a regular user' do
+      #   end
+      class SufficientContexts < Base # rubocop:disable Metrics/ClassLength
+        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."
+
+        COVERED_DIRECTORIES = %w[
+          app/models
+          app/controllers
+          app/services
+          app/jobs
+          app/mailers
+          app/helpers
+        ].freeze
+
+        EXCLUDED_METHODS = %w[initialize].freeze
+
+        EXCLUDED_PATTERNS = [
+          /^before_/,
+          /^after_/,
+          /^around_/,
+          /^validate_/,
+          /^autosave_/
+        ].freeze
+
+        def on_def(node)
+          check_method(node)
+        end
+
+        def on_defs(node)
+          check_method(node)
+        end
+
+        private
+
+        def check_method(node) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+          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)
+
+          spec_content = File.read(spec_file)
+          contexts = count_contexts_for_method(spec_content, method_name(node))
+
+          return if contexts >= branches
+
+          missing = branches - contexts
+          add_offense(node,
+                      message: format(MSG,
+                                      method_name: method_name(node),
+                                      branches: branches,
+                                      branch_word: pluralize("branch", branches),
+                                      contexts: contexts,
+                                      context_word: pluralize("context", contexts),
+                                      missing: missing,
+                                      missing_word: pluralize("context", missing)))
+        end
+
+        def method_name(node)
+          if node.def_type?
+            node.method_name.to_s
+          else
+            node.children[1].to_s
+          end
+        end
+
+        def in_covered_directory?
+          COVERED_DIRECTORIES.any? { |dir| processed_source.path.start_with?(dir) }
+        end
+
+        def excluded_method?(method_name)
+          return true if EXCLUDED_METHODS.include?(method_name)
+
+          EXCLUDED_PATTERNS.any? { |pattern| pattern.match?(method_name) }
+        end
+
+        def spec_file_path
+          path = processed_source.path
+          path.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
+
+          # Second pass: count branches, skipping elsif nodes
+          node.each_descendant do |descendant|
+            next if elsif_nodes.include?(descendant)
+
+            branches += branch_count_for_node(descendant)
+          end
+          branches
+        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
+          else 0
+          end
+        end
+
+        def count_if_branches(node)
+          # if/else is 2 branches, each elsif adds 1
+          branches = 2
+          current = node
+          while current&.if_type? && current.else_branch&.if_type?
+            branches += 1
+            current = current.else_branch
+          end
+          branches
+        end
+
+        def count_case_branches(node)
+          # Each when clause is a branch, plus default/else
+          when_count = node.when_branches.count
+          has_else = !node.else_branch.nil?
+          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)
+          in_method_block = false
+          context_count = 0
+          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)
+            elsif matches_context_pattern?(line, method_pattern)
+              context_count += 1
+            end
+          end
+
+          context_count
+        end
+
+        # rubocop:enable Metrics/MethodLength
+        def matches_method_describe?(line, method_pattern)
+          line =~ /^\s*describe\s+['"](?:#|\.)?#{method_pattern}['"]/ ||
+            line =~ /^\s*describe\s+:#{method_pattern}/
+        end
+
+        def matches_context_pattern?(line, method_pattern)
+          line =~ /^\s*(?:context|describe)\s+.*(?:#|\.)?#{method_pattern}/
+        end
+
+        def nested_context?(line)
+          line =~ /^\s*(?:context|describe)\s+/
+        end
+
+        def exiting_block?(line, current_indent, base_indent)
+          current_indent <= base_indent && line =~ /^\s*(?:describe|context|end)/
+        end
+
+        def pluralize(word, count)
+          return word if count == 1
+
+          case word
+          when "branch" then "branches"
+          when "context" then "contexts"
+          else "#{word}s"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/rspec_parity/plugin.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "lint_roller"
+
+module RuboCop
+  module RSpecParity
+    # LintRoller plugin for RuboCop integration (RuboCop >= 1.72)
+    class Plugin < LintRoller::Plugin
+      def about
+        LintRoller::About.new(
+          name: "rubocop-rspec_parity",
+          version: VERSION,
+          homepage: "https://github.com/povilasjurcys/rubocop-rspec_parity",
+          description: "RuboCop cops for RSpec parity checks"
+        )
+      end
+
+      def supported?(context)
+        context.engine == :rubocop
+      end
+
+      def rules(_context)
+        project_root = Pathname.new(__dir__).join("../../..")
+
+        LintRoller::Rules.new(
+          type: :path,
+          config_format: :rubocop,
+          value: project_root.join("config", "default.yml")
+        )
+      end
+    end
+  end
+end

data/lib/rubocop/rspec_parity/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module RSpecParity
+    VERSION = "0.1.0"
+  end
+end

data/lib/rubocop/rspec_parity.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require_relative "rspec_parity/version"
+
+module RuboCop
+  module RSpecParity
+    class Error < StandardError; end
+  end
+end

data/lib/rubocop-rspec_parity.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "rubocop_rspec_parity"

data/lib/rubocop_rspec_parity.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+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"

data/sig/rubocop/rspec_parity.rbs

@@ -0,0 +1,6 @@
+module Rubocop
+  module SpecParity
+    VERSION: String
+    # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+  end
+end

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification
+name: rubocop-rspec_parity
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Povilas Jurcys
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: lint_roller
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.72.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.72.0
+description: A RuboCop plugin that provides custom cops to ensure RSpec test coverage
+  parity and enforce RSpec best practices in your Ruby projects.
+email:
+- po.jurcys@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".ruby-version"
+- CHANGELOG.md
+- CLAUDE.md
+- CODE_OF_CONDUCT.md
+- LICENSE.txt
+- README.md
+- 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
+- lib/rubocop/rspec_parity/plugin.rb
+- lib/rubocop/rspec_parity/version.rb
+- lib/rubocop_rspec_parity.rb
+- sig/rubocop/rspec_parity.rbs
+homepage: https://github.com/povilasjurcys/rubocop-rspec_parity
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/povilasjurcys/rubocop-rspec_parity
+  source_code_uri: https://github.com/povilasjurcys/rubocop-rspec_parity
+  changelog_uri: https://github.com/povilasjurcys/rubocop-rspec_parity/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+  default_lint_roller_plugin: RuboCop::RSpecParity::Plugin
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.4
+specification_version: 4
+summary: RuboCop plugin for enforcing RSpec spec parity and best practices
+test_files: []