rubocop-vibe 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 32efe500f7fb50e4005a4ef34081405eee947bc058b96c684e60d3edb1095976
-  data.tar.gz: 79b4d44786594d509536e369756ead61b0cd34cd54cf288f857b4fa04e90f0a5
+  metadata.gz: 51eb5df4d2c3cea10d5c91ffdda0196ffd78d4863f677209daf4485fb2982386
+  data.tar.gz: 90ead0406cb08cf50c7b894b3f7031480cf04736cf9ae790496b55d175489deb
 SHA512:
-  metadata.gz: 62fb11ebb915d21241f1c0da9b6684564e457aeaa0469ce2fc5ec708bfaf1754f8b4f85dfc7167b7ea68b9e498424d6feb3e6afb57673f28a2921e88fba56f3d
-  data.tar.gz: 10bdf89f1dcfd15dbdfe06d293d3a6633193ecf953d50133be333d50b70b3ed7f84f081f6d40c4cbafd3fa68ae50839958ad1fe92eafddd44151b3f1c068e090
+  metadata.gz: 4a51750ef0ed7e271fcc054e4492506e9296fad7cdd605543e9e7e1baa20f7a7be4eb7fcf5429551417cd21422326abb74735603474579c37f767478ecb4e47d
+  data.tar.gz: 900cd97045e70e6fbedb103245d20b5453f85a59b6eade6c1df1efd783407024289f7f611e78f1ee10739bb322a3a8fe3e796d990930bf9dc0b96a27f84c7830

data/config/default.yml

@@ -160,6 +160,12 @@ Vibe/LetOrder:
   SafeAutoCorrect: true
   VersionAdded: "0.4.0"
 
+Vibe/ModuleOrganization:
+  Description: "Enforces consistent organization of module definitions."
+  Enabled: true
+  SafeAutoCorrect: false
+  VersionAdded: "0.7.0"
+
 Vibe/MultilineHashArgumentStyle:
   Description: "Enforces one-per-line and alphabetical ordering for hash arguments in multiline method calls."
   Enabled: true
@@ -183,6 +189,13 @@ Vibe/NoRubocopDisable:
   AllowedCops: []
   VersionAdded: "0.1.0"
 
+Vibe/NoSingleCharacterVariableNames:
+  Description: "Disallows single character variable names."
+  Enabled: true
+  AllowedNames:
+    - "_"
+  VersionAdded: "0.7.0"
+
 Vibe/NoSkippedTests:
   Description: "Enforces that tests are not skipped or marked as pending."
   Enabled: true

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

@@ -204,11 +204,11 @@ module RuboCop
         # @return [RuboCop::AST::Node, nil]
         def leftmost_receiver(node)
           return node if node.lvar_type?
-          return unless node.send_type?
+          return unless node.call_type?
 
           current = node
 
-          current = current.receiver while current.send_type? && current.receiver
+          current = current.receiver while current.call_type? && current.receiver
 
           current
         end

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

@@ -39,9 +39,9 @@ module RuboCop
       #   end
       class ClassOrganization < Base
         extend AutoCorrector
+        include BodyOrganization
 
-        ASSOCIATIONS    = %i(belongs_to has_one has_many has_and_belongs_to_many).freeze
-        ATTR_SORT_ORDER = { attr_accessor: "!0", attr_reader: "!1", attr_writer: "!2" }.freeze
+        ASSOCIATIONS = %i(belongs_to has_one has_many has_and_belongs_to_many).freeze
         CALLBACKS = %i(
           before_validation after_validation
           before_save after_save around_save
@@ -86,288 +86,78 @@ module RuboCop
           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,
-          public:    :instance_methods
-        }.freeze
-
-        # Check and register violations.
-        #
-        # @param [RuboCop::AST::Node] class_node The class node.
-        # @param [Array<Hash>] elements The elements.
-        # @param [Boolean] is_model Whether this is a Rails model.
-        # @return [void]
-        def check_violations(class_node, elements, is_model)
-          violations = find_violations(elements)
-
-          return if violations.empty?
-
-          message = is_model ? MODEL_MSG : CLASS_MSG
-
-          add_offense(violations.first[:node], message: message) do |corrector|
-            autocorrect(corrector, class_node, elements)
-          end
-        end
 
         # Check class nodes for organization.
         #
         # @param [RuboCop::AST::Node] node The class node.
         # @return [void]
         def on_class(node)
-          is_model      = rails_model?(node)
-          is_controller = rails_controller?(node)
+          @is_model      = rails_model?(node)
+          @is_controller = rails_controller?(node)
 
-          return if !is_model && !is_controller && !node.body
+          return if !@is_model && !@is_controller && !node.body
+          return unless node.body
 
-          elements = extract_elements(node, is_model: is_model, is_controller: is_controller)
+          elements = collect_class_elements(node.body)
 
           return if elements.size < 2
 
-          check_violations(node, elements, is_model)
+          check_body_violations(node, elements)
         end
 
         private
 
