rubocop-vibe 0.2.0 → 0.4.0

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

@@ -27,6 +27,7 @@ module RuboCop
       #   DEFAULT_VALUE = 0  # Separate group, not aligned
       class ConsecutiveConstantAlignment < Base
         extend AutoCorrector
+        include AlignmentHelpers
 
         MSG = "Align consecutive constant assignments at the `=` operator."
 
@@ -58,109 +59,12 @@ module RuboCop
         # @return [void]
         def check_constants_in_body(body)
           statements = extract_statements(body)
-          return if statements.size < 2
-
-          groups = group_consecutive_constants(statements)
-          groups.each { |group| check_group_alignment(group) }
-        end
-
-        # Extract statements from a body node.
-        #
-        # @param [RuboCop::AST::Node] body The body node.
-        # @return [Array<RuboCop::AST::Node>]
-        def extract_statements(body)
-          if body.begin_type?
-            body.children
-          else
-            [body]
-          end
-        end
-
-        # Group consecutive constant assignments together.
-        #
-        # @param [Array<RuboCop::AST::Node>] statements The statements.
-        # @return [Array<Array<RuboCop::AST::Node>>] Groups of consecutive constants.
-        def group_consecutive_constants(statements)
-          groups        = []
-          current_group = []
-          previous_line = nil
-
-          statements.each do |statement|
-            current_group, previous_line = process_statement(statement, current_group, previous_line, groups)
-          end
-
-          finalize_groups(groups, current_group)
-        end
-
-        # Process a single statement for grouping.
-        #
-        # @param [RuboCop::AST::Node] statement The statement.
-        # @param [Array<RuboCop::AST::Node>] current_group The current group.
-        # @param [Integer, nil] previous_line The previous line number.
-        # @param [Array<Array<RuboCop::AST::Node>>] groups The groups.
-        # @return [Array] The updated current_group and previous_line.
-        def process_statement(statement, current_group, previous_line, groups)
-          if constant_assignment?(statement)
-            current_group = handle_constant(statement, current_group, previous_line, groups)
-          else
-            save_group_if_valid(groups, current_group)
-            current_group = []
-          end
-          [current_group, statement.loc.last_line]
-        end
 
-        # Check if node is a single-line constant assignment.
-        #
-        # Only single-line constants are considered for alignment to avoid
-        # conflicts with multi-line hash/array constants and Layout/ExtraSpacing.
-        #
-        # @param [RuboCop::AST::Node] node The node.
-        # @return [Boolean]
-        def constant_assignment?(node)
-          node.casgn_type? && single_line?(node)
-        end
-
-        # Check if node is on a single line.
-        #
-        # @param [RuboCop::AST::Node] node The node.
-        # @return [Boolean]
-        def single_line?(node)
-          node.single_line?
-        end
+          return if statements.size < 2
 
-        # Handle a constant assignment.
-        #
-        # @param [RuboCop::AST::Node] statement The constant assignment.
-        # @param [Array<RuboCop::AST::Node>] current_group The current group.
-        # @param [Integer, nil] previous_line The previous line number.
-        # @param [Array<Array<RuboCop::AST::Node>>] groups The groups.
-        # @return [Array<RuboCop::AST::Node>] The updated current group.
-        def handle_constant(statement, current_group, previous_line, groups)
-          if previous_line && statement.loc.line - previous_line > 1
-            save_group_if_valid(groups, current_group)
-            current_group = []
-          end
-          current_group << statement
-          current_group
-        end
+          groups = group_consecutive_statements(statements) { |s| s.casgn_type? && s.single_line? }
 
