rubocop-vibe 0.2.0 → 0.3.0

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

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

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Vibe
+      # Enforces extracting compound boolean conditions into named methods.
+      #
+      # When a conditional has multiple boolean expressions joined by `&&` or
+      # `||`, the intent becomes unclear. Extracting to a descriptively-named
+      # method documents the business logic.
+      #
+      # This cop does NOT flag compound conditions that are:
+      # - The implied return value of a method (the extraction target)
+      #
+      # This cop DOES flag compound conditions that are:
+      # - In if/unless/while/until/when/ternary conditions
+      # - Inside an explicit return statement
+      #
+      # @example
+      #   # bad - multiple conditions obscure intent
+      #   if user.active? && user.verified?
+      #     grant_access
+      #   end
+      #
+      #   # bad - mixing operators
+      #   return if admin? || moderator?
+      #
+      #   # bad - negation wrapping compound
+      #   if !(order.paid? && order.shipped?)
+      #     send_reminder
+      #   end
+      #
+      #   # bad - explicit return with compound
+      #   def can_participate?
+      #     return admin? || moderator? if override?
+      #     check_other_conditions
+      #   end
+      #
+      #   # good - extracted to named method
+      #   if user.can_participate?
+      #     grant_access
+      #   end
+      #
+      #   # good - compound as implied method return value (this is the extraction)
+      #   def can_participate?
+      #     user.active? && user.verified?
+      #   end
+      class NoCompoundConditions < Base
+        MSG = "Extract compound conditions into a named method."
+
+        # Check and/or nodes for conditional context.
+        #
+        # @param [RuboCop::AST::Node] node The and/or node.
+        # @return [void]
+        def on_and(node)
+          check_compound(node)
+        end
+        alias on_or on_and
+
+        private
+
+        # Check if a compound condition should be flagged.
+        #
+        # @param [RuboCop::AST::Node] node The and/or node.
+        # @return [void]
+        def check_compound(node)
+          if inside_return_statement?(node) || in_conditional_position?(node)
+            add_offense(node)
+          end
+        end
+
+        # Check if node is in a conditional position (if/unless/while/until/when condition).
+        #
+        # @param [RuboCop::AST::Node] node The and/or node.
+        # @return [Boolean]
+        def in_conditional_position?(node)
+          ancestor = conditional_ancestor(node)
+
+          if ancestor
+            condition_of_ancestor?(node, ancestor)
+          else
+            false
+          end
+        end
+
+        # Find the nearest conditional ancestor (if/while/until/when).
+        #
+        # @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) }
+        end
+
+        # Check if node is (part of) the condition of the ancestor.
+        #
+        # @param [RuboCop::AST::Node] node The and/or node.
+        # @param [RuboCop::AST::Node] ancestor The if/while/until/when ancestor.
+        # @return [Boolean]
+        def condition_of_ancestor?(node, ancestor)
+          condition = condition_node(ancestor)
+
+          node_within_condition?(node, condition)
+        end
+
+        # Extract the condition node from a conditional ancestor.
+        #
+        # @param [RuboCop::AST::Node] ancestor The conditional ancestor.
+        # @return [RuboCop::AST::Node]
+        def condition_node(ancestor)
+          if ancestor.type?(:if, :while, :until)
+            ancestor.condition
+          else
+            ancestor
+          end
+        end
+
+        # Check if node is within the condition subtree.
+        #
+        # @param [RuboCop::AST::Node] node The node to find.
+        # @param [RuboCop::AST::Node] condition The condition root.
+        # @return [Boolean]
+        def node_within_condition?(node, condition)
+          return true if condition == node
+
+          condition.each_descendant.any?(node)
+        end
+
+        # Check if node is inside a return statement.
+        #
+        # @param [RuboCop::AST::Node] node The node.
+        # @return [Boolean]
+        def inside_return_statement?(node)
+          node.each_ancestor.any?(&:return_type?)
+        end
+      end
+    end
+  end
+end

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

@@ -33,6 +33,9 @@ module RuboCop
       #   task :my_task do
       #     # ...
       #   end
+      #
+      # NOTE: Examples use underscore (rubocop_disable) to prevent RuboCop from
+      # parsing them as actual directives. In real code, use colon (rubocop:disable).
       class NoRubocopDisable < Base
         MSG        = "Do not disable `%<cops>s`. Fix the issue or configure globally in `.rubocop.yml`."
         MSG_NO_COP = "Do not use `# rubocop:disable`. Fix the issue or configure globally in `.rubocop.yml`."

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