-        # Get category for attr methods based on visibility.
-        #
-        # @param [Symbol] visibility The current visibility.
-        # @return [Symbol]
-        def attr_category(visibility)
-          if visibility == :public
-            :attr_methods
-          else
-            visibility_method_category(visibility)
-          end
-        end
-
-        # Check if node is an attr method.
-        #
-        # @param [RuboCop::AST::Node] node The node to check.
-        # @return [Boolean]
-        def attr_method?(node)
-          node.send_type? && ATTR_SORT_ORDER.key?(node.method_name)
-        end
-
-        # Auto-correct by sorting elements within each visibility section.
-        #
-        # @param [RuboCop::AST::Corrector] corrector The corrector.
-        # @param [RuboCop::AST::Node] _class_node The class node.
-        # @param [Array<Hash>] elements The list of elements.
-        # @return [void]
-        def autocorrect(corrector, _class_node, elements)
-          elements.group_by { |e| e[:visibility] }.each_value do |section|
-            sorted = sort_elements(section)
-
-            next if sorted == section
-
-            autocorrect_group(corrector, section, sorted)
-          end
-        end
-
-        # Auto-correct a single consecutive group.
-        #
-        # @param [RuboCop::AST::Corrector] corrector The corrector.
-        # @param [Array<Hash>] group The original elements.
-        # @param [Array<Hash>] sorted The sorted elements.
-        # @return [void]
-        def autocorrect_group(corrector, group, sorted)
-          sorted.each_with_index do |element, idx|
-            original = group[idx]
-
-            next if element[:node] == original[:node]
-
-            corrector.replace(
-              node_range_with_comments(original[:node]),
-              source_with_comments(element[:node])
-            )
-          end
-        end
-
-        # Build element hash for a node.
-        #
-        # @param [RuboCop::AST::Node] child The node.
-        # @param [Symbol] visibility The current visibility.
-        # @param [Integer] index The original index.
-        # @param [Boolean] is_model Whether this is a Rails model.
-        # @param [Boolean] is_controller Whether this is a Rails controller.
-        # @return [Hash]
-        # @return [nil]
-        def build_element(child, visibility, index, is_model, is_controller)
-          return unless categorizable?(child)
-
-          category = categorize_node(child, visibility, is_model)
-
-          return unless category
-
-          # Skip public instance methods in controllers (Rails/ActionOrder handles them).
-          return if is_controller && category == :instance_methods && visibility == :public
-
-          element_hash(child, category, visibility, index, is_model)
-        end
-
-        # Check if node should be categorized.
-        #
-        # @param [RuboCop::AST::Node] node The node to check.
-        # @return [Boolean]
-        def categorizable?(node)
-          node.type?(:send, :any_def, :casgn)
-        end
-
-        # Categorize a node.
+        # Categorize send nodes for classes.
         #
         # @param [RuboCop::AST::Node] node The node to categorize.
-        # @param [Symbol] visibility The current visibility.
-        # @param [Boolean] is_model Whether this is a Rails model.
+        # @param [Symbol] _visibility The current visibility.
         # @return [Symbol]
-        # @return [nil] When node doesn't fit a category.
-        def categorize_node(node, visibility, is_model)
-          return method_category(node, visibility) if node.any_def_type?
-          return :constants if node.casgn_type?
+        # @return [nil]
+        def categorize_send_node(node, _visibility)
+          return :concerns if node.method?(:include)
+          return nil unless @is_model
 
-          return nil if visibility_modifier?(node)
-          return attr_category(visibility) if attr_method?(node)
+          return :associations if ASSOCIATIONS.include?(node.method_name)
+          return :validations if validation_method?(node)
+          return :callbacks if CALLBACKS.include?(node.method_name)
+          return :scopes if node.method?(:scope)
 
-          send_category(node, visibility, is_model)
+          nil
         end
 
-        # Collect elements from body nodes.
+        # Collect elements from class body with controller filtering.
         #
         # @param [RuboCop::AST::Node] body The body node.
-        # @param [Boolean] is_model Whether this is a Rails model.
-        # @param [Boolean] is_controller Whether this is a Rails controller.
         # @return [Array<Hash>] Array of element hashes.
-        def collect_elements(body, is_model, is_controller)
+        def collect_class_elements(body)
           visibility = :public
           elements   = []
-          index      = 0
 
           process_body_nodes(body).each do |child|
             visibility = child.method_name if visibility_modifier?(child)
+            element = build_body_element(child, visibility, elements.size)
 
-            element = build_element(child, visibility, index, is_model, is_controller)
+            next if element.nil? || controller_public_instance_method?(element, visibility)
 
-            elements << element and index += 1 if element
+            elements << element
           end
 
           elements
         end
 
-        # Get comments immediately before a node.
-        #
-        # @param [RuboCop::AST::Node] node The node.
-        # @return [Array<Parser::Source::Comment>] Consecutive comments before node.
-        def comments_before(node)
-          consecutive   = []
-          expected_line = node.first_line - 1
-
-          while (comment = comments_by_line[expected_line])
-            consecutive.unshift(comment)
-            expected_line -= 1
-          end
-
-          consecutive
-        end
-
-        # Get comments indexed by line number for fast lookup.
-        #
-        # @return [Hash<Integer, Parser::Source::Comment>] Comments keyed by line.
-        def comments_by_line
-          @comments_by_line ||= processed_source.comments.to_h { |c| [c.location.line, c] }
+        # Check if element is a public instance method in a controller.
+        def controller_public_instance_method?(element, visibility)
+          @is_controller && element[:category] == :instance_methods && visibility == :public
         end
 
