rubocop-vicenzo 0.1.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ed82c28ffcefb60cfdace3b56e7076dccfdfc8bdd936250554ee3adb99c74903
-  data.tar.gz: fc149cec1118966ed088ddf9b0d6b9f2375c25d364396fb5d2069991337dc2ac
+  metadata.gz: 685f19680a9d5721ed006772467155092d9d441c95c035191e3fa9dc449eac65
+  data.tar.gz: 22fa73c161855ced3561903c9a901ca19beec2904fe326402f426ec93040dd78
 SHA512:
-  metadata.gz: 79466db290631d6846ac960fcc8c30c7feb6b89e824443ada09c42f7b4d57a474268fe7c9fa37a686297bfcf538d715190da643dbeb53633c866e9dba3d3bf36
-  data.tar.gz: a0f924f733ba96918a8b5199f9a876c168184cc52cd476c3a3976929edc9cac2239ccf2fbc53e617c6cb340d60de4bf72a46a9d7072de675b461a83c1581b47e
+  metadata.gz: 8ea51ee079b7a796cb1f76c8630f9e78a8c8e4fe191f06e7096d4813744a8623a8b35b43288c7b24a671383d65b1ec4a76db72601bc32484ad5945009bb6a1d0
+  data.tar.gz: 795995a84e448e543fbc5d68a6c0434fd0f7ad62dc19e57727d6da251bcfc0bc9624c7eaa78e40a802d5e08d924dc85a2a3512b3d7a868388bb62e22df7447ce

data/.rubocop.yml

@@ -6,8 +6,20 @@ plugins:
   - rubocop-internal_affairs
 
 AllCops:
+  Exclude:
+    - 'bin/**/*'
+    - 'vendor/**/*'
   NewCops: enable
 
+InternalAffairs/UndefinedConfig: # False positive because conflicts with Rubocop Layout namespace
+  Exclude:
+    - 'lib/rubocop/cop/vicenzo/layout/**/*'
+
+Metrics/BlockLength:
+  Exclude:
+    - 'rakelib/**/*'
+    - 'Rakefile'
+
 Naming/FileName:
   Exclude:
     - lib/rubocop-vicenzo.rb
@@ -25,3 +37,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,23 @@
 ## [Unreleased]
 
+## [0.3.0] - 2025-12-17
+
+- Add RuboCop::Cop::Vicenzo::Layout::MultilineMethodCallLineBreaks #12;
+- Add RuboCop::Cop::Vicenzo::Style::MultilineMethodCallParentheses #13;
+- Add `AllowedMethods` configuration to `Vicenzo/Style/MultilineMethodCallParentheses` to allow excluding specific methods (e.g., RSpec DSLs like `to` and `change`) from the rule #15;
+
+## [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;

data/README.md

@@ -55,6 +55,14 @@ After checking out the repo, run `bin/setup` to install dependencies. Then, run
 
 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).
 
