rubocop-vicenzo 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 93a0df32e2fd3e164d0b7380c341fe12eb61a46143f4ec15f990961d72d1a611
+  data.tar.gz: ff138db061137acee6d7067d4cb9e3301d36f6ea33dac8cd494d9a616c8c2ac6
+SHA512:
+  metadata.gz: 0b5ddd5178c5866f85d86624f5709cb52a51444b2077363e2a73242feaeb80933e435e8009edbff123e786f01a671e7b7e0d8946e1e06096cb7dc747967f9ab1
+  data.tar.gz: d79145ff57444fa82a3a4dd89375821b77755841eeac1b373698784bab36a7c4448f609c4733de6b1206460684d3db3ab423b234ef661ad423ac47ea4df38c65

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,27 @@
+plugins:
+  - rubocop-performance
+  - rubocop-rake
+  - rubocop-rspec
+  - rubocop-vicenzo
+  - rubocop-internal_affairs
+
+AllCops:
+  NewCops: enable
+
+Naming/FileName:
+  Exclude:
+    - lib/rubocop-vicenzo.rb
+
+RSpec/ContextWording:
+  Prefixes:
+    - and
+    - but
+    - when
+    - with
+    - without
+
+RSpec/ExampleLength:
+  Enabled: false
+
+RSpec/NestedGroups:
+  Enabled: false

data/CHANGELOG.md