-        # Create element hash.
+        # Get the priority hash for the current context.
         #
-        # @param [RuboCop::AST::Node] node The node.
-        # @param [Symbol] category The category.
-        # @param [Symbol] visibility The visibility.
-        # @param [Integer] index The original index.
-        # @param [Boolean] is_model Whether this is a Rails model.
         # @return [Hash]
-        def element_hash(node, category, visibility, index, is_model)
-          {
-            node:           node,
-            category:       category,
-            visibility:     visibility,
-            original_index: index,
-            priority:       priority_for(category, node, is_model),
-            sort_key:       sort_key_for(category, node)
-          }
-        end
-
-        # Extract and categorize elements from the class.
-        #
-        # @param [RuboCop::AST::Node] node The class node.
-        # @param [Boolean] is_model Whether this is a Rails model.
-        # @param [Boolean] is_controller Whether this is a Rails controller.
-        # @return [Array<Hash>] Array of element info.
-        def extract_elements(node, is_model:, is_controller: false)
-          if node.body
-            collect_elements(node.body, is_model, is_controller)
+        def priorities
+          if @is_model
+            MODEL_PRIORITIES
           else
-            []
-          end
-        end
-
-        # Find elements that violate ordering.
-        #
-        # @param [Array<Hash>] elements The list of elements.
-        # @return [Array<Hash>] Elements that violate ordering.
-        def find_violations(elements)
-          violations = []
-
-          elements.each_cons(2) do |current, following|
-            violations << following if violates_order?(current, following)
-          end
-
-          violations.uniq
-        end
-
-        # Categorize method nodes.
-        #
-        # @param [RuboCop::AST::Node] node The node to categorize.
-        # @param [Symbol] visibility The current visibility.
-        # @return [Symbol]
-        def method_category(node, visibility)
-          return :class_methods if node.defs_type?
-          return :initialize if node.method?(:initialize) && visibility == :public
-
-          visibility_method_category(visibility)
-        end
-
-        # Get the source range of a node including preceding comments.
-        #
-        # @param [RuboCop::AST::Node] node The node.
-        # @return [Parser::Source::Range]
-        def node_range_with_comments(node)
-          comment_list = comments_before(node)
-
-          start_range = comment_list.any? ? comment_list.first.source_range : node.source_range
-
-          start_range.join(node.source_range)
-        end
-
-        # Get priority for a category.
-        #
-        # @param [Symbol] category The category.
-        # @param [RuboCop::AST::Node] _node The node.
-        # @param [Boolean] is_model Whether this is a Rails model.
-        # @return [Integer]
-        def priority_for(category, _node, is_model)
-          priorities = is_model ? MODEL_PRIORITIES : CLASS_PRIORITIES
-
-          priorities[category] || 999
-        end
-
-        # Process body nodes to get a flat list.
-        #
-        # @param [RuboCop::AST::Node] body The body node.
-        # @return [Array<RuboCop::AST::Node>]
-        def process_body_nodes(body)
-          if body.begin_type?
-            body.children
-          else
-            [body]
+            CLASS_PRIORITIES
           end
         end
 
@@ -416,33 +206,6 @@ module RuboCop
           first_arg.value.to_s
         end
 
-        # Categorize send nodes.
-        #
-        # @param [RuboCop::AST::Node] node The node to categorize.
-        # @param [Symbol] _visibility The current visibility.
-        # @param [Boolean] is_model Whether this is a Rails model.
-        # @return [Symbol]
-        # @return [nil]
-        def send_category(node, _visibility, is_model)
-          return :concerns if node.method?(:include)
-          return nil unless is_model
-
-          return :associations if ASSOCIATIONS.include?(node.method_name)
-          return :validations if validation_method?(node)
-          return :callbacks if CALLBACKS.include?(node.method_name)
-          return :scopes if node.method?(:scope)
-
-          nil
-        end
-
-        # Sort elements by priority, sort key, and original index.
-        #
-        # @param [Array<Hash>] elements The list of elements.
-        # @return [Array<Hash>]
-        def sort_elements(elements)
-          elements.sort_by { |e| [e[:priority], e[:sort_key], e[:original_index]] }
-        end
-
         # Get sort key for alphabetical ordering within category.
         #
         # @param [Symbol] category The category.
@@ -459,14 +222,6 @@ module RuboCop
           node.method_name.to_s
         end
 
-        # Get the source of a node including preceding comments.
-        #
-        # @param [RuboCop::AST::Node] node The node.
-        # @return [String]
-        def source_with_comments(node)
-          node_range_with_comments(node).source
-        end
-
         # Check if node is a validation method.
         #
         # @param [RuboCop::AST::Node] node The node to check.