+### Generate binstubs
+
+If you want is possible change the command `bundle exec something` by `bin/something` generating binstubs
+
+```bash
+bundle binstubs rake rspec-core rubocop
+```
+
 ### Creating a new cop
 
 ```bash

data/config/default.yml

@@ -1,14 +1,21 @@
+Vicenzo/Layout/MultilineMethodCallLineBreaks:
+  Description: 'Enforces that method calls in a multiline chain must each be on their own line.'
+  Enabled: true
+  Severity: convention
+  IndentationWidth: 2
+  VersionAdded: '0.3.0'
+
 Vicenzo/Rails/EnumInclusionOfValidation:
   Description: 'Check if the enum has the inclusion of validation defined.'
   Enabled: true
   Severity: convention
   VersionAdded: '0.1.0'
 
-Vicenzo/RSpec/MixedExampleGroups:
-  Description: 'Check if there are example and groups at same level'
+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.1.0'
+  VersionAdded: '0.2.0'
 
 Vicenzo/RSpec/NestedContextImproperStart:
   Description: 'Check if the nested context does not start as a root one.'
@@ -27,3 +34,20 @@ Vicenzo/RSpec/NestedSubjectRedefinition:
   Enabled: true
   Severity: warning
   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/**/*'
+
+Vicenzo/Style/MultilineMethodCallParentheses:
+  Description: 'Enforces parentheses for method calls with arguments that span multiple lines.'
+  Enabled: true
+  AllowedMethods: []
+  VersionAdded: '0.3.0'

data/lib/rubocop/cop/vicenzo/layout/multiline_method_call_line_breaks.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Vicenzo
+      module Layout
+        # Enforces that method calls in a multiline chain are each on their own line.
+        #
+        # If a method chain spans more than one line, this cop ensures that every
+        # call in the chain is placed on a new line. It prevents "mixed" styles
+        # where some methods are on the same line as the receiver while others are broken.
+        #
+        # @example
+        #   # bad
+        #   object.method_one
+        #     .method_two
+        #
+        #   # bad
+        #   object
+        #     .method_one.method_two
+        #     .method_three
+        #
+        #   # good - single line chain
+        #   object.method_one.method_two
+        #
+        #   # good - multiline chain
+        #   object
+        #     .method_one
+        #     .method_two
+        #
+        #   # good - arguments causing the break (if configured implicitly)
+        #   object.method_one(
+        #     arg1,
+        #     arg2
+        #   ).method_two
+        #
+        # ## Configuration
+        #
+        # This cop allows you to customize the indentation width used during auto-correction.
+        # The default width is 2 spaces relative to the previous line.
+        #
+        # ```yaml
+        # CustomCops/MultilineMethodCallLineBreaks:
+        #   IndentationWidth: 4 # (default is 2)
+        # ```
+        #
+        class MultilineMethodCallLineBreaks < Base
+          extend RuboCop::Cop::AutoCorrector
+
+          MSG = 'Method calls in a multiline chain must each be on their own line.'
+          DEFAULT_INDENTATION_WIDTH = 2
+          LEADING_SPACES_PATTERN = /\A */
+          CHAIN_START_PATTERN = /\A\s*&?\./
+
+          OPERATOR_METHODS = %i[[] []= + - * / % ** << >>].freeze
+
+          def on_send(node)
+            check_node(node)
+          end
+          alias on_csend on_send
+
+          private
+
+          def check_node(node)
+            return if part_of_larger_chain?(node)
+            return if single_line_chain?(node)
+
+            check_chain_structure(node)
+          end
+
+          def check_chain_structure(node)
+            current = node
+
+            while current.call_type?
+              receiver = current.receiver
+              break unless receiver
+
+              check_violation(current, receiver)
+              current = receiver
+            end
+          end
+
+          def check_violation(node, receiver)
+            return unless same_line?(receiver, node)
+            return if valid_same_line_exception?(node)
+
+            add_offense(offense_range(node)) do |corrector|
+              break_line_before_dot(corrector, node, receiver)
+            end
+          end
+
+          def valid_same_line_exception?(node)
+            arguments_cause_multiline?(node) || operator_method?(node)
+          end
+
+          def operator_method?(node)
+            OPERATOR_METHODS.include?(node.method_name)
+          end
+
+          def part_of_larger_chain?(node)
+            parent = node.parent
+            parent&.call_type? && parent.receiver == node
+          end
+
+          def single_line_chain?(node)
+            root = root_node(node)
+            root.loc.last_line == node.loc.last_line
+          end
+
+          def root_node(node)
+            current = node
+            current = current.receiver while current.respond_to?(:receiver) && current.receiver
+            current
+          end
+
+          def same_line?(receiver, node)
+            receiver.loc.last_line == call_start_line(node)
+          end
+
+          def call_start_line(node)
+            node.loc.dot ? node.loc.dot.line : node.loc.selector.line
+          end
+
+          def arguments_cause_multiline?(node)
+            return false if node.arguments.empty?
+            return false if node.receiver.loc.last_line != call_start_line(node)
+
+            return false if node.receiver.call_type? && node.receiver.loc.dot
+
+            node.multiline?
+          end
+
+          def offense_range(node)
+            return node.loc.selector unless node.loc.dot
+            return node.loc.dot unless node.loc.selector
+
+            node.loc.dot.join(node.loc.selector)
+          end
+
+          def break_line_before_dot(corrector, node, receiver)
+            dot = node.loc.dot
+            return unless dot
+
+            last_line_index = receiver.loc.last_line - 1
+            last_line_source = processed_source.lines[last_line_index]
+
+            current_indentation = last_line_source[LEADING_SPACES_PATTERN].length
+
+            previous_line_is_chain = last_line_source.match?(CHAIN_START_PATTERN)
+            extra_indent = previous_line_is_chain ? 0 : indentation_width
+
+            indentation = ' ' * (current_indentation + extra_indent)
+
+            corrector.insert_before(dot, "\n#{indentation}")
+          end
+
+          def indentation_width
+            cop_config.fetch('IndentationWidth', DEFAULT_INDENTATION_WIDTH)
+          end
+        end
+      end
+    end
+  end
+end

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/style/multiline_method_call_parentheses.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Vicenzo
+      module Style
+        # Enforces parentheses for method calls with arguments that span multiple lines.
+        # Single-line calls are ignored (parentheses are optional).
+        #
+        # This cop accepts an `AllowedMethods` configuration to exempt specific methods
+        # from this rule. This is particularly useful for Fluent DSLs (like RSpec's
+        # `to`, `change`, etc.) where parentheses might hurt readability or conflict
+        # with layout rules.
+        #
+        # @example
+        #   # bad
+        #   method_name arg1,
+        #               arg2
+        #
+        #   # good
+        #   method_name(arg1,
+        #               arg2)
+        #
+        #   # good (single line is always allowed)
+        #   method_name arg1, arg2
+        #
+        # @example AllowedMethods: ['to']
+        #   # good (allowed by configuration)
+        #   expect { action }.to change {
+        #     model.attribute
+        #   }
+        #
+        class MultilineMethodCallParentheses < Base
+          extend RuboCop::Cop::AutoCorrector
+          include RuboCop::Cop::RangeHelp
+
+          MSG = 'Use parentheses for method calls with arguments that span multiple lines.'
+
+          def on_send(node)
+            check_node(node)
+          end
+          alias on_csend on_send
+
+          private
+
+          def check_node(node)
+            return unless node.arguments?
+            return unless node.multiline?
+            return if node.parenthesized? || node.operator_method? || node.setter_method? || allowed_method?(node)
+
+            add_offense(node) do |corrector|
+              autocorrect(corrector, node)
+            end
+          end
+
+          def allowed_method?(node)
+            allowed_methods.include?(node.method_name.to_s)
+          end
+
+          def allowed_methods
+            cop_config.fetch('AllowedMethods', [])
+          end
+
+          def autocorrect(corrector, node)
+            if node.loc.selector
+              gap_range = range_between(node.loc.selector.end_pos, node.first_argument.source_range.begin_pos)
+              corrector.replace(gap_range, '(')
+            else
+              corrector.insert_before(node.first_argument, '(')
+            end
+
+            corrector.insert_after(node.last_argument, ')')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/vicenzo_cops.rb