-        # Save group if it has multiple constant assignments.
-        #
-        # @param [Array<Array<RuboCop::AST::Node>>] groups The groups.
-        # @param [Array<RuboCop::AST::Node>] group The group to potentially save.
-        # @return [void]
-        def save_group_if_valid(groups, group)
-          groups << group if group.size > 1
-        end
-
-        # Finalize groups by adding any remaining valid group.
-        #
-        # @param [Array<Array<RuboCop::AST::Node>>] groups The groups.
-        # @param [Array<RuboCop::AST::Node>] current_group The current group.
-        # @return [Array<Array<RuboCop::AST::Node>>] The finalized groups.
-        def finalize_groups(groups, current_group)
-          save_group_if_valid(groups, current_group)
-          groups
+          groups.each { |group| check_group_alignment(group) }
         end
 
         # Check alignment for a group of constant assignments.
@@ -173,6 +77,7 @@ module RuboCop
 
           group.each do |const|
             current_column = const.loc.operator.column
+
             next if current_column == target_column
 
             add_offense(const.loc.name) do |corrector|
@@ -210,19 +115,6 @@ module RuboCop
 
           [1, current_spaces + spaces_needed].max
         end
-
-        # Create a source range between two positions.
-        #
-        # @param [Integer] start_pos The start position.
-        # @param [Integer] end_pos The end position.
-        # @return [Parser::Source::Range]
-        def range_between(start_pos, end_pos)
-          Parser::Source::Range.new(
-            processed_source.buffer,
-            start_pos,
-            end_pos
-          )
-        end
       end
     end
   end

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

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Vibe
+      # Enforces alignment of consecutive indexed assignments at the `=` operator.
+      #
+      # Consecutive indexed assignments (with no blank lines between) should align
+      # their `=` operators for better readability. Groups are broken by blank lines.
+      #
+      # @example
+      #   # bad
+      #   response.headers["Cache-Control"] = "public, max-age=3600"
+      #   response.headers["Content-Type"] = "application/javascript"
+      #
+      #   # good
+      #   response.headers["Cache-Control"] = "public, max-age=3600"
+      #   response.headers["Content-Type"]  = "application/javascript"
+      #
+      #   # good - blank line breaks the group
+      #   response.headers["Cache-Control"] = "public, max-age=3600"
+      #
+      #   hash["key"] = "value"  # Separate group, not aligned
+      class ConsecutiveIndexedAssignmentAlignment < Base
+        extend AutoCorrector
+        include AlignmentHelpers
+
+        MSG = "Align consecutive indexed assignments at the = operator."
+
+        # Check block nodes for indexed assignment alignment.
+        #
+        # @param [RuboCop::AST::Node] node The block node.
+        # @return [void]
+        def on_block(node)
+          if node.body
+            check_indexed_assignments_in_body(node.body)
+          end
+        end
+        alias on_numblock on_block
+
+        # Check method definitions for indexed assignment alignment.
+        #
+        # @param [RuboCop::AST::Node] node The def node.
+        # @return [void]
+        def on_def(node)
+          if node.body
+            check_indexed_assignments_in_body(node.body)
+          end
+        end
+        alias on_defs on_def
+
+        private
+
+        # Check indexed assignments in a body node.
+        #
+        # @param [RuboCop::AST::Node] body The body node.
+        # @return [void]
+        def check_indexed_assignments_in_body(body)
+          statements = extract_statements(body)
+
+          return if statements.size < 2
+
+          groups = group_consecutive_statements(statements) { |s| indexed_assignment?(s) }
+
+          groups.each { |group| check_group_alignment(group) }
+        end
+
+        # Check if a node is an indexed assignment.
+        #
+        # @param [RuboCop::AST::Node] node The node to check.
+        # @return [Boolean]
+        def indexed_assignment?(node)
+          node.send_type? && node.method?(:[]=)
+        end
+
+        # Check alignment for a group of indexed 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(offense_location(asgn)) do |corrector|
+              autocorrect_alignment(corrector, asgn, target_column)
+            end
+          end
+        end
+
+        # Get the location to highlight for the offense.
+        #
+        # @param [RuboCop::AST::Node] asgn The indexed assignment node.
+        # @return [Parser::Source::Range]
+        def offense_location(asgn)
+          asgn.loc.selector
+        end
+
+        # Auto-correct the alignment of an indexed assignment.
+        #
+        # @param [RuboCop::AST::Corrector] corrector The corrector.
+        # @param [RuboCop::AST::Node] asgn The indexed assignment node.
+        # @param [Integer] target_column The target column for alignment.
+        # @return [void]
+        def autocorrect_alignment(corrector, asgn, target_column)
+          bracket_end    = closing_bracket_end_pos(asgn)
+          operator_start = asgn.loc.operator.begin_pos
+          total_spaces   = calculate_total_spaces(asgn, target_column, bracket_end, operator_start)
+
+          corrector.replace(
+            range_between(bracket_end, operator_start),
+            " " * total_spaces
+          )
+        end
+
+        # Get the position after the closing bracket.
+        #
+        # @param [RuboCop::AST::Node] asgn The indexed assignment node.
+        # @return [Integer]
+        def closing_bracket_end_pos(asgn)
+          asgn.first_argument.source_range.end_pos + 1
+        end
+
+        # Calculate total spaces needed for alignment.
+        #
+        # @param [RuboCop::AST::Node] asgn The indexed assignment node.
+        # @param [Integer] target_column The target column for alignment.
+        # @param [Integer] bracket_end Position after the closing bracket.
+        # @param [Integer] operator_start Position of the operator.
+        # @return [Integer] The number of spaces (minimum 1).
+        def calculate_total_spaces(asgn, target_column, bracket_end, operator_start)
+          current_column = asgn.loc.operator.column
+          current_spaces = operator_start - bracket_end
+          spaces_needed  = target_column - current_column
+
+          [1, current_spaces + spaces_needed].max
+        end
+      end
+    end
+  end
+end

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

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