@@ -476,52 +231,15 @@ module RuboCop
             node.method_name.to_s.start_with?("validates_")
         end
 
-        # Check if element violates alphabetical ordering.
+        # Get the violation message for the current context.
         #
-        # @param [Hash] current The current element.
-        # @param [Hash] following The following element.
-        # @return [Boolean]
-        def violates_alphabetical_order?(current, following)
-          current[:priority] == following[:priority] &&
-            !current[:sort_key].empty? &&
-            current[:sort_key] > following[:sort_key]
-        end
-
-        # Check if element violates category ordering.
-        #
-        # @param [Hash] current The current element.
-        # @param [Hash] following The following element.
-        # @return [Boolean]
-        def violates_category_order?(current, following)
-          current[:priority] > following[:priority]
-        end
-
-        # Check if element violates ordering.
-        #
-        # @param [Hash] current The current element.
-        # @param [Hash] following The following element.
-        # @return [Boolean]
-        def violates_order?(current, following)
-          violates_category_order?(current, following) ||
-            violates_alphabetical_order?(current, following)
-        end
-
-        # Get category for visibility-based instance methods.
-        #
-        # @param [Symbol] visibility The visibility.
-        # @return [Symbol]
-        # @return [nil]
-        def visibility_method_category(visibility)
-          VISIBILITY_CATEGORIES[visibility]
-        end
-
-        # Check if node is a visibility modifier (public, protected, private).
-        #
-        # @param [RuboCop::AST::Node] node The node to check.
-        # @return [Boolean]
-        def visibility_modifier?(node)
-          node.send_type? && node.receiver.nil? &&
-            %i(public protected private).include?(node.method_name)
+        # @return [String]
+        def violation_message
+          if @is_model
+            MODEL_MSG
+          else
+            CLASS_MSG
+          end
         end
       end
     end

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

@@ -94,7 +94,9 @@ module RuboCop
 
           return if statements.size < 2
 
-          groups = group_consecutive_statements(statements, &:lvasgn_type?)
+          groups = group_consecutive_statements(statements) do |statement|
+            statement.lvasgn_type? && !statement.children.last.block_type?
+          end
 
           groups.each { |group| check_group_alignment(group) }
         end

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

@@ -92,7 +92,9 @@ module RuboCop
 
           return if statements.size < 2
 
-          groups = group_consecutive_statements(statements) { |s| s.casgn_type? && s.single_line? }
+          groups = group_consecutive_statements(statements) do |statement|
+            statement.casgn_type? && statement.single_line?
+          end
 
           groups.each { |group| check_group_alignment(group) }
         end

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

@@ -112,7 +112,7 @@ module RuboCop
 
           return if statements.size < 2
 
-          groups = group_consecutive_statements(statements) { |s| indexed_assignment?(s) }
+          groups = group_consecutive_statements(statements) { |statement| indexed_assignment?(statement) }
 
           groups.each { |group| check_group_alignment(group) }
         end

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

@@ -113,7 +113,7 @@ module RuboCop
 
           return if statements.size < 2
 
-          groups = group_consecutive_statements(statements) { |s| let_declaration?(s) }
+          groups = group_consecutive_statements(statements) { |statement| let_declaration?(statement) }
 
           groups.each { |group| check_group_alignment(group) }
         end

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

@@ -109,7 +109,7 @@ module RuboCop
 
           return if statements.size < 2
 
-          groups = group_consecutive_statements(statements) { |s| scope_declaration?(s) }
+          groups = group_consecutive_statements(statements) { |statement| scope_declaration?(statement) }
 
           groups.each { |group| check_group_alignment(group) }
         end

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

@@ -73,7 +73,7 @@ module RuboCop
         # @param [Array<RuboCop::AST::Node>] group The constants group.
         # @return [Boolean]
         def alphabetically_ordered?(group)
-          names = group.map { |c| c.name.to_s }
+          names = group.map { |constant| constant.name.to_s }
 
           names == names.sort
         end
@@ -84,7 +84,7 @@ module RuboCop
         # @param [Array<RuboCop::AST::Node>] group The constants group.
         # @return [void]
         def autocorrect(corrector, group)
-          sorted = group.sort_by { |c| c.name.to_s }
+          sorted = group.sort_by { |constant| constant.name.to_s }
 
           group.each_with_index do |constant, index|
             sorted_constant = sorted[index]

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

@@ -105,7 +105,7 @@ module RuboCop
         # @param [Array<Hash>] blocks The list of describe blocks.
         # @return [void]
         def autocorrect(corrector, blocks)
-          sorted_blocks = blocks.sort_by { |b| [b[:priority], b[:original_index]] }
+          sorted_blocks = blocks.sort_by { |block| [block[:priority], block[:original_index]] }
 
           blocks.each_with_index do |block, index|
             sorted_block = sorted_blocks[index]

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

@@ -105,7 +105,7 @@ module RuboCop
 
           return if statements.size < 2
 
