rubocop-vibe 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cdbef6b6693f735e021fc40b2ff54c091942cacc146e6d7314b93597d92d5f0a
-  data.tar.gz: 1d612390dcb873c62803cfce7357dc6e73f2dd76cc63adff21478f62d513743f
+  metadata.gz: f214588afca7a72328401c384b819415ddae3ac7e4fa2c214bfb7225f4253b56
+  data.tar.gz: d4a9267839bcd11320ca97f7ef64f17134618f7efee156b4f35b8f1a2a07ad1e
 SHA512:
-  metadata.gz: 4b57b54a638c0cd84c19e2096d5792c145964bfab9c96f5f47f6a19d44f17bf8830260b536f6913cacb1f154da30dd26226ac688b3c5fa074fbcd90346cfbfb9
-  data.tar.gz: dfec2e07080d666343b0ebd686042299eaa129884fa47c35cab9b0f5ccdd54747d7227edecc970bff1e0e3a1279c4ac8c6eedc7a29e0da54df9fbd3edbed7a8e
+  metadata.gz: bb99fe49c2b921d70e07a6d2c6c4ea035fa76867a3391803f586575a7631d19d176af76791778aedf33178bfa6cb8f9fa3aebe1a66950b14b88c7dfd3823b101
+  data.tar.gz: 4527a16179dbb9b2fa026639f47409a706ba393564b50cc0f6f5544df4b23c9faf6abfc720e319c1a88e92b7f40e2eed553eb720853345134d6d8f754791a9c9

data/config/default.yml

@@ -62,6 +62,12 @@ Style/StringLiterals:
 Style/StringLiteralsInInterpolation:
   EnforcedStyle: double_quotes
 
+Vibe/AttrOrder:
+  Description: "Enforces alphabetical ordering of attr_reader, attr_writer, and attr_accessor arguments."
+  Enabled: true
+  SafeAutoCorrect: true
+  VersionAdded: "0.5.0"
+
 Vibe/BlankLineAfterAssignment:
   Description: "Enforces a blank line after variable assignments when followed by other code."
   Enabled: true
@@ -110,6 +116,18 @@ Vibe/ConsecutiveLetAlignment:
   SafeAutoCorrect: true
   VersionAdded: "0.2.0"
 
+Vibe/ConsecutiveScopeAlignment:
+  Description: "Enforces alignment of consecutive scope declarations at the -> arrow."
+  Enabled: true
+  SafeAutoCorrect: true
+  VersionAdded: "0.5.0"
+
+Vibe/ConstantAlphaOrder:
+  Description: "Enforces alphabetical ordering of consecutive constant declarations by name."
+  Enabled: true
+  SafeAutoCorrect: false
+  VersionAdded: "0.5.0"
+
 Vibe/DescribeBlockOrder:
   Description: "Enforces consistent ordering of describe blocks in RSpec files."
   Enabled: true
@@ -128,6 +146,12 @@ Vibe/IsExpectedOneLiner:
   SafeAutoCorrect: true
   VersionAdded: "0.1.0"
 
+Vibe/KeywordArgumentOrder:
+  Description: "Enforces alphabetical ordering of keyword arguments and their YARD documentation."
+  Enabled: true
+  SafeAutoCorrect: true
+  VersionAdded: "0.5.0"
+
 Vibe/LetOrder:
   Description: "Enforces alphabetical ordering of consecutive let declarations."
   Enabled: true
@@ -196,3 +220,15 @@ Vibe/ServiceCallMethod:
   Description: "Service objects should define `self.call` and `call` methods."
   Enabled: true
   VersionAdded: "0.1.0"
+
+Vibe/ValidateAfterValidates:
+  Description: "Enforces that validate calls appear after validates declarations in Rails models."
+  Enabled: true
+  SafeAutoCorrect: true
+  VersionAdded: "0.5.0"
+
+Vibe/ValidatesAlphaOrder:
+  Description: "Enforces alphabetical ordering of consecutive validates declarations by attribute name."
+  Enabled: true
+  SafeAutoCorrect: true
+  VersionAdded: "0.5.0"

data/lib/rubocop/cop/vibe/attr_order.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Vibe
+      # Enforces alphabetical ordering of arguments to `attr_reader`,
+      # `attr_writer`, and `attr_accessor` declarations.
+      #
+      # @example
+      #   # bad
+      #   attr_reader :id, :content, :timestamp, :raw
+      #
+      #   # good
+      #   attr_reader :content, :id, :raw, :timestamp
+      #
+      #   # bad
+      #   attr_accessor :zebra, :apple
+      #
+      #   # good
+      #   attr_accessor :apple, :zebra
+      class AttrOrder < Base
+        extend AutoCorrector
+
+        MSG = "Order `%<method>s` arguments alphabetically."
+
+        ATTR_METHODS = %i(attr_reader attr_writer attr_accessor).freeze
+
+        # Check attr_* method calls for alphabetical ordering.
+        #
+        # @param [RuboCop::AST::Node] node The send node.
+        # @return [void]
+        def on_send(node)
+          return unless attr_method?(node)
+          return unless node.arguments.size > 1
+          return if all_symbols?(node.arguments) && alphabetically_ordered?(node.arguments)
+
+          add_offense(node, message: format(MSG, method: node.method_name)) do |corrector|
+            autocorrect(corrector, node)
+          end
+        end
+        alias on_csend on_send
+
+        private
+
+        # Check if the node is an attr_* method call.
+        #
+        # @param [RuboCop::AST::Node] node The send node.
+        # @return [Boolean]
+        def attr_method?(node)
+          node.receiver.nil? && ATTR_METHODS.include?(node.method_name)
+        end
+
+        # Check if all arguments are symbols.
+        #
+        # @param [Array<RuboCop::AST::Node>] arguments The arguments.
+        # @return [Boolean]
+        def all_symbols?(arguments)
+          arguments.all?(&:sym_type?)
+        end
+
+        # Check if arguments are alphabetically ordered.
+        #
+        # @param [Array<RuboCop::AST::Node>] arguments The arguments.
+        # @return [Boolean]
+        def alphabetically_ordered?(arguments)
+          names = arguments.map { |arg| arg.value.to_s }
+
+          names == names.sort
+        end
+
+        # Auto-correct by reordering arguments alphabetically.
+        #
+        # @param [RuboCop::AST::Corrector] corrector The corrector.
+        # @param [RuboCop::AST::Node] node The send node.
+        # @return [void]
+        def autocorrect(corrector, node)
+          sorted_args   = node.arguments.sort_by { |arg| arg.value.to_s }
+          sorted_source = sorted_args.map(&:source).join(", ")
+
+          args_range = node.first_argument.source_range.join(node.last_argument.source_range)
+
+          corrector.replace(args_range, sorted_source)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/vibe/blank_line_after_assignment.rb