@@ -28,6 +28,7 @@ module RuboCop
       class ConsecutiveLetAlignment < Base
         extend AutoCorrector
         include SpecFileHelper
+        include AlignmentHelpers
 
         MSG = "Align consecutive `let` declarations at the `{` brace."
 
@@ -66,90 +67,12 @@ module RuboCop
         # @return [void]
         def check_lets_in_body(body)
           statements = extract_statements(body)
-          return if statements.size < 2
-
-          groups = group_consecutive_lets(statements)
-          groups.each { |group| check_group_alignment(group) }
-        end
-
-        # Extract statements from a body node.
-        #
-        # @param [RuboCop::AST::Node] body The body node.
-        # @return [Array<RuboCop::AST::Node>]
-        def extract_statements(body)
-          if body.begin_type?
-            body.children
-          else
-            [body]
-          end
-        end
-
-        # Group consecutive let declarations together.
-        #
-        # @param [Array<RuboCop::AST::Node>] statements The statements.
-        # @return [Array<Array<RuboCop::AST::Node>>] Groups of consecutive lets.
-        def group_consecutive_lets(statements)
-          groups        = []
-          current_group = []
-          previous_line = nil
-
-          statements.each do |statement|
-            current_group, previous_line = process_statement(statement, current_group, previous_line, groups)
-          end
-
-          finalize_groups(groups, current_group)
-        end
-
-        # Process a single statement for grouping.
-        #
-        # @param [RuboCop::AST::Node] statement The statement.
-        # @param [Array<RuboCop::AST::Node>] current_group The current group.
-        # @param [Integer, nil] previous_line The previous line number.
-        # @param [Array<Array<RuboCop::AST::Node>>] groups The groups.
-        # @return [Array] The updated current_group and previous_line.
-        def process_statement(statement, current_group, previous_line, groups)
-          if let_declaration?(statement)
-            current_group = handle_let(statement, current_group, previous_line, groups)
-          else
-            save_group_if_valid(groups, current_group)
-            current_group = []
-          end
-          [current_group, statement.loc.last_line]
-        end
 