-          groups = group_consecutive_statements(statements) { |s| let_declaration?(s) }
+          groups = group_consecutive_statements(statements) { |statement| let_declaration?(statement) }
 
           groups.each { |group| check_group_order(group) }
         end

data/lib/rubocop/cop/vibe/mixin/alignment_helpers.rb

@@ -10,6 +10,18 @@ module RuboCop
       module AlignmentHelpers
         private
 
+        # Check if two matched statements are consecutive (no gaps).
+        #
+        # @param [Array] first First [index, statement] pair.
+        # @param [Array] second Second [index, statement] pair.
+        # @param [Array<RuboCop::AST::Node>] statements Original statements.
+        # @return [Boolean]
+        def consecutive?(first, second, statements)
+          idx_a, stmt_a = first
+          idx_b, = second
+          idx_b == idx_a + 1 && no_blank_line_between?(stmt_a, statements[idx_b])
+        end
+
         # Extract statements from a body node.
         #
         # @param [RuboCop::AST::Node] body The body node.
@@ -22,20 +34,6 @@ module RuboCop
           end
         end
 
-        # Group consecutive statements based on a predicate.
-        #
-        # Iterates through statements and groups consecutive ones where the block
-        # returns true. Groups are broken by non-matching statements or blank lines.
-        #
-        # @param [Array<RuboCop::AST::Node>] statements The statements.
-        # @yield [RuboCop::AST::Node] Block to determine if statement matches criteria.
-        # @return [Array<Array<RuboCop::AST::Node>>] Groups of consecutive matching statements.
-        def group_consecutive_statements(statements, &)
-          matching_with_indices = find_matching_statements(statements, &)
-
-          group_by_consecutive_lines(matching_with_indices, statements)
-        end
-
         # Find statements matching the predicate with their indices.
         #
         # @param [Array<RuboCop::AST::Node>] statements The statements.
@@ -53,20 +51,22 @@ module RuboCop
         # @return [Array<Array<RuboCop::AST::Node>>] Groups with 2+ consecutive statements.
         def group_by_consecutive_lines(matches, statements)
           matches
-            .chunk_while { |a, b| consecutive?(a, b, statements) }
+            .chunk_while { |previous, current| consecutive?(previous, current, statements) }
             .filter_map { |group| group.map(&:last) if group.size > 1 }
         end
 
-        # Check if two matched statements are consecutive (no gaps).
+        # Group consecutive statements based on a predicate.
         #
-        # @param [Array] first First [index, statement] pair.
-        # @param [Array] second Second [index, statement] pair.
-        # @param [Array<RuboCop::AST::Node>] statements Original statements.
-        # @return [Boolean]
-        def consecutive?(first, second, statements)
-          idx_a, stmt_a = first
-          idx_b, = second
-          idx_b == idx_a + 1 && no_blank_line_between?(stmt_a, statements[idx_b])
+        # Iterates through statements and groups consecutive ones where the block
+        # returns true. Groups are broken by non-matching statements or blank lines.
+        #
+        # @param [Array<RuboCop::AST::Node>] statements The statements.
+        # @yield [RuboCop::AST::Node] Block to determine if statement matches criteria.
+        # @return [Array<Array<RuboCop::AST::Node>>] Groups of consecutive matching statements.
+        def group_consecutive_statements(statements, &)
+          matching_with_indices = find_matching_statements(statements, &)
+
+          group_by_consecutive_lines(matching_with_indices, statements)
         end
 
         # Check if there's no blank line between two statements.

