rubocop-vibe 0.3.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e14c979862da1db7feb6dc28697248359d9320450a1bbfca24db50101d9f4c43
-  data.tar.gz: e13a6d3fe34d9a24edc775dba8800e901a2a5a59ca5b3f35f516838e4ca79853
+  metadata.gz: f214588afca7a72328401c384b819415ddae3ac7e4fa2c214bfb7225f4253b56
+  data.tar.gz: d4a9267839bcd11320ca97f7ef64f17134618f7efee156b4f35b8f1a2a07ad1e
 SHA512:
-  metadata.gz: 1d89ddcdf3d94bb0aeca2ce767157e305a75990b540f2bd91d1e9255e26e29915da0eb7b3188d293a96b0d4bf2ce4ac25c700f4601238705e82f7c62dbdaaeac
-  data.tar.gz: 064b6dfe86613f8af93718a277db85d6bd705d7580fa27fe69469c41579aa0e4653c14dd4bcc48b56dd1d808c752921b2f69336816fe0ef3fcbb1098dd0d22f2
+  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
@@ -98,12 +104,30 @@ Vibe/ConsecutiveIndexedAssignmentAlignment:
   SafeAutoCorrect: true
   VersionAdded: "0.3.0"
 
+Vibe/ConsecutiveInstanceVariableAssignmentAlignment:
+  Description: "Enforces alignment of consecutive instance variable assignments at the = operator."
+  Enabled: true
+  SafeAutoCorrect: true
+  VersionAdded: "0.4.0"
+
 Vibe/ConsecutiveLetAlignment:
   Description: "Enforces alignment of consecutive let declarations at the { brace."
   Enabled: true
   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
@@ -122,6 +146,18 @@ 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
+  SafeAutoCorrect: true
+  VersionAdded: "0.4.0"
+
 Vibe/MultilineHashArgumentStyle:
   Description: "Enforces one-per-line and alphabetical ordering for hash arguments in multiline method calls."
   Enabled: true
@@ -184,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

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Vibe
+      # Enforces alignment of consecutive instance variable assignments at the `=` operator.
+      #
+      # Consecutive assignments (with no blank lines between) should align their
+      # `=` operators for better readability. Groups are broken by blank lines.
+      #
+      # @example
+      #   # bad
+      #   @user = create(:user)
+      #   @character = create(:character)
+      #   @input = "test"
+      #
+      #   # good
+      #   @user      = create(:user)
+      #   @character = create(:character)
+      #   @input     = "test"
+      #
+      #   # good - blank line breaks the group
+      #   @user      = create(:user)
+      #   @character = create(:character)
+      #
+      #   @service    = Users::Activate.new
+      #   @activation = service.call
+      class ConsecutiveInstanceVariableAssignmentAlignment < Base
+        extend AutoCorrector
+        include AlignmentHelpers
+
+        MSG = "Align consecutive instance variable assignments at the = operator."
+
+        # Check block nodes for assignment alignment.
+        #
+        # @param [RuboCop::AST::Node] node The block node.
+        # @return [void]
+        def on_block(node)
+          if node.body
+            check_assignments_in_body(node.body)
+          end
+        end
+        alias on_numblock on_block
+        alias on_itblock on_block
+
+        # Check method definitions for assignment alignment.
+        #
+        # @param [RuboCop::AST::Node] node The def node.
+        # @return [void]
+        def on_def(node)
+          if node.body
+            check_assignments_in_body(node.body)
+          end
+        end
+        alias on_defs on_def
+
+        private
+
+        # Check assignments in a body node.
+        #
+        # @param [RuboCop::AST::Node] body The body node.
+        # @return [void]
+        def check_assignments_in_body(body)
+          statements = extract_statements(body)
+
+          return if statements.size < 2
+
+          groups = group_consecutive_statements(statements, &:ivasgn_type?)
+
+          groups.each { |group| check_group_alignment(group) }
+        end
+
+        # Check alignment for a group of assignments.
+        #
+        # @param [Array<RuboCop::AST::Node>] group The assignment group.
+        # @return [void]
+        def check_group_alignment(group)
+          columns       = group.map { |asgn| asgn.loc.operator.column }
+          target_column = columns.max
+
+          group.each do |asgn|
+            current_column = asgn.loc.operator.column
+
+            next if current_column == target_column
+
+            add_offense(asgn.loc.name) do |corrector|
+              autocorrect_alignment(corrector, asgn, target_column)
+            end
+          end
+        end
+
+        # Auto-correct the alignment of an assignment.
+        #
+        # @param [RuboCop::AST::Corrector] corrector The corrector.
+        # @param [RuboCop::AST::Node] asgn The assignment node.
+        # @param [Integer] target_column The target column for alignment.
+        # @return [void]
+        def autocorrect_alignment(corrector, asgn, target_column)
+          variable_name_end = asgn.loc.name.end_pos
+          operator_start    = asgn.loc.operator.begin_pos
+          total_spaces      = calculate_total_spaces(asgn, target_column)
+
+          corrector.replace(
+            range_between(variable_name_end, operator_start),
+            " " * total_spaces
+          )
+        end
+
+        # Calculate total spaces needed for alignment.
+        #
+        # @param [RuboCop::AST::Node] asgn The assignment node.
+        # @param [Integer] target_column The target column for alignment.
+        # @return [Integer] The number of spaces (minimum 1).
+        def calculate_total_spaces(asgn, target_column)
+          current_column = asgn.loc.operator.column
+          current_spaces = asgn.loc.operator.begin_pos - asgn.loc.name.end_pos
+          spaces_needed  = target_column - current_column
+
+          [1, current_spaces + spaces_needed].max
+        end
+      end
+    end
+  end
+end

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