@@ -105,6 +105,7 @@ module RuboCop
         # @return [void]
         def check_x_method(node)
           method_name = x_method_call?(node)
+
           if method_name
             add_offense(node, message: format(MSG_XMETHOD, method: method_name))
           end

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

@@ -98,6 +98,7 @@ module RuboCop
         def following_statements?(parent, node)
           siblings   = parent.children
           node_index = siblings.index(node)
+
           siblings[(node_index + 1)..].any?
         end
 
@@ -151,6 +152,7 @@ module RuboCop
         def autocorrect(corrector, node)
           replacement = build_replacement(node)
           range       = replacement_range(node)
+
           corrector.replace(range, replacement)
         end
 
@@ -212,6 +214,7 @@ module RuboCop
         def get_remaining_code(node)
           siblings   = node.parent.children
           node_index = siblings.index(node)
+
           siblings[(node_index + 1)..].map(&:source).join("\n")
         end
 
@@ -223,6 +226,7 @@ module RuboCop
           siblings  = node.parent.children
           start_pos = node.source_range.begin_pos
           end_pos   = siblings.last.source_range.end_pos
+
           Parser::Source::Range.new(node.source_range.source_buffer, start_pos, end_pos)
         end
 

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

@@ -57,6 +57,7 @@ module RuboCop
           return unless single_statement?(node.body)
 
           expectation = extract_expectation(node.body)
+
           return unless simple_expectation?(expectation)
           return if complex_expectation?(node)
 
@@ -99,6 +100,7 @@ module RuboCop
         # @return [void]
         def autocorrect(corrector, node)
           expectation_source = node.body.source
+
           corrector.replace(node, "it { #{expectation_source} }")
         end
 
@@ -141,6 +143,7 @@ module RuboCop
         def find_expectation_in_chain(node)
           # Traverse up the chain looking for expect or is_expected.
           current = node
+
           while current&.send_type?
             return current if expectation_method?(current)
 
@@ -174,6 +177,7 @@ module RuboCop
         # @return [Boolean]
         def expect_subject?(node)
           argument = node.first_argument
+
           return false unless argument
           return false unless argument.send_type?
 

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

@@ -63,6 +63,7 @@ module RuboCop
         # @return [void]
         def autocorrect(corrector, node)
           replacement = build_replacement(node)
+
           corrector.replace(node, replacement)
         end
 

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

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Vibe
+      # Enforces using `do...end` syntax instead of braces for RSpec `before` blocks.
+      #
+      # @example
+      #   # bad
+      #   before { setup_data }
+      #
+      #   # bad
+      #   before(:each) { setup_data }
+      #
+      #   # good
+      #   before do
+      #     setup_data
+      #   end
+      #
+      #   # good
+      #   before(:each) do
+      #     setup_data
+      #   end
+      class RspecBeforeBlockStyle < Base
+        extend AutoCorrector
+        include SpecFileHelper
+
+        MSG = "Use `do...end` block syntax instead of braces for `%<method>s` blocks."
+
+        HOOK_METHODS = %i(before after around).freeze
+
+        # Check block nodes for brace-style hooks.
+        #
+        # @param [RuboCop::AST::Node] node The block node.
+        # @return [void]
+        def on_block(node)
+          return unless spec_file?
+          return unless hook_block?(node)
+          return unless node.braces?
+
+          method_name = node.method_name
+
+          add_offense(node.loc.begin, message: format(MSG, method: method_name)) do |corrector|
+            autocorrect(corrector, node)
+          end
+        end
+        alias on_numblock on_block
+
+        private
+
+        # Check if the block is a hook block (before, after, around).
+        #
+        # @param [RuboCop::AST::Node] node The block node.
+        # @return [Boolean]
+        def hook_block?(node)
+          send_node = node.send_node
+
+          send_node.receiver.nil? && HOOK_METHODS.include?(send_node.method_name)
+        end
+
+        # Autocorrect the offense by converting braces to do...end.
+        #
+        # @param [RuboCop::Cop::Corrector] corrector The corrector.
+        # @param [RuboCop::AST::Node] node The block node.
+        # @return [void]
+        def autocorrect(corrector, node)
+          base_indent = " " * node.loc.column
+          replacement = build_replacement(node, base_indent)
+
+          corrector.replace(block_range(node), replacement)
+        end
+
+        # Build the replacement string for the block.
+        #
+        # @param [RuboCop::AST::Node] node The block node.
+        # @param [String] base_indent The base indentation.
+        # @return [String]
+        def build_replacement(node, base_indent)
+          parts = ["do"]
+
+          if node.arguments.source_range
+            parts << " #{node.arguments.source}"
+          end
+
+          if node.body
+            body_source = format_body(node.body, "#{base_indent}  ")
+            parts << "\n#{body_source}"
+          end
+
+          parts << "\n#{base_indent}end"
+
+          parts.join
+        end
+
+        # Get the range from the opening brace to the closing brace.
+        #
+        # @param [RuboCop::AST::Node] node The block node.
+        # @return [Parser::Source::Range]
+        def block_range(node)
+          node.loc.begin.join(node.loc.end)
+        end
+
+        # Format the body with proper indentation.
+        #
+        # @param [RuboCop::AST::Node] body The body node.
+        # @param [String] indent The indentation string.
+        # @return [String]
+        def format_body(body, indent)
+          body.source.lines.map { |line| "#{indent}#{line.strip}" }.join("\n")
+        end
+      end
+    end
+  end
+end

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