data/lib/rubocop/cop/vibe/mixin/body_organization.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Vibe
+      # Shared helper methods for organizing class and module bodies.
+      #
+      # Including cops must implement:
+      #   - categorize_send_node(node, visibility) -> Symbol or nil
+      #   - priorities -> Hash
+      #   - sort_key_for(category, node) -> String
+      #   - violation_message -> String
+      module BodyOrganization
+        include OrganizationHelpers
+
+        private
+
+        # Get category for attr methods based on visibility.
+        def attr_category(visibility)
+          if visibility == :public
+            :attr_methods
+          else
+            visibility_method_category(visibility)
+          end
+        end
+
+        # Auto-correct by sorting elements within each visibility section.
+        def autocorrect(corrector, _container_node, elements)
+          elements.group_by { |element| element[:visibility] }.each_value do |section|
+            sorted = sort_elements(section)
+
+            next if sorted == section
+
+            replace_nodes(corrector, section, sorted)
+          end
+        end
+
+        # Categorize a node using shared logic and cop-specific send categorization.
+        def base_categorize_node(node, visibility)
+          return method_category(node, visibility) if node.any_def_type?
+          return :constants if node.casgn_type?
+          return nil if visibility_modifier?(node)
+          return attr_category(visibility) if attr_method?(node)
+
+          categorize_send_node(node, visibility)
+        end
+
+        # Build element hash for a node.
+        def build_body_element(child, visibility, index)
+          return unless child.type?(:send, :any_def, :casgn)
+
+          category = base_categorize_node(child, visibility)
+
+          return unless category
+
+          element_hash(child, category, visibility, index)
+        end
+
+        # Check and register violations.
+        def check_body_violations(container_node, elements)
+          violations = find_violations(elements)
+
+          return if violations.empty?
+
+          add_offense(violations.first[:node], message: violation_message) do |corrector|
+            autocorrect(corrector, container_node, elements)
+          end
+        end
+
+        # Collect elements from body nodes.
+        def collect_body_elements(body)
+          visibility = :public
+          elements   = []
+
+          process_body_nodes(body).each do |child|
+            visibility = child.method_name if visibility_modifier?(child)
+            element = build_body_element(child, visibility, elements.size)
+
+            elements << element if element
+          end
+
+          elements
+        end
+
+        # Create element hash.
+        def element_hash(node, category, visibility, index)
+          {
+            node:, category:, visibility:,
+            original_index: index,
+            priority:       priorities[category] || 999,
+            sort_key:       sort_key_for(category, node)
+          }
+        end
+
+        # Find elements that violate ordering.
+        def find_violations(elements)
+          elements.each_cons(2).filter_map do |current, following|
+            following if violates_order?(current, following)
+          end.uniq
+        end
+
+        # Categorize method nodes.
+        def method_category(node, visibility)
+          return :class_methods if node.defs_type?
+          return :initialize if node.method?(:initialize) && visibility == :public
+
+          visibility_method_category(visibility)
+        end
+
+        # Sort elements by priority, sort key, and original index.
+        def sort_elements(elements)
+          elements.sort_by { |element| [element[:priority], element[:sort_key], element[:original_index]] }
+        end
+
+        # Check if element violates alphabetical ordering.
+        def violates_alphabetical_order?(current, following)
+          current[:priority] == following[:priority] &&
+            !current[:sort_key].empty? &&
+            current[:sort_key] > following[:sort_key]
+        end
+
+        # Check if element violates ordering.
+        def violates_order?(current, following)
+          current[:priority] > following[:priority] ||
+            violates_alphabetical_order?(current, following)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/vibe/mixin/organization_helpers.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Vibe
+      # Low-level helpers for node ordering and comment handling.
+      #
+      # Used by BodyOrganization to handle source ranges, comments,
+      # visibility modifiers, and node replacement during autocorrect.
+      module OrganizationHelpers
+        ATTR_SORT_ORDER = { attr_accessor: "!0", attr_reader: "!1", attr_writer: "!2" }.freeze
+        VISIBILITY_CATEGORIES = {
+          protected: :protected_methods,
+          private:   :private_methods,
+          public:    :instance_methods
+        }.freeze
+
+        private
+
+        # Check if node is an attr method.
+        def attr_method?(node)
+          node.send_type? && ATTR_SORT_ORDER.key?(node.method_name)
+        end
+
+        # Get comments immediately before a node.
+        def comments_before(node)
+          consecutive   = []
+          expected_line = node.first_line - 1
+
+          while (comment = comments_by_line[expected_line])
+            consecutive.unshift(comment)
+            expected_line -= 1
+          end
+
+          consecutive
+        end
+
+        # Get comments indexed by line number for fast lookup.
+        def comments_by_line
+          @comments_by_line ||= processed_source.comments.to_h { |comment| [comment.location.line, comment] }
+        end
+
+        # Get the source range of a node including preceding comments.
+        def node_range_with_comments(node)
+          comment_list = comments_before(node)
+          start_range  = comment_list.any? ? comment_list.first.source_range : node.source_range
+          start_range.join(node.source_range)
+        end
+
+        # Process body nodes to get a flat list.
+        def process_body_nodes(body)
+          if body.begin_type?
+            body.children
+          else
+            [body]
+          end
+        end
+
+        # Replace nodes during auto-correct.
+        def replace_nodes(corrector, group, sorted)
+          sorted.each_with_index do |element, idx|
+            original = group[idx]
+
+            next if element[:node] == original[:node]
+
+            corrector.replace(node_range_with_comments(original[:node]),
+                              node_range_with_comments(element[:node]).source)
+          end
+        end
+
+        # Get category for visibility-based instance methods.
+        def visibility_method_category(visibility)
+          VISIBILITY_CATEGORIES[visibility]
+        end
+
+        # Check if node is a visibility modifier.
+        def visibility_modifier?(node)
+          node.send_type? && node.receiver.nil? &&
+            %i(public protected private).include?(node.method_name)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Vibe
+      # Enforces consistent organization of module definitions.
+      #
+      # Enforces: includes/extends → constants → attr → class methods →
+      # instance methods → protected → private.
+      #
+      # Within each category, methods are sorted alphabetically.
+      #
+      # @example
+      #   # bad
+      #   module Helper
+      #     def zebra
+      #     end
+      #
+      #     def alpha
+      #     end
+      #
+      #     include Foo
+      #   end
+      #
+      #   # good
+      #   module Helper
+      #     include Foo
+      #
+      #     def alpha
+      #     end
+      #
+      #     def zebra
+      #     end
+      #   end
+      class ModuleOrganization < Base
+        extend AutoCorrector
+        include BodyOrganization
+
+        MODULE_MSG = "Module elements should be ordered: includes/extends → constants → attr → " \
+                     "class methods → instance methods → protected → private."
+        MODULE_PRIORITIES = {
+          concerns:          10,
+          constants:         20,
+          attr_methods:      25,
+          class_methods:     35,
+          instance_methods:  40,
+          protected_methods: 50,
+          private_methods:   60
+        }.freeze
+
+        # Check module nodes for organization.
+        #
+        # @param [RuboCop::AST::Node] node The module node.
+        # @return [void]
+        def on_module(node)
+          return unless node.body
+
+          elements = collect_body_elements(node.body)
+
+          return if elements.size < 2
+
+          check_body_violations(node, elements)
+        end
+
+        private
+
+        # Categorize send nodes for modules.
+        #
+        # @param [RuboCop::AST::Node] node The node to categorize.
+        # @param [Symbol] _visibility The current visibility.
+        # @return [Symbol]
+        # @return [nil]
+        def categorize_send_node(node, _visibility)
+          return :concerns if node.method?(:include) || node.method?(:extend)
+
+          nil
+        end
+
+        # Get the priority hash.
+        #
+        # @return [Hash]
+        def priorities
+          MODULE_PRIORITIES
+        end
+
+        # Get sort key for alphabetical ordering within category.
+        #
+        # @param [Symbol] category The category.
+        # @param [RuboCop::AST::Node] node The node.
+        # @return [String]
+        def sort_key_for(category, node)
+          sortable = %i(class_methods instance_methods protected_methods private_methods)
+
+          return "" unless sortable.include?(category)
+          return ATTR_SORT_ORDER[node.method_name] if attr_method?(node)
+
+          node.method_name.to_s
+        end
+
+        # Get the violation message.
+        #
+        # @return [String]
+        def violation_message
+          MODULE_MSG
+        end
+      end
+    end
+  end
+end

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

