rubocop-vicenzo 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 93a0df32e2fd3e164d0b7380c341fe12eb61a46143f4ec15f990961d72d1a611
-  data.tar.gz: ff138db061137acee6d7067d4cb9e3301d36f6ea33dac8cd494d9a616c8c2ac6
+  metadata.gz: b430ab160562cd140cd498e015dbf4e2c03a6bd99189ae24adc00881a3bbab48
+  data.tar.gz: 3757afc640413d2ed6548319003ecf62be4cc84658673d430e5ff8236936f2d6
 SHA512:
-  metadata.gz: 0b5ddd5178c5866f85d86624f5709cb52a51444b2077363e2a73242feaeb80933e435e8009edbff123e786f01a671e7b7e0d8946e1e06096cb7dc747967f9ab1
-  data.tar.gz: d79145ff57444fa82a3a4dd89375821b77755841eeac1b373698784bab36a7c4448f609c4733de6b1206460684d3db3ab423b234ef661ad423ac47ea4df38c65
+  metadata.gz: 4b2cbdc348b8faa2dd97e722e78e5c8956b67da26df8541314990331a645b156c758540d6602960e8f96340a6294bf0a35a833b4f2d5a1a237349bbb91f58ba6
+  data.tar.gz: 88b77a6119a722404ad6d263f61ed53423e4991ae216bd8ea2295712fa72c5536b902948bea8c61e2f32e832444e356c2a0b16ae2f4a8727993acd063db40130

data/.rubocop.yml

@@ -25,3 +25,8 @@ RSpec/ExampleLength:
 
 RSpec/NestedGroups:
   Enabled: false
+
+Vicenzo/RSpec/LeakyDefinition:
+  Exclude:
+    - 'spec/support/**/*'
+    - 'spec/rubocop/cop/vicenzo/rspec/leaky_definition_spec.rb'

data/CHANGELOG.md

@@ -1,5 +1,22 @@
 ## [Unreleased]
 
+## [0.2.0] - 2025-11-27
+
+- Remove RuboCop::Cop::Vicenzo::RSpec::MixedExampleGroups in favor of InconsistentSiblingStructure #10;
+
+- Add RoboCop::Cop::Vicenzo::RSpec::LeakyDefinition #9;
+- Add RoboCop::Cop::Vicenzo::RSpec::InconsistentSiblingStructure #10;
+
+- Fix NestedContextImproperStart to deal with all nested contexts #10;
+- Fix NestedLetRedefinition to not point sibling lets as nested #10;
+- Fix NestedSubjectRedefinition to not point sibling lets as nested #10;
+
+
+## [0.1.1] - 2025-08-12
+
+- Add Rightly enable all cops #7;
+- Fix RuboCop::Cop::Vicenzo::Rails::EnumInclusionOfValidation working with array format and no options #7;
+
 ## [0.1.0] - 2025-04-02
 
 - Initial release;

data/config/default.yml

@@ -1,11 +1,19 @@
-Vicenzo/RSpec/MixedExampleGroups:
-  Description: 'Check if there are example and groups at same level'
-  Enabled: warning
+Vicenzo/Rails/EnumInclusionOfValidation:
+  Description: 'Check if the enum has the inclusion of validation defined.'
+  Enabled: true
+  Severity: convention
   VersionAdded: '0.1.0'
 
+Vicenzo/RSpec/InconsistentSiblingStructure:
+  Description: 'Enforces strict structural consistency (e.g. prevents mixing describe with context or examples with groups).'
+  Enabled: true
+  Severity: warning
+  VersionAdded: '0.2.0'
+
 Vicenzo/RSpec/NestedContextImproperStart:
   Description: 'Check if the nested context does not start as a root one.'
-  Enabled: warning
+  Enabled: true
+  Severity: convention
   VersionAdded: '0.1.0'
 
 Vicenzo/RSpec/NestedLetRedefinition:
@@ -16,10 +24,17 @@ Vicenzo/RSpec/NestedLetRedefinition:
 
 Vicenzo/RSpec/NestedSubjectRedefinition:
   Description: 'Check if a subject is redefined in a nested example group.'
-  Enabled: warning
+  Enabled: true
+  Severity: 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'
+Vicenzo/RSpec/LeakyDefinition:
+  Description: 'Do not define methods, classes, or modules directly in spec files (unless inside spec/support).'
+  Enabled: true
+  Severity: warning
+  VersionAdded: '0.2.0'
+  Include:
+    - '**/spec/**/*_spec.rb'
+  Exclude:
+    - '**/spec/support/**/*'
+    - '**/spec/factories/**/*'

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

@@ -52,7 +52,7 @@ module RuboCop
           private
 
           def find_validate_option(enum_node)
-            enum_node.last_argument.each_pair.find { |pair| pair.key.value == :validate }
+            options_node_for(enum_node)&.each_pair&.find { |pair| pair.key.value == :validate }
           end
 
           def valid_validate_option?(validate_kwarg)
@@ -62,14 +62,15 @@ module RuboCop
               end
           end
 