@@ -0,0 +1,12 @@
+## [Unreleased]
+
+## [0.1.0] - 2025-04-02
+
+- Initial release;
+- Add RoboCop::Cop::Vicenzo::RSpec::NestedLetRedefinition #1;
+- Add RoboCop::Cop::Vicenzo::RSpec::NestedSubjectRedefinition #2;
+- Add RuboCop::Cop::Vicenzo::Rails::EnumInclusionOfValidation #3;
+- Add RuboCop::Cop::Vicenzo::RSpec::NestedContextImproperStart #4;
+- Add RuboCop::Cop::Vicenzo::RSpec::MixedExampleGroups #6;
+
+- Change RuboCop::Cop::Vicenzo::RSpec::NestedContextImproperStart inherits from Rspec::Base #5;

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) 2025 Bruno Vicenzo
+
+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,74 @@
+# RuboCop::Vicenzo
+
+[![Ruby](https://github.com/bvicenzo/rubocop-vicenzo/actions/workflows/main.yml/badge.svg)](https://github.com/bvicenzo/rubocop-vicenzo/actions/workflows/main.yml)
+
+## Installation
+
+Install the gem and add to the application's Gemfile by executing:
+
+```bash
+bundle add rubocop-vicenzo --group=development --require=false
+```
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+```bash
+gem install rubocop-vicenzo
+```
+
+## Usage
+
+You need to tell RuboCop to load the Vicenzo extension. There are three
+ways to do this:
+
+### RuboCop configuration file
+
+Put this into your `.rubocop.yml`.
+
+```yaml
+plugins: rubocop-vicenzo
+```
+
+Alternatively, use the following array notation when specifying multiple extensions.
+
+```yaml
+plugins:
+  - rubocop-other-extension
+  - rubocop-vicenzo
+```
+
+Now you can run `rubocop` and it will automatically load the RuboCop Vicenzo
+cops together with the standard cops.
+
+> [!NOTE]
+> The plugin system is supported in RuboCop 1.72+. In earlier versions, use `require` instead of `plugins`.
+
+### Command line
+
+```bash
+rubocop --plugin rubocop-vicenzo
+```
+
+## 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).
+
+### Creating a new cop
+
+```bash
+bundle exec rake 'new_cop[Vicenzo/OptionalNamespace/CopName]'
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/rubocop-vicenzo. 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/[USERNAME]/rubocop-vicenzo/blob/master/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::Vicenzo project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/rubocop-vicenzo/blob/master/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.rspec_opts = '--format progress'
+end
+
+require 'rubocop/rake_task'
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]
+
+desc 'Generate a new cop with a template'
+task :new_cop, [:cop] do |_task, args|
+  require 'rubocop'
+
+  cop_name = args.fetch(:cop) do
+    warn 'usage: bundle exec rake new_cop[Department/Name]'
+    exit!
+  end
+
+  generator = RuboCop::Cop::Generator.new(cop_name)
+
+  generator.write_source
+  generator.write_spec
+  generator.inject_require(root_file_path: 'lib/rubocop/cop/vicenzo_cops.rb')
+  generator.inject_config(config_file_path: 'config/default.yml')
+
+  puts generator.todo
+end

data/config/default.yml

@@ -0,0 +1,25 @@
+Vicenzo/RSpec/MixedExampleGroups:
+  Description: 'Check if there are example and groups at same level'
+  Enabled: warning
+  VersionAdded: '0.1.0'
+
+Vicenzo/RSpec/NestedContextImproperStart:
+  Description: 'Check if the nested context does not start as a root one.'
+  Enabled: warning
+  VersionAdded: '0.1.0'
+
+Vicenzo/RSpec/NestedLetRedefinition:
+  Description: 'Check if a let is redefined in a nested example group.'
+  Enabled: true
+  Severity: warning
+  VersionAdded: '0.1.0'
+
+Vicenzo/RSpec/NestedSubjectRedefinition:
+  Description: 'Check if a subject is redefined in a nested example group.'
+  Enabled: warning
+  VersionAdded: '0.1.0'
+
+Vicenzo/Rails/EnumInclusionOfValidation:
+  Description: 'Check if the enum has the inclusion of validation defined.'
+  Enabled: convention
+  VersionAdded: '0.1.0'

data/lib/rubocop/cop/vicenzo/rails/enum_inclusion_of_validation.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Vicenzo
+      module Rails
+        # Ensures that enums using the new syntax include the
+        # `validate: { allow_nil: true }` option.
+        #
+        # ## Bad usage
+        #
+        # ```ruby
+        # enum :status, { active: 1, inactive: 0 }, suffix: true
+        # ```
+        #
+        # ```ruby
+        # enum :status, { active: 1, inactive: 0 }, validate: true, suffix: true
+        # ```
+        #
+        # ## Good usage
+        #
+        # ```ruby
+        # enum :status, { active: 1, inactive: 0 }, validate: { allow_nil: true }, suffix: true
+        # ```
+        #
+        # This cop does not enforce validation on enums using the old syntax:
+        #
+        # ```ruby
+        # enum status: { active: 1, inactive: 0 }
+        # ```
+        class EnumInclusionOfValidation < Base
+          extend AutoCorrector
+
+          MSG_MISSING_VALIDATE = 'Add `validate: { allow_nil: true }` to the enum.'
+          MSG_INVALID_VALIDATE = 'The `validate` option for the enum must be `validate: { allow_nil: true }`.'
+
+          RESTRICT_ON_SEND = [:enum].freeze
+
+          def on_send(node)
+            return unless node.command?(:enum)
+
+            # Ignore old-style enums
+            first_argument = node.first_argument
+            return if first_argument&.hash_type?
+
+            validate_kwarg = find_validate_option(node)
+
+            register_offence_for(node, validate_kwarg)
+          end
+          alias on_csend on_send
+
+          private
+
+          def find_validate_option(enum_node)
+            enum_node.last_argument.each_pair.find { |pair| pair.key.value == :validate }
+          end
+
+          def valid_validate_option?(validate_kwarg)
+            validate_kwarg.value.hash_type? &&
+              validate_kwarg.value.each_pair.any? do |pair|
+                pair.key.value == :allow_nil && pair.value.true_type?
+              end
+          end
+
+          def last_hash_node(enum_node)
+            enum_node.last_argument if enum_node.last_argument.hash_type?
+          end
+
+          def register_offence_for(enum_node, validate_kwarg)
+            if validate_kwarg.nil?
+              add_offense(enum_node, message: MSG_MISSING_VALIDATE) do |corrector|
+                corrector.insert_after(last_hash_node(enum_node), ', validate: { allow_nil: true }')
+              end
+            elsif !valid_validate_option?(validate_kwarg)
+              add_offense(validate_kwarg, message: MSG_INVALID_VALIDATE) do |corrector|
+                corrector.replace(validate_kwarg, 'validate: { allow_nil: true }')
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/vicenzo/rspec/mixed_example_groups.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Vicenzo
+      module RSpec
+        # Ensures that examples (`it`, `specify`, `example`)
+        # are not mixed with groups (`describe`, `context`) at the same level.
+        #
+        # @example
+        #   # bad
+        #   RSpec.describe User do
+        #     it { is_expected.to validate_presence_of(:name) }
+        #     describe '#admin?' do
+        #       it { expect(true).to eq(true) }
+        #     end
+        #   end
+        #
+        #   # bad
+        #   RSpec.describe User do
+        #     describe '#admin?' do
+        #       it { expect(true).to eq(true) }
+        #       context 'when email starts with' do
+        #       end
+        #     end
+        #   end
+        #
+        #   # good
+        #   RSpec.describe User do
+        #     describe '#admin?' do
+        #       context 'when email starts with' do
+        #         it { expect(true).to eq(true) }
+        #       end
+        #     end
+        #   end
+        class MixedExampleGroups < RuboCop::Cop::RSpec::Base
+          MSG = 'Do not mix examples (`it`, `specify`, `example`) with groups (`describe`, `context`) ' \
+                'at the same level.'
+
+          def on_block(node)
+            return unless example_or_group?(node)
+
+            parent = node.parent
+            return unless parent
+
+            children = parent.children.select { |child| example_or_group?(child) }
+            example_nodes, group_nodes = children.partition { |n| example?(n) }
+
+            return if example_nodes.empty? || group_nodes.empty?
+
+            add_offense(node)
+          end
+
+          alias on_numblock on_block
+
+          private
+
+          def example_or_group?(node)
+            example?(node) || example_group?(node)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/vicenzo/rspec/nested_context_improper_start.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Vicenzo
+      module RSpec
+        # Checks for nested `context` blocks where the inner `context`
+        # starts with "when", "with", or "without". It suggests replacing it with "and", "but", or "however".
+        #
+        # @example
+        #   # bad
+        #   context 'when the product is for sale' do
+        #     context 'when the color pink is not available' do
+        #       it 'does not show the pink option'
+        #     end
+        #   end
+        #
+        #   # good
+        #   context 'when the product is for sale' do
+        #     context 'but the color pink is not available' do
+        #       it 'does not show the pink option'
+        #     end
+        #   end
+        class NestedContextImproperStart < RuboCop::Cop::RSpec::Base
+          MSG = 'Nested `context` should start with `and`, `but`, or `however`, not `when`, `with`, or `without`.'
+
+          FORBIDDEN_PREFIXES = %w[when with without].freeze
+
+          def on_block(node)
+            return unless context_block?(node) && context_block?(node.parent)
+
+            context_description = description_for(node)
+            return unless context_description
+
+            first_word = context_description.split.first&.downcase
+            return unless FORBIDDEN_PREFIXES.include?(first_word)
+
+            add_offense(node.send_node)
+          end
+
+          alias on_numblock on_block
+
+          private
+
+          def context_block?(node)
+            !node.nil? && node.block_type? && node.send_node.command?(:context)
+          end
+
+          def description_for(context_node)
+            description = context_node.send_node.first_argument
+
+            return if description.nil?
+
+            description.source.delete_prefix("'").delete_suffix("'")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/vicenzo/rspec/nested_let_redefinition.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Vicenzo
+      module RSpec
+        # Do not define the same let in nested example groups.
+        #
+        # It makes the tests more dificult to read and indicates that exists hidden scenarios (contexts)
+        #
+        # @example `Hidden context`
+        #
+        #   # bad
+        #
+        #   describe '#authorized?' do
+        #     subject(:action) { create(:action) }
+        #     let(:user) { create(:user, :admin) }
+        #
+        #     it { expect(action).to be_authorized(user) }
+        #
+        #     context 'when user is not admin' do
+        #       let(:user) { create(:user, :analyst) }
+        #
+        #       it { expect(action).not_to be_authorized(user) }
+        #     end
+        #   end
+        #
+        #   # good
+        #
+        #   describe '#authorized?' do
+        #     subject(:action) { create(:action) }
+        #
+        #     context 'when user is not admin' do
+        #       let(:user) { create(:user, :analyst) }
+        #
+        #       it { expect(action).not_to be_authorized(user) }
+        #     end
+        #
+        #     context 'when user is admin' do # this context was hidden
+        #       let(:user) { create(:user, :admin) }
+        #
+        #       it { expect(action).to be_authorized(user) }
+        #     end
+        #   end
+        class NestedLetRedefinition < RuboCop::Cop::RSpec::Base
+          MSG = 'Let `:%<name>s` is already defined in ancestor(s) block(s) at: %<definitions>s.'
+
+          # @!method let_name(node)
+          def_node_matcher :let_name, <<~PATTERN
+            {
+              (block (send nil? #Helpers.all ({str sym} $_) ...) ...)
+              (send nil? #Helpers.all ({str sym} $_) block_pass)
+            }
+          PATTERN
+
+          # @!method let_it_be_name(node)
+          def_node_matcher :let_it_be_name, <<~PATTERN
+            {
+              (block (send nil? {:let_it_be :let_it_be!} ({str sym} $_) ...) ...)
+              (send nil? {:let_it_be :let_it_be!} ({str sym} $_) block_pass)
+            }
+          PATTERN
+
+          # @!method let_it_be?(node)
+          def_node_matcher :let_it_be?, <<~PATTERN
+            {
+              (block (send nil? {:let_it_be :let_it_be!} ...) ...)
+              (send nil? {:let_it_be :let_it_be!} _ block_pass)
+            }
+          PATTERN
+
+          def on_block(node)
+            check_let_redefinitions(node, {}) if example_group?(node)
+          end
+
+          alias on_numblock on_block
+
+          private
+
+          def check_let_redefinitions(node, let_definitions)
+            node.body.each_child_node do |child|
+              if child.block_type?
+                if example_group?(child)
+                  check_let_redefinitions(child, let_definitions.dup)
+                elsif let?(child) || let_it_be?(child)
+                  check_let(child, let_definitions)
+                end
+              end
+            end
+          end
+
+          def check_let(let_node, let_definitions)
+            name = (let_name(let_node) || let_it_be_name(let_node)).to_s.to_sym
+
+            if let_definitions.key?(name)
+              add_offense(let_node, message: redefined_let_message(name, let_definitions))
+              let_definitions[name] << line_location(let_node)
+            else
+              let_definitions[name] = [line_location(let_node)]
+            end
+          end
+
+          def redefined_let_message(name, let_definitions)
+            format(MSG, name:, definitions: let_definitions[name].join(', '))
+          end
+
+          def line_location(node)
+            node.source_range.line
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/vicenzo/rspec/nested_subject_redefinition.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Vicenzo
+      module RSpec
+        # Do not define the same let in nested example groups.
+        #
+        # It makes the tests more dificult to read and indicates that exists hidden scenarios (contexts)
+        #
+        # @example `Hidden context`
+        #
+        #   # bad
+        #
+        #   describe '#can_access?' do
+        #     subject(:user) { create(:user, :admin) }
+        #
+        #     it { expect(user).to can_access(:products) }
+        #
+        #     context 'when user is not admin' do
+        #       subject(:user) { create(:user, :analyst) }
+        #
+        #       it { expect(user).not_to can_access(:products) }
+        #     end
+        #   end
+        #
+        #   # good
+        #
+        #   describe '#can_access?' do
+        #     context 'when user is not admin' do
+        #       subject(:user) { create(:user, :analyst) }
+        #
+        #       it { expect(user).not_to can_access(:products) }
+        #     end
+        #
+        #     context 'when user is admin' do # this context was hidden
+        #       subject(:user) { create(:user, :admin) }
+        #
+        #       it { expect(action).to can_access(:products) }
+        #     end
+        #   end
+        class NestedSubjectRedefinition < RuboCop::Cop::RSpec::Base
+          MSG = 'Subject `:%<name>s` is already defined in ancestor(s) block(s) at: %<definitions>s.'
+
+          # @!method subject_name(node)
+          #   Find a named or unnamed subject definition
+          #
+          #   @example anonymous subject
+          #     subject_name(parse('subject { foo }').ast) do |name|
+          #       name # => :subject
+          #     end
+          #
+          #   @example named subject
+          #     subject_name(parse('subject(:thing) { foo }').ast) do |name|
+          #       name # => :thing
+          #     end
+          #
+          #   @param node [RuboCop::AST::Node]
+          #
+          #   @yield [Symbol] subject name
+          def_node_matcher :subject_name, <<-PATTERN
+            (block
+              (send nil?
+                { #Subjects.all (sym $_) | $#Subjects.all }
+              ) args ...)
+          PATTERN
+
+          def on_block(node)
+            check_subject_redefinitions(node, {}) if example_group?(node)
+          end
+
+          alias on_numblock on_block
+
+          private
+
+          def name_for(subject_node)
+            name = subject_name(subject_node)
+
+            name == :subject ? :anonymous : name
+          end
+
+          def check_subject_redefinitions(node, subject_definitions)
+            node.body.each_child_node do |child|
+              if child.block_type?
+                if example_group?(child)
+                  check_subject_redefinitions(child, subject_definitions.dup)
+                elsif subject?(child)
+                  check_subject(child, subject_definitions)
+                end
+              end
+            end
+          end
+
+          def check_subject(subject_node, subject_definitions)
+            name = name_for(subject_node)
+
+            if subject_definitions.key?(name)
+              add_offense(subject_node, message: redefined_subject_message(name, subject_definitions))
+              subject_definitions[name] << line_location(subject_node)
+            else
+              subject_definitions[name] = [line_location(subject_node)]
+            end
+          end
+
+          def redefined_subject_message(name, subject_definitions)
+            format(MSG, name:, definitions: subject_definitions[name].join(', '))
+          end
+
+          def line_location(node)
+            node.source_range.line
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/vicenzo_cops.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require_relative 'vicenzo/rspec/mixed_example_groups'
+require_relative 'vicenzo/rspec/nested_context_improper_start'
+require_relative 'vicenzo/rspec/nested_let_redefinition'
+require_relative 'vicenzo/rspec/nested_subject_redefinition'
+require_relative 'vicenzo/rails/enum_inclusion_of_validation'

data/lib/rubocop/vicenzo/plugin.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'lint_roller'
+
+module RuboCop
+  module Vicenzo
+    # A plugin that integrates rubocop-vicenzo with RuboCop's plugin system.
+    class Plugin < LintRoller::Plugin
+      def about
+        LintRoller::About.new(
+          name: 'rubocop-vicenzo',
+          version: VERSION,
+          homepage: 'https://github.com/bvicenzo/rubocop-vicenzo/',
+          description: 'Cops created for sharing years of experiments of good practices.'
+        )
+      end
+
+      def supported?(context)
+        context.engine == :rubocop
+      end
+
+      def rules(_context)
+        LintRoller::Rules.new(
+          type: :path,
+          config_format: :rubocop,
+          value: Pathname.new(__dir__).join('../../../config/default.yml')
+        )
+      end
+    end
+  end
+end

data/lib/rubocop/vicenzo/version.rb

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

data/lib/rubocop/vicenzo.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require_relative 'vicenzo/version'
+
+module RuboCop
+  # Vicenzo's Cop
+  module Vicenzo
+  end
+end

data/lib/rubocop-vicenzo.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'rubocop'
+require 'rubocop-rspec'
+
+require_relative 'rubocop/vicenzo'
+require_relative 'rubocop/vicenzo/version'
+require_relative 'rubocop/vicenzo/plugin'
+
+require_relative 'rubocop/cop/vicenzo_cops'

data/sig/rubocop/vicenzo.rbs

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

metadata

@@ -0,0 +1,107 @@
+--- !ruby/object:Gem::Specification
+name: rubocop-vicenzo
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Bruno Vicenzo
+bindir: exe
+cert_chain: []
+date: 2025-04-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.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.72.2
+- !ruby/object:Gem::Dependency
+  name: rubocop-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.5.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.5.0
+description: Cops with good pratices I have been learning
+email:
+- bruno@alumni.usp.br
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".rubocop.yml"
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- config/default.yml
+- lib/rubocop-vicenzo.rb
+- lib/rubocop/cop/vicenzo/rails/enum_inclusion_of_validation.rb
+- lib/rubocop/cop/vicenzo/rspec/mixed_example_groups.rb
+- lib/rubocop/cop/vicenzo/rspec/nested_context_improper_start.rb
+- lib/rubocop/cop/vicenzo/rspec/nested_let_redefinition.rb
+- lib/rubocop/cop/vicenzo/rspec/nested_subject_redefinition.rb
+- lib/rubocop/cop/vicenzo_cops.rb
+- lib/rubocop/vicenzo.rb
+- lib/rubocop/vicenzo/plugin.rb
+- lib/rubocop/vicenzo/version.rb
+- sig/rubocop/vicenzo.rbs
+homepage: https://github.com/bvicenzo/rubocop-vicenzo
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/bvicenzo/rubocop-vicenzo
+  source_code_uri: https://github.com/bvicenzo/rubocop-vicenzo
+  changelog_uri: https://github.com/bvicenzo/rubocop-vicenzo/blob/master/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+  default_lint_roller_plugin: RuboCop::Vicenzo::Plugin
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.2
+specification_version: 4
+summary: Cops of Bruno Vicenzo
+test_files: []