@@ -97,7 +97,7 @@ module RuboCop
         # @param [RuboCop::AST::Node] node The node.
         # @return [RuboCop::AST::Node, nil]
         def conditional_ancestor(node)
-          node.each_ancestor.find { |a| a.type?(:if, :while, :until, :when) }
+          node.each_ancestor.find { |ancestor| ancestor.type?(:if, :while, :until, :when) }
         end
 
         # Check if node is in a conditional position (if/unless/while/until/when condition).

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

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Vibe
+      # Disallows single character variable names.
+      #
+      # Single character names tend to obscure intent. The cop flags local
+      # variables, instance variables, class variables, method and block
+      # parameters, and rescue variables. The leading `@` or `@@` sigil is
+      # ignored when measuring length, so `@a` and `@@a` are treated as
+      # single character names.
+      #
+      # Names listed in `AllowedNames` are ignored. The default list contains
+      # `_`, which conventionally marks an intentionally unused value.
+      #
+      # @example
+      #   # bad
+      #   x = 1
+      #   @a = 1
+      #   def foo(n); end
+      #   [1].each { |i| i }
+      #
+      #   # good
+      #   count = 1
+      #   @account = 1
+      #   def foo(name); end
+      #   [1].each { |index| index }
+      #
+      # @example AllowedNames: ['_', 'i', 'j']
+      #   # good
+      #   2.times { |i| i }
+      #
+      # The block parameter `t` is allowed in files under `db/`, where it is a
+      # convention for Rails migrations (e.g. `create_table :users do |t|`).
+      class NoSingleCharacterVariableNames < Base
+        MIGRATION_BLOCK_VARIABLE = "t"
+        MIGRATION_PATH_PATTERN   = %r{(?:\A|/)db/}
+        MSG                      = "Avoid single character variable name `%<name>s`."
+
+        # @param node [RuboCop::AST::Node]
+        # @return [void]
+        def on_arg(node)
+          check(node, node.name)
+        end
+        alias on_blockarg on_arg
+        alias on_cvasgn on_arg
+        alias on_ivasgn on_arg
+        alias on_kwarg on_arg
+        alias on_kwoptarg on_arg
+        alias on_kwrestarg on_arg
+        alias on_lvasgn on_arg
+        alias on_optarg on_arg
+        alias on_restarg on_arg
+
+        private
+
+        # @return [Array<String>]
+        def allowed_names
+          @allowed_names ||= Array(cop_config.fetch("AllowedNames", ["_"]))
+        end
+
+        # @param node [RuboCop::AST::Node]
+        # @param name [Symbol, nil]
+        # @return [void]
+        def check(node, name)
+          return if name.nil?
+
+          bare = name.to_s.sub(/\A@@?/, "")
+
+          return if bare.length != 1
+          return if allowed_names.include?(bare)
+          return if migration_block_variable?(bare)
+
+          add_offense(node.loc.name, message: format(MSG, name: name))
+        end
+
+        # @param bare [String] the variable name without sigils.
+        # @return [Boolean]
+        def migration_block_variable?(bare)
+          bare == MIGRATION_BLOCK_VARIABLE && migration_file?
+        end
+
+        # @return [Boolean]
+        def migration_file?
+          processed_source.file_path.match?(MIGRATION_PATH_PATTERN)
+        end
+      end
+    end
+  end
+end

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