-          def last_hash_node(enum_node)
+          def options_node_for(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 }')
+                last_node = options_node_for(enum_node) || enum_node.last_argument
+                corrector.insert_after(last_node, ', validate: { allow_nil: true }')
               end
             elsif !valid_validate_option?(validate_kwarg)
               add_offense(validate_kwarg, message: MSG_INVALID_VALIDATE) do |corrector|

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

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Vicenzo
+      module RSpec
+        # Enforces strict structural consistency in RSpec files.
+        #
+        # It forbids mixing:
+        # 1. Examples (`it`) with Groups (`describe` or `context`)
+        # 2. Different types of Groups (`describe` with `context`)
+        #
+        # @example
+        #   # bad (Mixing Describe and Context)
+        #   RSpec.describe User do
+        #     describe '#admin?' do ... end
+        #     context 'when user is logged' do ... end
+        #   end
+        #
+        #   # bad (Mixing Example and Context)
+        #   RSpec.describe User do
+        #     it { is_expected.to be_valid }
+        #     context 'when invalid' do ... end
+        #   end
+        #
+        #   # good
+        #   RSpec.describe User do
+        #     describe '#admin?' do ... end
+        #     describe '#client?' do ... end
+        #   end
+        #
+        class InconsistentSiblingStructure < RuboCop::Cop::RSpec::Base
+          MSG = 'Do not mix %<type_a>s with %<type_b>s at the same level.'
+
+          EXAMPLES  = %i[it specify example scenario focus].freeze
+          DESCRIBES = %i[describe feature experiment].freeze
+          CONTEXTS  = %i[context].freeze
+
+          # @!method example_definition?(node)
+          def_node_matcher :example_definition?, <<~PATTERN
+            (block (send nil? {#{EXAMPLES.map(&:inspect).join(' ')}} ...) ...)
+          PATTERN
+
+          # @!method describe_definition?(node)
+          def_node_matcher :describe_definition?, <<~PATTERN
+            (block (send nil? {#{DESCRIBES.map(&:inspect).join(' ')}} ...) ...)
+          PATTERN
+
+          # @!method context_definition?(node)
+          def_node_matcher :context_definition?, <<~PATTERN
+            (block (send nil? {#{CONTEXTS.map(&:inspect).join(' ')}} ...) ...)
+          PATTERN
+
+          def on_block(node)
+            return unless example_group?(node)
+            return unless node.body
+
+            # Normaliza e classifica em passos separados
+            children = child_nodes_for(node)
+            found_nodes = classify_children(children)
+
+            validate_consistency(found_nodes)
+          end
+
+          alias on_numblock on_block
+
+          private
+
+          def child_nodes_for(node)
+            node.body.begin_type? ? node.body.each_child_node : [node.body]
+          end
+
+          def classify_children(nodes)
+            classified = { example: [], describe: [], context: [] }
+
+            nodes.each do |child|
+              next unless child.block_type?
+
+              type = node_type(child)
+              classified[type] << child if type
+            end
+
+            classified
+          end
+
+          def node_type(node)
+            if example_definition?(node)
+              :example
+            elsif describe_definition?(node)
+              :describe
+            elsif context_definition?(node)
+              :context
+            end
+          end
+
+          def validate_consistency(nodes)
+            present_types = nodes.keys.select { |type| nodes[type].any? }
+
+            return if present_types.size <= 1
+
+            check_pair(nodes, :example, :describe)
+            check_pair(nodes, :example, :context)
+            check_pair(nodes, :describe, :context)
+          end
+
+          def check_pair(nodes, type_a, type_b)
+            return unless nodes[type_a].any? && nodes[type_b].any?
+
+            nodes[type_b].each do |node|
+              add_offense(node, message: format(MSG, type_a: type_a, type_b: type_b))
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require 'rubocop'
+
+module RuboCop
+  module Cop
+    module Vicenzo
+      module RSpec
+        # Checks for methods, classes, or modules defined directly within
+        # RSpec blocks or at the top level of a spec file.
+        #
+        # Such definitions pollute the global namespace or the test class scope,
+        # leading to state leaking and intermittent test failures.
+        #
+        # @example
+        #   # bad
+        #   describe User do
+        #     def setup_user
+        #       # ...
+        #     end
+        #   end
+        #
+        #   # bad
+        #   def global_helper
+        #   end
+        #
+        #   # bad
+        #   def stub_service
+        #     allow(Service).to receive(:call)
+        #   end
+        #
+        #   # good
+        #   describe User do
+        #     let(:user) { create(:user) }
+        #   end
+        #
+        #   # good (inside anonymous class)
+        #   let(:model) do
+        #     Class.new do
+        #       def safe_method; end
+        #     end
+        #   end
+        #
+        #   # good
+        #   before do
+        #     allow(Service).to receive(:call)
+        #   end
+        #
+        class LeakyDefinition < RuboCop::Cop::RSpec::Base
+          MSG = 'Do not define methods, classes, or modules directly in the global scope or within spec blocks. ' \
+                'This pollutes the namespace. ' \
+                'Move this logic to `spec/support`, use `let`, before, ' \
+                'or encapsulate it within a safe structure (e.g., `Class.new`).'
+
+          # Matcher to identify dynamic class/module definitions commonly used in specs
+          # Looks for blocks applied to Class.new, Module.new, or Struct.new
+          # considers controller {} a valid mock
+          # @!method dynamic_definition?(node)
+          def_node_matcher :dynamic_definition?, <<~PATTERN
+            (block
+              {
+                (send (const {nil? cbase} {:Class :Module :Struct}) :new ...)
+                (send nil? :controller ...)
+              }
+              ...
+            )
+          PATTERN
+
+          def on_def(node)
+            check_node(node)
+          end
+
+          def on_class(node)
+            check_node(node)
+          end
+
+          def on_module(node)
+            check_node(node)
+          end
+
+          private
+
+          def check_node(node)
+            # If inside a safe scope (static or dynamic class/module), it's allowed.
+            return if inside_safe_scope?(node)
+
+            add_offense(node)
+          end
+
+          def inside_safe_scope?(node)
+            # Traverse ancestors to find a "protective shield"
+            node.each_ancestor.any? do |ancestor|
+              # 1. Is it a traditional definition? (class Foo; end)
+              next true if ancestor.type?(:class, :module)
+
+              # 2. Is it a dynamic definition? (Class.new do; end)
+              next true if dynamic_definition?(ancestor)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -26,32 +26,45 @@ module RuboCop
 
           FORBIDDEN_PREFIXES = %w[when with without].freeze
 
+          # @!method context_block?(node)
+          def_node_matcher :context_block?, <<~PATTERN
+            (block (send nil? :context ...) ...)
+          PATTERN
+
+          # @!method example_group_block?(node)
+          def_node_matcher :example_group_block?, <<~PATTERN
+            (block (send nil? {:describe :context :feature :example_group} ...) ...)
+          PATTERN
+
           def on_block(node)
-            return unless context_block?(node) && context_block?(node.parent)
+            return unless context_block?(node)
 
-            context_description = description_for(node)
-            return unless context_description
+            parent = find_closest_example_group(node)
 
-            first_word = context_description.split.first&.downcase
-            return unless FORBIDDEN_PREFIXES.include?(first_word)
+            return unless parent && context_block?(parent)
 
-            add_offense(node.send_node)
+            check_description(node)
           end
 
           alias on_numblock on_block
 
           private
 
-          def context_block?(node)
-            !node.nil? && node.block_type? && node.send_node.command?(:context)
+          def find_closest_example_group(node)
+            node.each_ancestor(:block).find { |ancestor| example_group_block?(ancestor) }
           end
 
-          def description_for(context_node)
-            description = context_node.send_node.first_argument
+          def check_description(node)
+            description_node = node.send_node.first_argument
 
-            return if description.nil?
+            return unless description_node&.str_type?
 
-            description.source.delete_prefix("'").delete_suffix("'")
+            text = description_node.value.to_s.strip
+            first_word = text.split.first&.downcase
+
+            return unless FORBIDDEN_PREFIXES.include?(first_word)
+
+            add_offense(node.send_node)
           end
         end
       end

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

@@ -90,11 +90,12 @@ module RuboCop
           end
 
           def check_let(let_node, let_definitions)
-            name = (let_name(let_node) || let_it_be_name(let_node)).to_s.to_sym
+            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)
+
+              let_definitions[name] += [line_location(let_node)]
             else
               let_definitions[name] = [line_location(let_node)]
             end

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

@@ -96,7 +96,7 @@ module RuboCop
 
             if subject_definitions.key?(name)
               add_offense(subject_node, message: redefined_subject_message(name, subject_definitions))
-              subject_definitions[name] << line_location(subject_node)
+              subject_definitions[name] += [line_location(subject_node)]
             else
               subject_definitions[name] = [line_location(subject_node)]
             end

data/lib/rubocop/cop/vicenzo_cops.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
-require_relative 'vicenzo/rspec/mixed_example_groups'
+require_relative 'vicenzo/rspec/inconsistent_sibling_structure'
 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/rspec/leaky_definition'
 require_relative 'vicenzo/rails/enum_inclusion_of_validation'

data/lib/rubocop/vicenzo/version.rb

@@ -2,6 +2,6 @@
 
 module RuboCop
   module Vicenzo
-    VERSION = '0.1.0'
+    VERSION = '0.2.0'
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-vicenzo
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Bruno Vicenzo
 bindir: exe
 cert_chain: []
-date: 2025-04-02 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lint_roller
@@ -51,7 +51,8 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 3.5.0
-description: Cops with good pratices I have been learning
+description: A growing set of custom RuboCop cops capturing the best practices I've
+  been learning.
 email:
 - bruno@alumni.usp.br
 executables: []
@@ -68,7 +69,8 @@ files:
 - 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/inconsistent_sibling_structure.rb
+- lib/rubocop/cop/vicenzo/rspec/leaky_definition.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
@@ -101,7 +103,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.2
+rubygems_version: 3.7.2
 specification_version: 4
 summary: Cops of Bruno Vicenzo
 test_files: []

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

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