@@ -53,6 +53,7 @@ module RuboCop
           end
         end
         alias on_numblock on_block
+        alias on_itblock on_block
 
         # Check method definitions for assignment statements.
         #

data/lib/rubocop/cop/vibe/blank_line_before_expectation.rb

@@ -51,6 +51,7 @@ module RuboCop
           end
         end
         alias on_numblock on_block
+        alias on_itblock on_block
 
         private
 

data/lib/rubocop/cop/vibe/class_organization.rb

@@ -36,20 +36,13 @@ module RuboCop
       class ClassOrganization < Base
         extend AutoCorrector
 
+        CLASS_MSG = "Class elements should be ordered: includes → constants → initialize → " \
+                    "class methods → instance methods → protected → private."
         MODEL_MSG = "Model elements should be ordered: concerns → constants → associations → " \
                     "validations → callbacks → scopes → class methods → instance methods → " \
                     "protected → private."
-        CLASS_MSG = "Class elements should be ordered: includes → constants → initialize → " \
-                    "class methods → instance methods → protected → private."
 
         ASSOCIATIONS = %i(belongs_to has_one has_many has_and_belongs_to_many).freeze
-        VALIDATIONS = %i(
-          validates validate validates_each validates_with
-          validates_absence_of validates_acceptance_of validates_confirmation_of
-          validates_exclusion_of validates_format_of validates_inclusion_of
-          validates_length_of validates_numericality_of validates_presence_of
-          validates_size_of validates_uniqueness_of validates_associated
-        ).freeze
         CALLBACKS = %i(
           before_validation after_validation
           before_save after_save around_save
@@ -59,6 +52,15 @@ module RuboCop
           after_commit after_rollback
           after_initialize after_find after_touch
         ).freeze
+        CLASS_PRIORITIES = {
+          concerns:          10,
+          constants:         20,
+          initialize:        30,
+          class_methods:     40,
+          instance_methods:  50,
+          protected_methods: 60,
+          private_methods:   70
+        }.freeze
         MODEL_PRIORITIES = {
           concerns:          10,
           constants:         20,
@@ -71,15 +73,13 @@ module RuboCop
           protected_methods: 90,
           private_methods:   100
         }.freeze