@@ -109,7 +109,7 @@ module RuboCop
         # @param [Array<RuboCop::AST::Node>] chain The method chain.
         # @return [Boolean]
         def chain_has_with?(chain)
-          chain.any? { |n| n.method?(:with) }
+          chain.any? { |node| node.method?(:with) }
         end
 
         # Check if the method is one we care about for chaining.
@@ -190,7 +190,7 @@ module RuboCop
         # @param [Array<RuboCop::AST::Node>] chain The method chain.
         # @return [Integer, nil]
         def find_receive_index(chain)
-          chain.index { |n| RECEIVE_METHODS.include?(n.method_name) }
+          chain.index { |node| RECEIVE_METHODS.include?(node.method_name) }
         end
 
         # Find the starting position for the replacement.

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

@@ -66,8 +66,8 @@ module RuboCop
         # @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) }
+          validates_nodes = group.select { |node| VALIDATES_METHODS.include?(node.method_name) }
+          validate_nodes  = group.select { |node| node.method?(VALIDATE_METHOD) }
           sorted          = validates_nodes + validate_nodes
 
           group.each_with_index do |node, index|
@@ -104,7 +104,7 @@ module RuboCop
 
           return if statements.size < 2
 
-          groups = group_consecutive_statements(statements) { |s| validates_family?(s) }
+          groups = group_consecutive_statements(statements) { |statement| validates_family?(statement) }
 
           groups.each { |group| check_group_order(group) }
         end
@@ -114,7 +114,7 @@ module RuboCop
         # @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) }
+          last_validates_index = group.rindex { |node| VALIDATES_METHODS.include?(node.method_name) }
 
           return [] if last_validates_index.nil?
 

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

@@ -60,7 +60,7 @@ module RuboCop
         # @param [Array<RuboCop::AST::Node>] group The validates group.
         # @return [Boolean]
         def alphabetically_ordered?(group)
-          names = group.map { |v| extract_validates_name(v) }
+          names = group.map { |validates| extract_validates_name(validates) }
 
           names == names.sort
         end
@@ -71,7 +71,7 @@ module RuboCop
         # @param [Array<RuboCop::AST::Node>] group The validates group.
         # @return [void]
         def autocorrect(corrector, group)
-          sorted = group.sort_by { |v| extract_validates_name(v) }
+          sorted = group.sort_by { |validates| extract_validates_name(validates) }
 
           group.each_with_index do |validates, index|
             sorted_validates = sorted[index]
@@ -107,7 +107,7 @@ module RuboCop
 
           return if statements.size < 2
 
-          groups = group_consecutive_statements(statements) { |s| validates_declaration?(s) }
+          groups = group_consecutive_statements(statements) { |statement| validates_declaration?(statement) }
 
           groups.each { |group| check_group_order(group) }
         end

data/lib/rubocop/cop/vibe_cops.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 require_relative "vibe/mixin/alignment_helpers"
+require_relative "vibe/mixin/organization_helpers"
+require_relative "vibe/mixin/body_organization"
 require_relative "vibe/mixin/spec_file_helper"
 
 require_relative "vibe/attr_order"
@@ -19,10 +21,12 @@ 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/module_organization"
 require_relative "vibe/multiline_hash_argument_style"
 require_relative "vibe/no_assigns_attribute_testing"
 require_relative "vibe/no_compound_conditions"
 require_relative "vibe/no_rubocop_disable"
+require_relative "vibe/no_single_character_variable_names"
 require_relative "vibe/no_skipped_tests"
 require_relative "vibe/no_unless_guard_clause"
 require_relative "vibe/prefer_one_liner_expectation"

data/lib/rubocop/vibe/version.rb

@@ -2,6 +2,6 @@
 
 module RuboCop
   module Vibe
-    VERSION = "0.6.0"
+    VERSION = "0.7.0"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-vibe
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Tristan Dunn
@@ -104,11 +104,15 @@ files:
 - 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/body_organization.rb
+- lib/rubocop/cop/vibe/mixin/organization_helpers.rb
 - lib/rubocop/cop/vibe/mixin/spec_file_helper.rb
+- lib/rubocop/cop/vibe/module_organization.rb
 - lib/rubocop/cop/vibe/multiline_hash_argument_style.rb
 - lib/rubocop/cop/vibe/no_assigns_attribute_testing.rb
 - lib/rubocop/cop/vibe/no_compound_conditions.rb
 - lib/rubocop/cop/vibe/no_rubocop_disable.rb
+- lib/rubocop/cop/vibe/no_single_character_variable_names.rb
 - lib/rubocop/cop/vibe/no_skipped_tests.rb
 - lib/rubocop/cop/vibe/no_unless_guard_clause.rb
 - lib/rubocop/cop/vibe/prefer_one_liner_expectation.rb
@@ -144,7 +148,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.9
+rubygems_version: 4.0.23
 specification_version: 4
 summary: A set of custom cops to use on AI generated code.
 test_files: []