rubocop-vibe 0.1.0 → 0.3.0

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

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Vibe
+      # Enforces alignment of consecutive constant assignments at the `=` operator.
+      #
+      # Consecutive constant assignments (with no blank lines between) should align their
+      # `=` operators for better readability. Groups are broken by blank lines or non-constant
+      # statements.
+      #
+      # @example
+      #   # bad
+      #   MINIMUM_NAME_LENGTH = 3
+      #   MAXIMUM_NAME_LENGTH = 12
+      #   ACTIVE_DURATION = 15.minutes
+      #
+      #   # good
+      #   MINIMUM_NAME_LENGTH = 3
+      #   MAXIMUM_NAME_LENGTH = 12
+      #   ACTIVE_DURATION     = 15.minutes
+      #
+      #   # good - blank line breaks the group
+      #   THROTTLE_LIMIT  = 10
+      #   THROTTLE_PERIOD = 5
+      #
+      #   DEFAULT_VALUE = 0  # Separate group, not aligned
+      class ConsecutiveConstantAlignment < Base
+        extend AutoCorrector
+        include AlignmentHelpers
+
+        MSG = "Align consecutive constant assignments at the `=` operator."
+
+        # Check class nodes for constant alignment.
+        #
+        # @param [RuboCop::AST::Node] node The class node.
+        # @return [void]
+        def on_class(node)
+          if node.body
+            check_constants_in_body(node.body)
+          end
+        end
+
+        # Check module nodes for constant alignment.
+        #
+        # @param [RuboCop::AST::Node] node The module node.
+        # @return [void]
+        def on_module(node)
+          if node.body
+            check_constants_in_body(node.body)
+          end
+        end
+
+        private
+
+        # Check constants in a body node.
+        #
+        # @param [RuboCop::AST::Node] body The body node.
+        # @return [void]
+        def check_constants_in_body(body)
+          statements = extract_statements(body)
+
+          return if statements.size < 2
+
+          groups = group_consecutive_statements(statements) { |s| s.casgn_type? && s.single_line? }
+
+          groups.each { |group| check_group_alignment(group) }
+        end
+
+        # Check alignment for a group of constant assignments.
+        #
+        # @param [Array<RuboCop::AST::Node>] group The constant group.
+        # @return [void]
+        def check_group_alignment(group)
+          columns       = group.map { |const| const.loc.operator.column }
+          target_column = columns.max
+
+          group.each do |const|
+            current_column = const.loc.operator.column
+
+            next if current_column == target_column
+
+            add_offense(const.loc.name) do |corrector|
+              autocorrect_alignment(corrector, const, target_column)
+            end
+          end
+        end
+
+        # Auto-correct the alignment of a constant assignment.
+        #
+        # @param [RuboCop::AST::Corrector] corrector The corrector.
+        # @param [RuboCop::AST::Node] const The constant assignment node.
+        # @param [Integer] target_column The target column for alignment.
+        # @return [void]
+        def autocorrect_alignment(corrector, const, target_column)
+          name_end       = const.loc.name.end_pos
+          operator_start = const.loc.operator.begin_pos
+          total_spaces   = calculate_total_spaces(const, target_column)
+
+          corrector.replace(
+            range_between(name_end, operator_start),
+            " " * total_spaces
+          )
+        end
+
+        # Calculate total spaces needed for alignment.
+        #
+        # @param [RuboCop::AST::Node] const The constant assignment node.
+        # @param [Integer] target_column The target column for alignment.
+        # @return [Integer] The number of spaces (minimum 1).
+        def calculate_total_spaces(const, target_column)
+          current_column = const.loc.operator.column
+          current_spaces = const.loc.operator.begin_pos - const.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_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

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Vibe
+      # Enforces alignment of consecutive `let` declarations at the `{` brace.
+      #
+      # Consecutive `let` declarations (with no blank lines between) should align their
+      # `{` braces for better readability. Groups are broken by blank lines or non-let
+      # statements.
+      #
+      # @example
+      #   # bad
+      #   let(:character) { instance_double(Character) }
+      #   let(:damage) { 1 }
+      #   let(:instance) { described_class.new }
+      #
+      #   # good
+      #   let(:character) { instance_double(Character) }
+      #   let(:damage)    { 1 }
+      #   let(:instance)  { described_class.new }
+      #
+      #   # good - blank line breaks the group
+      #   let(:user)      { create(:user) }
+      #   let(:character) { create(:character) }
+      #
+      #   let(:service) { Users::Activate.new }  # Separate group, not aligned
+      class ConsecutiveLetAlignment < Base
+        extend AutoCorrector
+        include SpecFileHelper
+        include AlignmentHelpers
+
+        MSG = "Align consecutive `let` declarations at the `{` brace."
+
+        # @!method let_declaration?(node)
+        #   Check if node is a let/let! declaration.
+        def_node_matcher :let_declaration?, <<~PATTERN
+          (block (send nil? {:let :let!} (sym _)) ...)
+        PATTERN
+
+        # Check describe/context blocks for let alignment.
+        #
+        # @param [RuboCop::AST::Node] node The block node.
+        # @return [void]
+        def on_block(node)
+          return unless spec_file?
+          return unless describe_or_context?(node)
+          return unless node.body
+
+          check_lets_in_body(node.body)
+        end
+        alias on_numblock on_block
+
+        private
+
+        # Check if block is a describe or context block.
+        #
+        # @param [RuboCop::AST::Node] node The block node.
+        # @return [Boolean]
+        def describe_or_context?(node)
+          node.send_node && %i(describe context).include?(node.method_name)
+        end
+
+        # Check let declarations in a body node.
+        #
+        # @param [RuboCop::AST::Node] body The body node.
+        # @return [void]
+        def check_lets_in_body(body)
+          statements = extract_statements(body)
+
+          return if statements.size < 2
+
+          groups = group_consecutive_statements(statements) { |s| let_declaration?(s) }
+
+          groups.each { |group| check_group_alignment(group) }
+        end
+
+        # Check alignment for a group of let declarations.
+        #
+        # @param [Array<RuboCop::AST::Node>] group The let group.
+        # @return [void]
+        def check_group_alignment(group)
+          columns       = group.map { |let| let.loc.begin.column }
+          target_column = columns.max
+
+          group.each do |let|
+            current_column = let.loc.begin.column
+
+            next if current_column == target_column
+
+            add_offense(let.send_node) do |corrector|
+              autocorrect_alignment(corrector, let, target_column)
+            end
+          end
+        end
+
+        # Auto-correct the alignment of a let declaration.
+        #
+        # @param [RuboCop::AST::Corrector] corrector The corrector.
+        # @param [RuboCop::AST::Node] let The let block node.
+        # @param [Integer] target_column The target column for alignment.
+        # @return [void]
+        def autocorrect_alignment(corrector, let, target_column)
+          send_node    = let.send_node
+          send_end     = send_node.source_range.end_pos
+          brace_start  = let.loc.begin.begin_pos
+          total_spaces = calculate_total_spaces(let, target_column)
+
+          corrector.replace(
+            range_between(send_end, brace_start),
+            " " * total_spaces
+          )
+        end
+
+        # Calculate total spaces needed for alignment.
+        #
+        # @param [RuboCop::AST::Node] let The let block node.
+        # @param [Integer] target_column The target column for alignment.
+        # @return [Integer] The number of spaces (minimum 1).
+        def calculate_total_spaces(let, target_column)
+          current_column = let.loc.begin.column
+          current_spaces = let.loc.begin.begin_pos - let.send_node.source_range.end_pos
+          spaces_needed  = target_column - current_column
+
+          [1, current_spaces + spaces_needed].max
+        end
+      end
+    end
+  end
+end

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

@@ -59,7 +59,7 @@ module RuboCop
         # Default priority for descriptions that can't be categorized (e.g., constants, variables)
         DEFAULT_PRIORITY = 999
 
-        MODEL_ORDER = %w(class associations validations).freeze
+        MODEL_ORDER        = %w(class associations validations).freeze
         CONTROLLER_ACTIONS = %w(index show new create edit update destroy).freeze
         SPECIAL_SECTIONS = {
           "class"        => 0,
@@ -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