-        # Handle a let declaration.
-        #
-        # @param [RuboCop::AST::Node] statement The let declaration.
-        # @param [Array<RuboCop::AST::Node>] current_group The current group.
-        # @param [Integer, nil] previous_line The previous line number.
-        # @param [Array<Array<RuboCop::AST::Node>>] groups The groups.
-        # @return [Array<RuboCop::AST::Node>] The updated current group.
-        def handle_let(statement, current_group, previous_line, groups)
-          if previous_line && statement.loc.line - previous_line > 1
-            save_group_if_valid(groups, current_group)
-            current_group = []
-          end
-          current_group << statement
-          current_group
-        end
+          return if statements.size < 2
 
-        # Save group if it has multiple let declarations.
-        #
-        # @param [Array<Array<RuboCop::AST::Node>>] groups The groups.
-        # @param [Array<RuboCop::AST::Node>] group The group to potentially save.
-        # @return [void]
-        def save_group_if_valid(groups, group)
-          groups << group if group.size > 1
-        end
+          groups = group_consecutive_statements(statements) { |s| let_declaration?(s) }
 
-        # Finalize groups by adding any remaining valid group.
-        #
-        # @param [Array<Array<RuboCop::AST::Node>>] groups The groups.
-        # @param [Array<RuboCop::AST::Node>] current_group The current group.
-        # @return [Array<Array<RuboCop::AST::Node>>] The finalized groups.
-        def finalize_groups(groups, current_group)
-          save_group_if_valid(groups, current_group)
-          groups
+          groups.each { |group| check_group_alignment(group) }
         end
 
         # Check alignment for a group of let declarations.
@@ -162,6 +85,7 @@ module RuboCop
 
           group.each do |let|
             current_column = let.loc.begin.column
+
             next if current_column == target_column
 
             add_offense(let.send_node) do |corrector|
@@ -200,19 +124,6 @@ module RuboCop
 
           [1, current_spaces + spaces_needed].max
         end
-
-        # Create a source range between two positions.
-        #
-        # @param [Integer] start_pos The start position.
-        # @param [Integer] end_pos The end position.
-        # @return [Parser::Source::Range]
-        def range_between(start_pos, end_pos)
-          Parser::Source::Range.new(
-            processed_source.buffer,
-            start_pos,
-            end_pos
-          )
-        end
       end
     end
   end

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

@@ -83,9 +83,11 @@ module RuboCop
           return unless top_level_describe?(node)
 
           describe_blocks = extract_describe_blocks(node)
+
           return if describe_blocks.size < 2
 
           violations = find_ordering_violations(describe_blocks)
+
           violations.each do |block_info|
             add_offense(block_info[:node]) do |corrector|
               autocorrect(corrector, describe_blocks)
@@ -153,15 +155,15 @@ module RuboCop
         # @return [nil] When description is not a string/symbol literal.
         def extract_description(node)
           first_arg = node.send_node.first_argument
+
           return unless first_arg
 
           if first_arg.str_type?
             first_arg.value
           elsif first_arg.sym_type?
             first_arg.value.to_s
-            # Intentionally returns nil for constants/variables.
-            # These will get DEFAULT_PRIORITY.
           end
+          # Returns nil for constants/variables - they get DEFAULT_PRIORITY.
         end
 
         # Categorize description and assign priority.
@@ -202,6 +204,7 @@ module RuboCop
         def controller_action_priority(description)
           # Strip the # prefix for controller actions.
           action_name = description.start_with?("#") ? description[1..] : description
+
           if controller_action?(action_name)
             30 + CONTROLLER_ACTIONS.index(action_name)
           end
@@ -251,6 +254,7 @@ module RuboCop
 
           blocks.each_with_index do |block, index|
             sorted_block = sorted_blocks[index]
+
             next if block == sorted_block
 
             corrector.replace(block[:node], sorted_block[:node].source)