@@ -1,7 +1,10 @@
 # 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'
+require_relative 'vicenzo/layout/multiline_method_call_line_breaks'
+require_relative 'vicenzo/style/multiline_method_call_parentheses'

data/lib/rubocop/vicenzo/version.rb

@@ -2,6 +2,6 @@
 
 module RuboCop
   module Vicenzo
-    VERSION = '0.1.1'
+    VERSION = '0.3.0'
   end
 end

data/rakelib/release.rake

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require 'date'
+
+desc 'Prepare release: update config, version file, and changelog'
+task :cut_release, [:version] do |_t, args|
+  version = args[:version]
+
+  # 1. Validation
+  abort 'Error: You must provide a version. Example: rake cut_release[0.3.0]' unless version
+
+  config_file    = 'config/default.yml'
+  version_file   = 'lib/rubocop/vicenzo/version.rb'
+  changelog_file = 'CHANGELOG.md'
+
+  # Check if files exist
+  [config_file, version_file, changelog_file].each do |file|
+    abort "Error: File not found at #{file}" unless File.exist?(file)
+  end
+
+  puts "✂️  Cutting release for version #{version}..."
+
+  # -------------------------------------------------------
+  # 2. Update config/default.yml (<<next>> -> version)
+  # -------------------------------------------------------
+  config_content = File.read(config_file)
+  if config_content.include?("'<<next>>'")
+    updated_config = config_content.gsub("'<<next>>'", "'#{version}'")
+    File.write(config_file, updated_config)
+    puts "   ✅ Updated 'VersionAdded' in #{config_file}"
+  else
+    puts "   ⚠️  No '<<next>>' found in #{config_file} (skipping)"
+  end
+
+  # -------------------------------------------------------
+  # 3. Update lib/rubocop/vicenzo/version.rb
+  # -------------------------------------------------------
+  version_content = File.read(version_file)
+  # Regex looks for: VERSION = '...' or VERSION = "..."
+  if version_content.match?(/VERSION\s*=\s*['"](.+)['"]/)
+    updated_version = version_content.gsub(/VERSION\s*=\s*['"](.+)['"]/, "VERSION = '#{version}'")
+    File.write(version_file, updated_version)
+    puts "   ✅ Updated VERSION constant in #{version_file}"
+  else
+    puts "   ❌ Could not find VERSION constant in #{version_file}"
+  end
+
+  # -------------------------------------------------------
+  # 4. Update CHANGELOG.md
+  # -------------------------------------------------------
+  changelog_content = File.read(changelog_file)
+  unreleased_header = '## [Unreleased]'
+  date = Date.today.to_s # YYYY-MM-DD
+
+  # We replace "## [Unreleased]" with:
+  # ## [Unreleased]
+  #
+  # ## [version] - date
+  #
+  # This pushes the existing unreleased items down under the new version header.
+  new_entry_header = "#{unreleased_header}\n\n## [#{version}] - #{date}"
+
+  if changelog_content.include?(unreleased_header)
+    # We use 'sub' to replace only the first occurrence (the top one)
+    updated_changelog = changelog_content.sub(unreleased_header, new_entry_header)
+    File.write(changelog_file, updated_changelog)
+    puts "   ✅ Updated #{changelog_file} (moved items to [#{version}])"
+  else
+    puts "   ❌ Could not find '#{unreleased_header}' in #{changelog_file}"
+  end
+
+  puts "\n🎉 Release preparation complete! Don't forget to commit."
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-vicenzo
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Bruno Vicenzo
 bindir: exe
 cert_chain: []
-date: 2025-08-12 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lint_roller
@@ -68,15 +68,19 @@ files:
 - Rakefile
 - config/default.yml
 - lib/rubocop-vicenzo.rb
+- lib/rubocop/cop/vicenzo/layout/multiline_method_call_line_breaks.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
+- lib/rubocop/cop/vicenzo/style/multiline_method_call_parentheses.rb
 - lib/rubocop/cop/vicenzo_cops.rb
 - lib/rubocop/vicenzo.rb
 - lib/rubocop/vicenzo/plugin.rb
 - lib/rubocop/vicenzo/version.rb
+- rakelib/release.rake
 - sig/rubocop/vicenzo.rbs
 homepage: https://github.com/bvicenzo/rubocop-vicenzo
 licenses:
@@ -102,7 +106,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