rubocop-vibe 0.2.0 → 0.4.0

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

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

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Vibe
+      # Enforces alphabetical ordering of consecutive `let` declarations.
+      #
+      # Consecutive `let` declarations (with no blank lines between) should be
+      # alphabetically ordered by their symbol name for better readability and
+      # easier scanning. Groups are broken by blank lines or non-let statements.
+      #
+      # @example
+      #   # bad
+      #   let(:subcategory) { create(:category, :subcategory) }
+      #   let(:budget)      { subcategory.budget }
+      #   let(:category)    { subcategory.parent }
+      #
+      #   # good
+      #   let(:budget)      { subcategory.budget }
+      #   let(:category)    { subcategory.parent }
+      #   let(:subcategory) { create(:category, :subcategory) }
+      #
+      #   # good - blank line breaks the group
+      #   let(:zebra) { create(:zebra) }
+      #
+      #   let(:apple) { create(:apple) }
+      class LetOrder < Base
+        extend AutoCorrector
+        include SpecFileHelper
+        include AlignmentHelpers
+
+        MSG = "Order consecutive `let` declarations alphabetically."
+
+        # @!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 ordering.
+        #
+        # @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_order(group) }
+        end
+
+        # Check ordering for a group of let declarations.
+        #
+        # @param [Array<RuboCop::AST::Node>] group The let group.
+        # @return [void]
+        def check_group_order(group)
+          return if alphabetically_ordered?(group)
+
+          violations = find_ordering_violations(group)
+
+          violations.each do |let|
+            add_offense(let.send_node) do |corrector|
+              autocorrect(corrector, group)
+            end
+          end
+        end
+
+        # Check if let declarations are alphabetically ordered.
+        #
+        # @param [Array<RuboCop::AST::Node>] group The let group.
+        # @return [Boolean]
+        def alphabetically_ordered?(group)
+          names = group.map { |let| extract_let_name(let) }
+
+          names == names.sort
+        end
+
+        # Extract the symbol name from a let declaration.
+        #
+        # @param [RuboCop::AST::Node] let The let block node.
+        # @return [String]
+        def extract_let_name(let)
+          let.send_node.first_argument.value.to_s
+        end
+
+        # Find let declarations that violate ordering.
+        #
+        # @param [Array<RuboCop::AST::Node>] group The let group.
+        # @return [Array<RuboCop::AST::Node>] Lets that violate ordering.
+        def find_ordering_violations(group)
+          violations = []
+
+          group.each_cons(2) do |current, following|
+            current_name   = extract_let_name(current)
+            following_name = extract_let_name(following)
+
+            violations << following if current_name > following_name
+          end
+
+          violations.uniq
+        end
+
+        # Auto-correct by reordering let declarations.
+        #
+        # @param [RuboCop::AST::Corrector] corrector The corrector.
+        # @param [Array<RuboCop::AST::Node>] group The let group.
+        # @return [void]
+        def autocorrect(corrector, group)
+          sorted = group.sort_by { |let| extract_let_name(let) }
+
+          group.each_with_index do |let, index|
+            sorted_let = sorted[index]
+
+            next if let == sorted_let
+
+            corrector.replace(let, sorted_let.source)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Vibe
+      # Shared helper methods for consecutive alignment cops.
+      #
+      # Provides common functionality for grouping consecutive statements
+      # and creating source ranges for autocorrection.
+      module AlignmentHelpers
+        private
+
+        # 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 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.
+        # @return [Array<Array>] Array of [index, statement] pairs.
+        def find_matching_statements(statements)
+          statements.each_with_index.filter_map do |stmt, idx|
+            [idx, stmt] if yield(stmt)
+          end
+        end
+
+        # Group matched statements that are on consecutive lines.
+        #
+        # @param [Array<Array>] matches Array of [index, statement] pairs.
+        # @param [Array<RuboCop::AST::Node>] statements Original statements for line lookups.
+        # @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) }
+            .filter_map { |group| group.map(&:last) if group.size > 1 }
+        end
+
+        # 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
+
+        # Check if there's no blank line between two statements.
+        #
+        # @param [RuboCop::AST::Node] stmt_a First statement.
+        # @param [RuboCop::AST::Node] stmt_b Second statement.
+        # @return [Boolean]
+        def no_blank_line_between?(stmt_a, stmt_b)
+          stmt_b.loc.line - stmt_a.loc.last_line <= 1
+        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
+end

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

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Vibe
+      # Enforces that hash arguments in multiline method calls are on separate
+      # lines and alphabetically ordered by key name.
+      #
+      # This cop applies to method calls where the closing parenthesis is on
+      # its own line.
+      #
+      # Value alignment (table style) is handled separately by Layout/HashAlignment.
+      #
+      # @example
+      #   # bad - multiple hash pairs on same line
+      #   SomeService.call(
+      #     website_id: website.id, data: data
+      #   )
+      #
+      #   # bad - hash pairs not alphabetically ordered
+      #   SomeService.call(
+      #     website_id: website.id,
+      #     data: data
+      #   )
+      #
+      #   # good
+      #   SomeService.call(
+      #     data: data,
+      #     website_id: website.id
+      #   )
+      class MultilineHashArgumentStyle < Base
+        extend AutoCorrector
+
+        MSG = "Hash arguments in multiline calls should be one per line " \
+              "and alphabetically ordered."
+
+        # Check send nodes for hash arguments that need reformatting.
+        #
+        # @param [RuboCop::AST::Node] node The send node.
+        # @return [void]
+        def on_send(node)
+          return unless multiline_call_with_hash?(node)
+
+          hash_arg = find_hash_argument(node)
+
+          return unless hash_arg
+          return unless needs_correction?(hash_arg)
+
+          add_offense(hash_arg) do |corrector|
+            autocorrect(corrector, hash_arg)
+          end
+        end
+        alias on_csend on_send
+
+        private
+
+        # Check if this is a multiline call with closing paren on own line.
+        #
+        # @param [RuboCop::AST::Node] node The send node.
+        # @return [Boolean]
+        def multiline_call_with_hash?(node)
+          node.parenthesized? && closing_paren_on_own_line?(node)
+        end
+
+        # Check if closing paren is on its own line (after last argument).
+        #
+        # @param [RuboCop::AST::Node] node The send node.
+        # @return [Boolean]
+        def closing_paren_on_own_line?(node)
+          last_arg = node.last_argument
+
+          if last_arg
+            node.loc.end.line > last_arg.loc.last_line
+          else
+            false
+          end
+        end
+
+        # Find hash argument in the call (if any).
+        #
+        # @param [RuboCop::AST::Node] node The send node.
+        # @return [RuboCop::AST::Node, nil]
+        def find_hash_argument(node)
+          node.arguments.find(&:hash_type?)
+        end
+
+        # Check if hash needs correction (same line or unordered).
+        #
+        # @param [RuboCop::AST::Node] hash_arg The hash node.
+        # @return [Boolean]
+        def needs_correction?(hash_arg)
+          pairs = hash_arg.pairs
+
+          return false if pairs.size < 2
+
+          multiple_pairs_on_same_line?(pairs) || !pairs_alphabetically_ordered?(pairs)
+        end
+
+        # Check if multiple pairs are on the same line.
+        #
+        # @param [Array<RuboCop::AST::Node>] pairs The hash pairs.
+        # @return [Boolean]
+        def multiple_pairs_on_same_line?(pairs)
+          lines = pairs.map { |pair| pair.loc.line }
+
+          lines.size != lines.uniq.size
+        end
+
+        # Check if pairs are alphabetically ordered by key name.
+        #
+        # @param [Array<RuboCop::AST::Node>] pairs The hash pairs.
+        # @return [Boolean]
+        def pairs_alphabetically_ordered?(pairs)
+          key_names = pairs.map { |pair| extract_key_name(pair) }
+
+          key_names == key_names.sort
+        end
+
+        # Extract the key name as a string for sorting.
+        #
+        # @param [RuboCop::AST::Node] pair The hash pair node.
+        # @return [String]
+        def extract_key_name(pair)
+          key = pair.key
+
+          if key.type?(:sym, :str)
+            key.value.to_s
+          else
+            key.source
+          end
+        end
+
+        # Autocorrect by reordering and splitting pairs.
+        #
+        # @param [RuboCop::Cop::Corrector] corrector The corrector.
+        # @param [RuboCop::AST::Node] hash_arg The hash node.
+        # @return [void]
+        def autocorrect(corrector, hash_arg)
+          pairs       = hash_arg.pairs
+          sorted      = pairs.sort_by { |pair| extract_key_name(pair) }
+          indentation = calculate_indentation(pairs.first)
+          replacement = build_replacement(sorted, indentation)
+
+          corrector.replace(hash_arg, replacement)
+        end
+
+        # Calculate indentation for reformatted pairs.
+        #
+        # @param [RuboCop::AST::Node] first_pair The first pair node.
+        # @return [String]
+        def calculate_indentation(first_pair)
+          " " * first_pair.loc.column
+        end
+
+        # Build the replacement string with sorted pairs on separate lines.
+        #
+        # @param [Array<RuboCop::AST::Node>] sorted_pairs The sorted pairs.
+        # @param [String] indentation The indentation string.
+        # @return [String]
+        def build_replacement(sorted_pairs, indentation)
+          sorted_pairs.map.with_index do |pair, index|
+            prefix = index.zero? ? "" : indentation
+            suffix = index == sorted_pairs.size - 1 ? "" : ","
+
+            "#{prefix}#{pair.source}#{suffix}"
+          end.join("\n")
+        end
+      end
+    end
+  end
+end