-        CLASS_PRIORITIES = {
-          concerns:          10,
-          constants:         20,
-          initialize:        30,
-          class_methods:     40,
-          instance_methods:  50,
-          protected_methods: 60,
-          private_methods:   70
-        }.freeze
+        VALIDATIONS = %i(
+          validates validate validates_each validates_with
+          validates_absence_of validates_acceptance_of validates_confirmation_of
+          validates_exclusion_of validates_format_of validates_inclusion_of
+          validates_length_of validates_numericality_of validates_presence_of
+          validates_size_of validates_uniqueness_of validates_associated
+        ).freeze
         VISIBILITY_CATEGORIES = {
           protected: :protected_methods,
           private:   :private_methods,

data/lib/rubocop/cop/vibe/consecutive_assignment_alignment.rb

@@ -40,6 +40,7 @@ module RuboCop
           end
         end
         alias on_numblock on_block
+        alias on_itblock on_block
 
         # Check method definitions for assignment alignment.
         #

data/lib/rubocop/cop/vibe/consecutive_indexed_assignment_alignment.rb

@@ -37,6 +37,7 @@ module RuboCop
           end
         end
         alias on_numblock on_block
+        alias on_itblock on_block
 
         # Check method definitions for indexed assignment alignment.
         #

data/lib/rubocop/cop/vibe/consecutive_instance_variable_assignment_alignment.rb

@@ -41,6 +41,7 @@ module RuboCop
           end
         end
         alias on_numblock on_block
+        alias on_itblock on_block
 
         # Check method definitions for assignment alignment.
         #

data/lib/rubocop/cop/vibe/consecutive_let_alignment.rb

@@ -50,6 +50,7 @@ module RuboCop
           check_lets_in_body(node.body)
         end
         alias on_numblock on_block
+        alias on_itblock on_block
 
         private
 

data/lib/rubocop/cop/vibe/consecutive_scope_alignment.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Vibe
+      # Enforces alignment of consecutive `scope` declarations at the `->` arrow.
+      #
+      # Consecutive `scope` declarations (with no blank lines between) should align
+      # their `->` arrows for better readability. Groups are broken by blank lines or
+      # non-scope statements.
+      #
+      # @example
+      #   # bad
+      #   scope :between, ->(start, stop) { where(created_at: start..stop) }
+      #   scope :for_website, ->(website_id) { where(website_id: website_id) }
+      #
+      #   # good
+      #   scope :between,     ->(start, stop) { where(created_at: start..stop) }
+      #   scope :for_website, ->(website_id)  { where(website_id: website_id) }
+      #
+      #   # good - blank line breaks the group
+      #   scope :between,     ->(start, stop) { where(created_at: start..stop) }
+      #
+      #   scope :for_website, ->(website_id) { where(website_id: website_id) }
+      class ConsecutiveScopeAlignment < Base
+        extend AutoCorrector
+        include AlignmentHelpers
+
+        MSG = "Align consecutive scope declarations at the `->` arrow."
+
+        # Check class nodes for scope alignment.
+        #
+        # @param [RuboCop::AST::Node] node The class node.
+        # @return [void]
+        def on_class(node)
+          if node.body
+            check_scopes_in_body(node.body)
+          end
+        end
+
+        private
+
+        # Check scope declarations in a body node.
+        #
+        # @param [RuboCop::AST::Node] body The body node.
+        # @return [void]
+        def check_scopes_in_body(body)
+          statements = extract_statements(body)
+
+          return if statements.size < 2
+
+          groups = group_consecutive_statements(statements) { |s| scope_declaration?(s) }
+
+          groups.each { |group| check_group_alignment(group) }
+        end
+
+        # Check if a node is a scope declaration with a lambda.
+        #
+        # @param [RuboCop::AST::Node] node The node to check.
+        # @return [Boolean]
+        def scope_declaration?(node)
+          return false unless node.send_type?
+          return false unless node.method?(:scope)
+          return false unless node.receiver.nil?
+          return false unless node.arguments[1]&.block_type?
+
+          node.arguments[1].method?(:lambda)
+        end
+
+        # Get the source range of the `->` arrow in a scope declaration.
+        #
+        # @param [RuboCop::AST::Node] scope_node The scope send node.
+        # @return [Parser::Source::Range]
+        def arrow_range(scope_node)
+          scope_node.arguments[1].send_node.loc.selector
+        end
+
+        # Check alignment for a group of scope declarations.
+        #
+        # @param [Array<RuboCop::AST::Node>] group The scope group.
+        # @return [void]
+        def check_group_alignment(group)
+          columns       = group.map { |scope| arrow_range(scope).column }
+          target_column = columns.max
+
+          group.each do |scope|
+            current_column = arrow_range(scope).column
+
+            next if current_column == target_column
+
+            add_offense(scope.first_argument) do |corrector|
+              autocorrect_alignment(corrector, scope, target_column)
+            end
+          end
+        end
+
+        # Auto-correct the alignment of a scope declaration.
+        #
+        # @param [RuboCop::AST::Corrector] corrector The corrector.
+        # @param [RuboCop::AST::Node] scope_node The scope send node.
+        # @param [Integer] target_column The target column for alignment.
+        # @return [void]
+        def autocorrect_alignment(corrector, scope_node, target_column)
+          arrow        = arrow_range(scope_node)
+          comma_end    = scope_node.first_argument.source_range.end_pos + 1
+          arrow_start  = arrow.begin_pos
+          total_spaces = calculate_total_spaces(scope_node, target_column)
+
+          corrector.replace(
+            range_between(comma_end, arrow_start),
+            " " * total_spaces
+          )
+        end
+
+        # Calculate total spaces needed for alignment.
+        #
+        # @param [RuboCop::AST::Node] scope_node The scope send node.
+        # @param [Integer] target_column The target column for alignment.
+        # @return [Integer] The number of spaces (minimum 1).
+        def calculate_total_spaces(scope_node, target_column)
+          arrow          = arrow_range(scope_node)
+          comma_end      = scope_node.first_argument.source_range.end_pos + 1
+          current_column = arrow.column
+          current_spaces = arrow.begin_pos - comma_end
+          spaces_needed  = target_column - current_column
+
+          [1, current_spaces + spaces_needed].max
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/vibe/constant_alpha_order.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Vibe
+      # Enforces alphabetical ordering of consecutive constant declarations by name.
+      #
+      # Consecutive constant declarations (with no blank lines between) should be
+      # alphabetically ordered by constant name for better readability and
+      # easier scanning. Groups are broken by blank lines or non-constant statements.
+      #
+      # @example
+      #   # bad
+      #   class MyClass
+      #     ZEBRA = 1
+      #     ALPHA = 2
+      #   end
+      #
+      #   # good
+      #   class MyClass
+      #     ALPHA = 2
+      #     ZEBRA = 1
+      #   end
+      #
+      #   # good - blank line breaks the group
+      #   class MyClass
+      #     ZEBRA = 1
+      #
+      #     ALPHA = 2
+      #   end
+      class ConstantAlphaOrder < Base
+        extend AutoCorrector
+        include AlignmentHelpers
+
+        MSG = "Order constants alphabetically by name."
+
+        # Check block nodes for constant ordering.
+        #
+        # @param [RuboCop::AST::Node] node The block node.
+        # @return [void]
+        def on_block(node)
+          if node.body
+            check_constants_in_body(node.body)
+          end
+        end
+        alias on_itblock on_block
+        alias on_numblock on_block
+
+        # Check class nodes for constant ordering.
+        #
+        # @param [RuboCop::AST::Node] node The class node.
+        # @return [void]
+        def on_class(node)
+          if node.body
+            check_constants_in_body(node.body)
+          end
+        end
+
+        # Check module nodes for constant ordering.
+        #
+        # @param [RuboCop::AST::Node] node The module node.
+        # @return [void]
+        def on_module(node)
+          if node.body
+            check_constants_in_body(node.body)
+          end
+        end
+
+        private
+
+        # Check constant declarations in a body node.
+        #
+        # @param [RuboCop::AST::Node] body The body node.
+        # @return [void]
+        def check_constants_in_body(body)
+          statements = extract_statements(body)
+
+          return if statements.size < 2
+
+          groups = group_consecutive_statements(statements, &:casgn_type?)
+
+          groups.each { |group| check_group_order(group) }
+        end
+
+        # Check ordering for a group of constant declarations.
+        #
+        # @param [Array<RuboCop::AST::Node>] group The constants group.
+        # @return [void]
+        def check_group_order(group)
+          return if alphabetically_ordered?(group)
+
+          violations = find_ordering_violations(group)
+
+          violations.each do |constant|
+            add_offense(constant) do |corrector|
+              autocorrect(corrector, group)
+            end
+          end
+        end
+
+        # Check if constant declarations are alphabetically ordered.
+        #
+        # @param [Array<RuboCop::AST::Node>] group The constants group.
+        # @return [Boolean]
+        def alphabetically_ordered?(group)
+          names = group.map { |c| c.name.to_s }
+
+          names == names.sort
+        end
+
+        # Find constant declarations that violate ordering.
+        #
+        # @param [Array<RuboCop::AST::Node>] group The constants group.
+        # @return [Array<RuboCop::AST::Node>] Constants that violate ordering.
+        def find_ordering_violations(group)
+          violations = []
+
+          group.each_cons(2) do |current, following|
+            violations << following if current.name.to_s > following.name.to_s
+          end
+
+          violations.uniq
+        end
+
+        # Auto-correct by reordering constant declarations.
+        #
+        # @param [RuboCop::AST::Corrector] corrector The corrector.
+        # @param [Array<RuboCop::AST::Node>] group The constants group.
+        # @return [void]
+        def autocorrect(corrector, group)
+          sorted = group.sort_by { |c| c.name.to_s }
+
+          group.each_with_index do |constant, index|
+            sorted_constant = sorted[index]
+
+            next if constant == sorted_constant
+
+            corrector.replace(constant, sorted_constant.source)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/vibe/describe_block_order.rb

@@ -59,8 +59,8 @@ module RuboCop
         # Default priority for descriptions that can't be categorized (e.g., constants, variables)
         DEFAULT_PRIORITY = 999
 
-        MODEL_ORDER        = %w(class associations validations).freeze
         CONTROLLER_ACTIONS = %w(index show new create edit update destroy).freeze
+        MODEL_ORDER        = %w(class associations validations).freeze
         SPECIAL_SECTIONS = {
           "class"        => 0,
           "constants"    => 5,
@@ -95,6 +95,7 @@ module RuboCop
           end
         end
         alias on_numblock on_block
+        alias on_itblock on_block
 
         private
 

data/lib/rubocop/cop/vibe/explicit_return_conditional.rb

@@ -47,8 +47,8 @@ module RuboCop
       class ExplicitReturnConditional < Base
         extend AutoCorrector
 
-        MSG_TERNARY  = "Use explicit `if`/`else`/`end` block instead of ternary operator for return value."
         MSG_MODIFIER = "Use explicit `if`/`end` block instead of trailing conditional for return value."
+        MSG_TERNARY  = "Use explicit `if`/`else`/`end` block instead of ternary operator for return value."
 
         # Check method definitions for conditional return values.
         #
@@ -151,12 +151,13 @@ module RuboCop
         # @param [RuboCop::AST::Node] node The modifier if node.
         # @return [String]
         def build_if_block(node)
+          keyword      = node.unless? && node.condition.type?(:and, :or) ? "unless" : "if"
           condition    = build_condition(node)
           base_indent  = " " * node.loc.column
           inner_indent = "#{base_indent}  "
 
           [
-            "if #{condition}",
+            "#{keyword} #{condition}",
             "#{inner_indent}#{node.if_branch.source}",
             "#{base_indent}end"
           ].join("\n")
@@ -168,7 +169,7 @@ module RuboCop
         # @param [RuboCop::AST::Node] node The if node.
         # @return [String] The condition source.
         def build_condition(node)
-          if node.unless?
+          if node.unless? && !node.condition.type?(:and, :or)
             negate_condition(node.condition)
           else
             node.condition.source

data/lib/rubocop/cop/vibe/keyword_argument_order.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Vibe
+      # Enforces alphabetical ordering of keyword arguments in method definitions
+      # and their associated YARD `@param` documentation tags.
+      #
+      # @example
+      #   # bad
+      #   # @param id [String] the identifier
+      #   # @param content [String] the body
+      #   def initialize(id:, content:)
+      #   end
+      #
+      #   # good
+      #   # @param content [String] the body
+      #   # @param id [String] the identifier
+      #   def initialize(content:, id:)
+      #   end
+      class KeywordArgumentOrder < Base
+        extend AutoCorrector
+
+        MSG = "Order keyword arguments alphabetically."
+
+        # Check method definitions for keyword argument ordering.
+        #
+        # @param [RuboCop::AST::Node] node The def node.
+        # @return [void]
+        def on_def(node)
+          return unless node.arguments?
+
+          kwargs = extract_keyword_arguments(node)
+
+          return if kwargs.size < 2
+          return if alphabetically_ordered?(kwargs)
+
+          add_offense(node.arguments) do |corrector|
+            autocorrect(corrector, node, kwargs)
+          end
+        end
+        alias on_defs on_def
+
+        private
+
+        # Extract keyword arguments from a method definition.
+        #
+        # @param [RuboCop::AST::Node] node The def node.
+        # @return [Array<RuboCop::AST::Node>]
+        def extract_keyword_arguments(node)
+          node.arguments.select { |arg| arg.type?(:kwarg, :kwoptarg) }
+        end
+
+        # Check if keyword arguments are correctly ordered.
+        #
+        # Required kwargs come first (alphabetically), then optional kwargs (alphabetically).
+        #
+        # @param [Array<RuboCop::AST::Node>] kwargs The keyword arguments.
+        # @return [Boolean]
+        def alphabetically_ordered?(kwargs)
+          kwargs == kwargs.sort_by { |arg| kwarg_sort_key(arg) }
+        end
+
+        # Generate a sort key for a keyword argument.
+        #
+        # Required kwargs come first alphabetically, then optional kwargs alphabetically.
+        #
+        # @param [RuboCop::AST::Node] arg The argument node.
+        # @return [Array]
+        def kwarg_sort_key(arg)
+          # kwargs array is pre-filtered to only include kwarg/kwoptarg types
+          if arg.kwarg_type?
+            [0, arg.name.to_s]
+          else
+            [1, arg.name.to_s]
+          end
+        end
+
+        # Auto-correct by reordering keyword arguments and documentation.
+        #
+        # @param [RuboCop::AST::Corrector] corrector The corrector.
+        # @param [RuboCop::AST::Node] node The def node.
+        # @param [Array<RuboCop::AST::Node>] kwargs The keyword arguments.
+        # @return [void]
+        def autocorrect(corrector, node, kwargs)
+          autocorrect_arguments(corrector, node)
+          autocorrect_documentation(corrector, node, kwargs)
+        end
+
+        # Auto-correct keyword arguments in the method signature.
+        #
+        # @param [RuboCop::AST::Corrector] corrector The corrector.
+        # @param [RuboCop::AST::Node] node The def node.
+        # @return [void]
+        def autocorrect_arguments(corrector, node)
+          args          = node.arguments.to_a
+          sorted_args   = args.sort_by { |arg| sort_key(arg) }
+          sorted_source = sorted_args.map(&:source).join(", ")
+
+          args_range = args.first.source_range.join(args.last.source_range)
+
+          corrector.replace(args_range, sorted_source)
+        end
+
+        # Generate a sort key for an argument.
+        #
+        # Positional arguments come first, then required keyword arguments
+        # alphabetically, then optional keyword arguments alphabetically.
+        #
+        # @param [RuboCop::AST::Node] arg The argument node.
+        # @return [Array]
+        def sort_key(arg)
+          case arg.type
+          when :kwarg
+            [1, arg.name.to_s]
+          when :kwoptarg
+            [2, arg.name.to_s]
+          else
+            [0, ""]
+          end
+        end
+
+        # Auto-correct YARD @param documentation.
+        #
+        # @param [RuboCop::AST::Corrector] corrector The corrector.
+        # @param [RuboCop::AST::Node] node The def node.
+        # @param [Array<RuboCop::AST::Node>] kwargs The keyword arguments.
+        # @return [void]
+        def autocorrect_documentation(corrector, node, kwargs)
+          comments = preceding_comments(node)
+
+          return if comments.empty?
+
+          param_comments = extract_param_comments(comments, kwargs)
+
+          return if param_comments.empty?
+
+          sorted_kwarg_names = kwargs.sort_by { |arg| sort_key(arg) }.map { |arg| arg.name.to_s }
+
+          reorder_param_comments(corrector, param_comments, sorted_kwarg_names)
+        end
+
+        # Get comments preceding a node.
+        #
+        # @param [RuboCop::AST::Node] node The node.
+        # @return [Array<Parser::Source::Comment>]
+        def preceding_comments(node)
+          processed_source.ast_with_comments[node] || []
+        end
+
+        # Extract @param comments for keyword arguments.
+        #
+        # @param [Array<Parser::Source::Comment>] comments The comments.
+        # @param [Array<RuboCop::AST::Node>] kwargs The keyword arguments.
+        # @return [Array<Parser::Source::Comment>]
+        def extract_param_comments(comments, kwargs)
+          kwarg_names = kwargs.map { |arg| arg.name.to_s }
+
+          comments.select do |comment|
+            match = comment.text.match(/@param\s+(\w+)/)
+
+            match && kwarg_names.include?(match[1])
+          end
+        end
+
+        # Reorder @param comments to match argument order.
+        #
+        # @param [RuboCop::AST::Corrector] corrector The corrector.
+        # @param [Array<Parser::Source::Comment>] param_comments The param comments.
+        # @param [Array<String>] sorted_kwarg_names The sorted keyword argument names.
+        # @return [void]
+        def reorder_param_comments(corrector, param_comments, sorted_kwarg_names)
+          sorted = param_comments.sort_by do |comment|
+            match = comment.text.match(/@param\s+(\w+)/)
+
+            sorted_kwarg_names.index(match[1]) || Float::INFINITY
+          end
+
+          param_comments.each_with_index do |comment, index|
+            sorted_comment = sorted[index]
+
+            next if comment == sorted_comment
+
+            corrector.replace(comment, sorted_comment.text)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/vibe/let_order.rb

@@ -49,6 +49,7 @@ module RuboCop
           check_lets_in_body(node.body)
         end
         alias on_numblock on_block
+        alias on_itblock on_block
 
         private
 

data/lib/rubocop/cop/vibe/no_rubocop_disable.rb

@@ -40,9 +40,9 @@ module RuboCop
         MSG        = "Do not disable `%<cops>s`. Fix the issue or configure globally in `.rubocop.yml`."
         MSG_NO_COP = "Do not use `# rubocop:disable`. Fix the issue or configure globally in `.rubocop.yml`."
 
-        DISABLE_PATTERN  = /\A#\s*rubocop\s*:\s*disable\b/i
-        COP_NAME_PATTERN = %r{[A-Za-z]+/[A-Za-z0-9]+}
         ALL_PATTERN      = /\brubocop\s*:\s*disable\s+all\b/i
+        COP_NAME_PATTERN = %r{[A-Za-z]+/[A-Za-z0-9]+}
+        DISABLE_PATTERN  = /\A#\s*rubocop\s*:\s*disable\b/i
 
         # Check for rubocop:disable comments.
         #

data/lib/rubocop/cop/vibe/no_skipped_tests.rb

@@ -38,12 +38,12 @@ module RuboCop
       class NoSkippedTests < Base
         include SpecFileHelper
 
-        MSG_SKIP    = "Do not skip tests. Implement or delete the test."
         MSG_PENDING = "Do not mark tests as pending. Implement or delete the test."
+        MSG_SKIP    = "Do not skip tests. Implement or delete the test."
         MSG_XMETHOD = "Do not use `%<method>s`. Implement or delete the test."
 
-        SKIP_METHODS    = %i(skip).freeze
         PENDING_METHODS = %i(pending).freeze
+        SKIP_METHODS    = %i(skip).freeze
         X_METHODS       = %i(xit xspecify xexample xscenario xdescribe xcontext xfeature).freeze
 
         # @!method skip_call?(node)

data/lib/rubocop/cop/vibe/prefer_one_liner_expectation.rb

@@ -66,6 +66,7 @@ module RuboCop
           end
         end
         alias on_numblock on_block
+        alias on_itblock on_block
 
         private
 

data/lib/rubocop/cop/vibe/raise_unless_block.rb

@@ -72,25 +72,28 @@ module RuboCop
         # @param [RuboCop::AST::Node] node The if node.
         # @return [String] The replacement code.
         def build_replacement(node)
+          keyword      = node.unless? && node.condition.type?(:and, :or) ? "unless" : "if"
           condition    = build_condition(node)
           raise_source = node.body.source
           base_indent  = " " * node.loc.column
           inner_indent = "#{base_indent}  "
 
           [
-            "if #{condition}",
+            "#{keyword} #{condition}",
             "#{inner_indent}#{raise_source}",
             "#{base_indent}end"
           ].join("\n")
         end
 
-        # Build the condition for the if block.
-        # For unless, negate the condition. For if, keep it as is.
+        # Build the condition for the if/unless block.
+        # For unless with a compound condition, keep it as-is (paired with unless keyword).
+        # For unless with a simple condition, negate it.
+        # For if, keep as-is.
         #
         # @param [RuboCop::AST::Node] node The if node.
         # @return [String] The condition source.
         def build_condition(node)
-          if node.unless?
+          if node.unless? && !node.condition.type?(:and, :or)
             "!#{node.condition.source}"
           else
             node.condition.source

data/lib/rubocop/cop/vibe/rspec_before_block_style.rb

@@ -45,6 +45,7 @@ module RuboCop
           end
         end
         alias on_numblock on_block
+        alias on_itblock on_block
 
         private
 

data/lib/rubocop/cop/vibe/validate_after_validates.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Vibe
+      # Enforces that `validate` calls appear after `validates` declarations.
+      #
+      # Within a consecutive block of validates-family calls (no blank lines
+      # between), all `validate :method` calls must come after all `validates*`
+      # declarations. The order of `validate` calls relative to each other is
+      # not enforced.
+      #
+      # @example
+      #   # bad
+      #   class User < ApplicationRecord
+      #     validate :check_expiry
+      #     validates :name, presence: true
+      #   end
+      #
+      #   # good
+      #   class User < ApplicationRecord
+      #     validates :name, presence: true
+      #     validate :check_expiry
+      #   end
+      #
+      #   # good - blank line breaks the group
+      #   class User < ApplicationRecord
+      #     validate :check_expiry
+      #
+      #     validates :name, presence: true
+      #   end
+      class ValidateAfterValidates < Base
+        extend AutoCorrector
+        include AlignmentHelpers
+
+        MSG = "Place `validate` calls after `validates` declarations."
+
+        VALIDATES_METHODS = %i(
+          validates validates_each validates_with
+          validates_absence_of validates_acceptance_of validates_confirmation_of
+          validates_exclusion_of validates_format_of validates_inclusion_of
+          validates_length_of validates_numericality_of validates_presence_of
+          validates_size_of validates_uniqueness_of validates_associated
+        ).freeze
+
+        VALIDATE_METHOD = :validate
+
+        # Check class nodes for validate/validates ordering.
+        #
+        # @param [RuboCop::AST::Node] node The class node.
+        # @return [void]
+        def on_class(node)
+          return unless rails_model?(node)
+          return unless node.body
+
+          check_validates_in_body(node.body)
+        end
+
+        private
+
+        # Check validates-family declarations in a body node.
+        #
+        # @param [RuboCop::AST::Node] body The body node.
+        # @return [void]
+        def check_validates_in_body(body)
+          statements = extract_statements(body)
+
+          return if statements.size < 2
+
+          groups = group_consecutive_statements(statements) { |s| validates_family?(s) }
+
+          groups.each { |group| check_group_order(group) }
+        end
+
+        # Check if a node is a validates-family declaration.
+        #
+        # @param [RuboCop::AST::Node] node The node to check.
+        # @return [Boolean]
+        def validates_family?(node)
+          if node.send_type?
+            VALIDATES_METHODS.include?(node.method_name) || node.method?(VALIDATE_METHOD)
+          else
+            false
+          end
+        end
+
+        # Check ordering for a group of validates-family declarations.
+        #
+        # @param [Array<RuboCop::AST::Node>] group The validates group.
+        # @return [void]
+        def check_group_order(group)
+          violations = find_violations(group)
+
+          return if violations.empty?
+
+          violations.each do |validate|
+            add_offense(validate) do |corrector|
+              autocorrect(corrector, group)
+            end
+          end
+        end
+
+        # Find validate calls that appear before validates* declarations.
+        #
+        # @param [Array<RuboCop::AST::Node>] group The validates group.
+        # @return [Array<RuboCop::AST::Node>] Validate nodes that violate ordering.
+        def find_violations(group)
+          last_validates_index = group.rindex { |n| VALIDATES_METHODS.include?(n.method_name) }
+
+          return [] if last_validates_index.nil?
+
+          group.each_with_index.filter_map do |node, index|
+            node if index < last_validates_index && node.method?(VALIDATE_METHOD)
+          end
+        end
+
+        # Auto-correct by moving validate calls after validates* declarations.
+        #
+        # Preserves relative order within each tier.
+        #
+        # @param [RuboCop::AST::Corrector] corrector The corrector.
+        # @param [Array<RuboCop::AST::Node>] group The validates group.
+        # @return [void]
+        def autocorrect(corrector, group)
+          validates_nodes = group.select { |n| VALIDATES_METHODS.include?(n.method_name) }
+          validate_nodes  = group.select { |n| n.method?(VALIDATE_METHOD) }
+          sorted          = validates_nodes + validate_nodes
+
+          group.each_with_index do |node, index|
+            sorted_node = sorted[index]
+
+            next if node == sorted_node
+
+            corrector.replace(node, sorted_node.source)
+          end
+        end
+
+        # Check if this is a Rails model.
+        #
+        # @param [RuboCop::AST::Node] node The class node.
+        # @return [Boolean]
+        def rails_model?(node)
+          if node.parent_class
+            parent_name = node.parent_class.const_name.to_s
+            parent_name == "ApplicationRecord" ||
+              parent_name == "ActiveRecord::Base" ||
+              parent_name.end_with?("::ApplicationRecord")
+          else
+            false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/vibe/validates_alpha_order.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Vibe
+      # Enforces alphabetical ordering of consecutive `validates` declarations.
+      #
+      # Consecutive `validates` declarations (with no blank lines between) should be
+      # alphabetically ordered by the first attribute name for better readability and
+      # easier scanning. Groups are broken by blank lines or non-validates statements.
+      #
+      # @example
+      #   # bad
+      #   class User < ApplicationRecord
+      #     validates :name, presence: true
+      #     validates :age, numericality: true
+      #   end
+      #
+      #   # good
+      #   class User < ApplicationRecord
+      #     validates :age, numericality: true
+      #     validates :name, presence: true
+      #   end
+      #
+      #   # good - blank line breaks the group
+      #   class User < ApplicationRecord
+      #     validates :z, presence: true
+      #
+      #     validates :a, presence: true
+      #   end
+      class ValidatesAlphaOrder < Base
+        extend AutoCorrector
+        include AlignmentHelpers
+
+        MSG = "Order validates declarations alphabetically by attribute name."
+
+        VALIDATES_METHODS = %i(
+          validates validates_each validates_with
+          validates_absence_of validates_acceptance_of validates_confirmation_of
+          validates_exclusion_of validates_format_of validates_inclusion_of
+          validates_length_of validates_numericality_of validates_presence_of
+          validates_size_of validates_uniqueness_of validates_associated
+        ).freeze
+
+        # Check class nodes for validates ordering.
+        #
+        # @param [RuboCop::AST::Node] node The class node.
+        # @return [void]
+        def on_class(node)
+          return unless rails_model?(node)
+          return unless node.body
+
+          check_validates_in_body(node.body)
+        end
+
+        private
+
+        # Check validates declarations in a body node.
+        #
+        # @param [RuboCop::AST::Node] body The body node.
+        # @return [void]
+        def check_validates_in_body(body)
+          statements = extract_statements(body)
+
+          return if statements.size < 2
+
+          groups = group_consecutive_statements(statements) { |s| validates_declaration?(s) }
+
+          groups.each { |group| check_group_order(group) }
+        end
+
+        # Check if a node is a validates declaration.
+        #
+        # @param [RuboCop::AST::Node] node The node to check.
+        # @return [Boolean]
+        def validates_declaration?(node)
+          if node.send_type?
+            VALIDATES_METHODS.include?(node.method_name)
+          else
+            false
+          end
+        end
+
+        # Check ordering for a group of validates declarations.
+        #
+        # @param [Array<RuboCop::AST::Node>] group The validates group.
+        # @return [void]
+        def check_group_order(group)
+          return if alphabetically_ordered?(group)
+
+          violations = find_ordering_violations(group)
+
+          violations.each do |validates|
+            add_offense(validates) do |corrector|
+              autocorrect(corrector, group)
+            end
+          end
+        end
+
+        # Check if validates declarations are alphabetically ordered.
+        #
+        # @param [Array<RuboCop::AST::Node>] group The validates group.
+        # @return [Boolean]
+        def alphabetically_ordered?(group)
+          names = group.map { |v| extract_validates_name(v) }
+
+          names == names.sort
+        end
+
+        # Extract the attribute name from a validates declaration.
+        #
+        # @param [RuboCop::AST::Node] node The validates node.
+        # @return [String]
+        def extract_validates_name(node)
+          node.first_argument.value.to_s
+        end
+
+        # Find validates declarations that violate ordering.
+        #
+        # @param [Array<RuboCop::AST::Node>] group The validates group.
+        # @return [Array<RuboCop::AST::Node>] Validates that violate ordering.
+        def find_ordering_violations(group)
+          violations = []
+
+          group.each_cons(2) do |current, following|
+            violations << following if extract_validates_name(current) > extract_validates_name(following)
+          end
+
+          violations.uniq
+        end
+
+        # Auto-correct by reordering validates declarations.
+        #
+        # @param [RuboCop::AST::Corrector] corrector The corrector.
+        # @param [Array<RuboCop::AST::Node>] group The validates group.
+        # @return [void]
+        def autocorrect(corrector, group)
+          sorted = group.sort_by { |v| extract_validates_name(v) }
+
+          group.each_with_index do |validates, index|
+            sorted_validates = sorted[index]
+
+            next if validates == sorted_validates
+
+            corrector.replace(validates, sorted_validates.source)
+          end
+        end
+
+        # Check if this is a Rails model.
+        #
+        # @param [RuboCop::AST::Node] node The class node.
+        # @return [Boolean]
+        def rails_model?(node)
+          if node.parent_class
+            parent_name = node.parent_class.const_name.to_s
+            parent_name == "ApplicationRecord" ||
+              parent_name == "ActiveRecord::Base" ||
+              parent_name.end_with?("::ApplicationRecord")
+          else
+            false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/vibe_cops.rb

@@ -3,6 +3,7 @@
 require_relative "vibe/mixin/alignment_helpers"
 require_relative "vibe/mixin/spec_file_helper"
 
+require_relative "vibe/attr_order"
 require_relative "vibe/blank_line_after_assignment"
 require_relative "vibe/blank_line_before_expectation"
 require_relative "vibe/class_organization"
@@ -11,9 +12,12 @@ require_relative "vibe/consecutive_constant_alignment"
 require_relative "vibe/consecutive_indexed_assignment_alignment"
 require_relative "vibe/consecutive_instance_variable_assignment_alignment"
 require_relative "vibe/consecutive_let_alignment"
+require_relative "vibe/consecutive_scope_alignment"
+require_relative "vibe/constant_alpha_order"
 require_relative "vibe/describe_block_order"
 require_relative "vibe/explicit_return_conditional"
 require_relative "vibe/is_expected_one_liner"
+require_relative "vibe/keyword_argument_order"
 require_relative "vibe/let_order"
 require_relative "vibe/multiline_hash_argument_style"
 require_relative "vibe/no_assigns_attribute_testing"
@@ -26,3 +30,5 @@ require_relative "vibe/raise_unless_block"
 require_relative "vibe/rspec_before_block_style"
 require_relative "vibe/rspec_stub_chain_style"
 require_relative "vibe/service_call_method"
+require_relative "vibe/validate_after_validates"
+require_relative "vibe/validates_alpha_order"

data/lib/rubocop/vibe/version.rb

@@ -2,6 +2,6 @@
 
 module RuboCop
   module Vibe
-    VERSION = "0.4.0"
+    VERSION = "0.5.0"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-vibe
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Tristan Dunn
@@ -29,14 +29,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.82.1
+        version: 1.85.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.82.1
+        version: 1.85.0
 - !ruby/object:Gem::Dependency
   name: rubocop-performance
   requirement: !ruby/object:Gem::Requirement
@@ -71,14 +71,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.8.0
+        version: 3.9.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.8.0
+        version: 3.9.0
 description: A set of custom cops to use on AI generated code.
 email: hello@tristandunn.com
 executables: []
@@ -87,6 +87,7 @@ extra_rdoc_files: []
 files:
 - config/default.yml
 - lib/rubocop-vibe.rb
+- lib/rubocop/cop/vibe/attr_order.rb
 - lib/rubocop/cop/vibe/blank_line_after_assignment.rb
 - lib/rubocop/cop/vibe/blank_line_before_expectation.rb
 - lib/rubocop/cop/vibe/class_organization.rb
@@ -95,9 +96,12 @@ files:
 - lib/rubocop/cop/vibe/consecutive_indexed_assignment_alignment.rb
 - lib/rubocop/cop/vibe/consecutive_instance_variable_assignment_alignment.rb
 - lib/rubocop/cop/vibe/consecutive_let_alignment.rb
+- lib/rubocop/cop/vibe/consecutive_scope_alignment.rb
+- lib/rubocop/cop/vibe/constant_alpha_order.rb
 - lib/rubocop/cop/vibe/describe_block_order.rb
 - lib/rubocop/cop/vibe/explicit_return_conditional.rb
 - lib/rubocop/cop/vibe/is_expected_one_liner.rb
+- lib/rubocop/cop/vibe/keyword_argument_order.rb
 - lib/rubocop/cop/vibe/let_order.rb
 - lib/rubocop/cop/vibe/mixin/alignment_helpers.rb
 - lib/rubocop/cop/vibe/mixin/spec_file_helper.rb
@@ -112,6 +116,8 @@ files:
 - lib/rubocop/cop/vibe/rspec_before_block_style.rb
 - lib/rubocop/cop/vibe/rspec_stub_chain_style.rb
 - lib/rubocop/cop/vibe/service_call_method.rb
+- lib/rubocop/cop/vibe/validate_after_validates.rb
+- lib/rubocop/cop/vibe/validates_alpha_order.rb
 - lib/rubocop/cop/vibe_cops.rb
 - lib/rubocop/vibe.rb
 - lib/rubocop/vibe/plugin.rb
@@ -138,7 +144,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.4
+rubygems_version: 4.0.5
 specification_version: 4
 summary: A set of custom cops to use on AI generated code.
 test_files: []