@@ -85,11 +85,13 @@ module RuboCop
         def check_receive_chain(to_node, receive_chain)
           chain         = extract_chain(receive_chain)
           receive_index = find_receive_index(chain)
+
           return unless receive_index
           return unless chain_has_with?(chain)
           return unless line_exceeds_max_length?(to_node)
 
           methods = chain[(receive_index + 1)..]
+
           check_methods_alignment(to_node, chain[receive_index], methods)
         end
 
@@ -170,6 +172,7 @@ module RuboCop
         # @return [Boolean]
         def should_flag?(previous_node, method_node, is_first)
           reference_line = is_first ? previous_node.loc.last_line : previous_node.loc.selector.line
+
           reference_line == method_node.loc.selector.line
         end
 
@@ -223,6 +226,7 @@ module RuboCop
         # @return [String]
         def calculate_indentation(node)
           base_column = find_chain_start_column(node)
+
           " " * (base_column + 2)
         end
 

data/lib/rubocop/cop/vibe_cops.rb

@@ -1,19 +1,26 @@
 # frozen_string_literal: true
 
+require_relative "vibe/mixin/alignment_helpers"
 require_relative "vibe/mixin/spec_file_helper"
 
+require_relative "vibe/blank_line_after_assignment"
 require_relative "vibe/blank_line_before_expectation"
 require_relative "vibe/class_organization"
 require_relative "vibe/consecutive_assignment_alignment"
 require_relative "vibe/consecutive_constant_alignment"
+require_relative "vibe/consecutive_indexed_assignment_alignment"
 require_relative "vibe/consecutive_let_alignment"
 require_relative "vibe/describe_block_order"
+require_relative "vibe/explicit_return_conditional"
 require_relative "vibe/is_expected_one_liner"
+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_skipped_tests"
 require_relative "vibe/no_unless_guard_clause"
 require_relative "vibe/prefer_one_liner_expectation"
 require_relative "vibe/raise_unless_block"
+require_relative "vibe/rspec_before_block_style"
 require_relative "vibe/rspec_stub_chain_style"
 require_relative "vibe/service_call_method"

data/lib/rubocop/vibe/plugin.rb

@@ -10,10 +10,10 @@ module RuboCop
       # @return [LintRoller::About] Information about the plug-in.
       def about
         LintRoller::About.new(
-          name:        "rubocop-vibe",
-          version:     VERSION,
+          description: "A set of custom cops to use on AI generated code.",
           homepage:    "https://github.com/tristandunn/rubocop-vibe",
-          description: "A set of custom cops to use on AI generated code."
+          name:        "rubocop-vibe",
+          version:     VERSION
         )
       end
 
@@ -23,8 +23,8 @@ module RuboCop
       # @return [LintRoller::Rules] The rules for this plug-in.
       def rules(_context)
         LintRoller::Rules.new(
-          type:          :path,
           config_format: :rubocop,
+          type:          :path,
           value:         Pathname.new(__dir__).join("../../../config/default.yml")
         )
       end