rubocop-vibe 0.2.0 → 0.3.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_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)

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

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Vibe
+      # Enforces using explicit `if`/`else`/`end` blocks instead of ternary operators
+      # or trailing conditionals when they are the return value of a method.
+      #
+      # Ternary operators and trailing conditionals can be harder to read when used
+      # as method return values. This cop enforces converting them to explicit
+      # `if`/`else`/`end` blocks for better readability.
+      #
+      # @example
+      #   # bad - ternary as return value
+      #   def allow_origin
+      #     origin = request.headers["Origin"]
+      #     origin_allowed?(origin) ? origin : "*"
+      #   end
+      #
+      #   # good - explicit if/else
+      #   def allow_origin
+      #     origin = request.headers["Origin"]
+      #     if origin_allowed?(origin)
+      #       origin
+      #     else
+      #       "*"
+      #     end
+      #   end
+      #
+      #   # bad - trailing conditional as return value
+      #   def vary
+      #     "Origin" if website.present?
+      #   end
+      #
+      #   # good - explicit if block
+      #   def vary
+      #     if website.present?
+      #       "Origin"
+      #     end
+      #   end
+      #
+      #   # good - ternary used in assignment (not as return value)
+      #   def example
+      #     result = condition ? "yes" : "no"
+      #     process(result)
+      #   end
+      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."
+
+        # Check method definitions for conditional return values.
+        #
+        # @param [RuboCop::AST::Node] node The def node.
+        # @return [void]
+        def on_def(node)
+          if node.body
+            check_return_value(node.body)
+          end
+        end
+        alias on_defs on_def
+
+        private
+
+        # Check if the return value is a conditional that should be explicit.
+        #
+        # @param [RuboCop::AST::Node] body The method body node.
+        # @return [void]
+        def check_return_value(body)
+          return_node = find_return_node(body)
+
+          return unless return_node.if_type?
+
+          if return_node.ternary?
+            register_ternary_offense(return_node)
+          elsif return_node.modifier_form?
+            register_modifier_offense(return_node)
+          end
+        end
+
+        # Find the node that represents the return value.
+        #
+        # @param [RuboCop::AST::Node] body The method body node.
+        # @return [RuboCop::AST::Node, nil]
+        def find_return_node(body)
+          if body.begin_type?
+            body.children.last
+          else
+            body
+          end
+        end
+
+        # Register offense for ternary operator.
+        #
+        # @param [RuboCop::AST::Node] node The ternary node.
+        # @return [void]
+        def register_ternary_offense(node)
+          add_offense(node, message: MSG_TERNARY) do |corrector|
+            autocorrect_ternary(corrector, node)
+          end
+        end
+
+        # Register offense for modifier conditional.
+        #
+        # @param [RuboCop::AST::Node] node The modifier if node.
+        # @return [void]
+        def register_modifier_offense(node)
+          add_offense(node, message: MSG_MODIFIER) do |corrector|
+            autocorrect_modifier(corrector, node)
+          end
+        end
+
+        # Autocorrect ternary operator to if/else/end block.
+        #
+        # @param [RuboCop::Cop::Corrector] corrector The corrector.
+        # @param [RuboCop::AST::Node] node The ternary node.
+        # @return [void]
+        def autocorrect_ternary(corrector, node)
+          corrector.replace(node, build_if_else_block(node))
+        end
+
+        # Autocorrect modifier conditional to if/end block.
+        #
+        # @param [RuboCop::Cop::Corrector] corrector The corrector.
+        # @param [RuboCop::AST::Node] node The modifier if node.
+        # @return [void]
+        def autocorrect_modifier(corrector, node)
+          corrector.replace(node, build_if_block(node))
+        end
+
+        # Build if/else/end block replacement for ternary.
+        #
+        # @param [RuboCop::AST::Node] node The ternary node.
+        # @return [String]
+        def build_if_else_block(node)
+          base_indent  = " " * node.loc.column
+          inner_indent = "#{base_indent}  "
+
+          [
+            "if #{node.condition.source}",
+            "#{inner_indent}#{node.if_branch.source}",
+            "#{base_indent}else",
+            "#{inner_indent}#{node.else_branch.source}",
+            "#{base_indent}end"
+          ].join("\n")
+        end
+
+        # Build if/end block replacement for modifier conditional.
+        #
+        # @param [RuboCop::AST::Node] node The modifier if node.
+        # @return [String]
+        def build_if_block(node)
+          condition    = build_condition(node)
+          base_indent  = " " * node.loc.column
+          inner_indent = "#{base_indent}  "
+
+          [
+            "if #{condition}",
+            "#{inner_indent}#{node.if_branch.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.
+        #
+        # @param [RuboCop::AST::Node] node The if node.
+        # @return [String] The condition source.
+        def build_condition(node)
+          if node.unless?
+            negate_condition(node.condition)
+          else
+            node.condition.source
+          end
+        end
+
+        # Negate a condition, handling simple cases cleanly.
+        #
+        # @param [RuboCop::AST::Node] condition The condition node.
+        # @return [String] The negated condition.
+        def negate_condition(condition)
+          if condition.send_type? && condition.method?(:!)
+            condition.receiver.source
+          else
+            "!#{condition.source}"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -45,6 +45,7 @@ module RuboCop
           return unless is_expected_call?(node)
 
           example_block = find_example_block(node)
+
           return unless example_block
           return unless example_block_with_description?(example_block)
           return if complex_expectation?(example_block)
@@ -65,6 +66,7 @@ module RuboCop
         def find_example_block(node)
           node.each_ancestor(:block).find do |ancestor|
             send_node = ancestor.send_node
+
             send_node.method?(:it) || send_node.method?(:specify)
           end
         end
@@ -100,6 +102,7 @@ module RuboCop
         # @return [void]
         def autocorrect(corrector, node)
           expectation_source = node.body.source
+
           corrector.replace(node, "it { #{expectation_source} }")
         end
       end