rubocop-vibe 0.1.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

@@ -9,30 +9,40 @@ module RuboCop
       # per-line basis. If a cop needs to be disabled, it should be configured
       # globally in `.rubocop.yml` with proper justification.
       #
-      # @example Bad - inline disable directive on a line
-      #   def method
-      #     do_something # rubocop_disable Style/SomeCop  (triggers offense)
-      #   end
+      # Specific cops can be allowed via the `AllowedCops` configuration option.
+      # If multiple cops are disabled in one comment, only the disallowed ones
+      # will be flagged.
       #
-      # @example Bad - block disable directive
-      #   # rubocop_disable Style/SomeCop  (triggers offense)
-      #   def method
-      #     do_something
-      #   end
-      #   # rubocop_enable Style/SomeCop
+      # @example Bad - inline disable directive
+      #   do_something # rubocop_disable Style/SomeCop
+      #
+      # @example Bad - disable without specifying a cop
+      #   # rubocop_disable all
+      #   do_something
       #
       # @example Good - fix the issue instead
-      #   def method
-      #     do_something_correctly
-      #   end
+      #   do_something_correctly
       #
       # @example Good - configure globally in .rubocop.yml
+      #   # In .rubocop.yml:
       #   # Style/SomeCop:
       #   #   Enabled: false
+      #
+      # @example AllowedCops: ['Rails/RakeEnvironment'] - allowed cop is not flagged
+      #   # rubocop_disable Rails/RakeEnvironment
+      #   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 use `# rubocop:disable`. Fix the issue or configure globally in `.rubocop.yml`."
+        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`."
 
-        DISABLE_PATTERN = /\A#\s*rubocop\s*:\s*disable\b/i
+        DISABLE_PATTERN  = /\A#\s*rubocop\s*:\s*disable\b/i
+        COP_NAME_PATTERN = %r{[A-Za-z]+/[A-Za-z0-9]+}
+        ALL_PATTERN      = /\brubocop\s*:\s*disable\s+all\b/i
 
         # Check for rubocop:disable comments.
         #
@@ -41,7 +51,7 @@ module RuboCop
           processed_source.comments.each do |comment|
             next unless disable_comment?(comment)
 
-            add_offense(comment)
+            check_disabled_cops(comment)
           end
         end
 
@@ -54,6 +64,46 @@ module RuboCop
         def disable_comment?(comment)
           DISABLE_PATTERN.match?(comment.text)
         end
+
+        # Check disabled cops and flag disallowed ones.
+        #
+        # @param [Parser::Source::Comment] comment The comment to check.
+        # @return [void]
+        def check_disabled_cops(comment)
+          cops = extract_cop_names(comment.text)
+
+          if cops.empty?
+            add_offense(comment, message: MSG_NO_COP)
+          else
+            disallowed = cops.reject { |cop| allowed_cop?(cop) }
+            return if disallowed.empty?
+
+            add_offense(comment, message: format(MSG, cops: disallowed.join(", ")))
+          end
+        end
+
+        # Extract cop names from a rubocop:disable comment.
+        #
+        # @param [String] text The comment text.
+        # @return [Array<String>]
+        def extract_cop_names(text)
+          text.scan(COP_NAME_PATTERN)
+        end
+
+        # Check if a cop is in the allowed list.
+        #
+        # @param [String] cop The cop name.
+        # @return [Boolean]
+        def allowed_cop?(cop)
+          allowed_cops.include?(cop)
+        end
+
+        # Get the list of allowed cops from configuration.
+        #
+        # @return [Array<String>]
+        def allowed_cops
+          @allowed_cops ||= Array(cop_config.fetch("AllowedCops", []))
+        end
       end
     end
   end

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

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Vibe
+      # Enforces using `if/end` blocks instead of inline modifiers for `raise` statements.
+      #
+      # Inline `raise ... if/unless` statements can be harder to read because they
+      # place the condition after the action. This cop enforces converting them
+      # to `if/end` blocks for better readability.
+      #
+      # @example
+      #   # bad - inline unless modifier
+      #   raise ArgumentError, "Invalid column" unless COLUMNS.include?(column)
+      #
+      #   # good - if block with negated condition
+      #   if !COLUMNS.include?(column)
+      #     raise ArgumentError, "Invalid column"
+      #   end
+      #
+      #   # bad - inline if modifier
+      #   raise ArgumentError, "Invalid column" if column.nil?
+      #
+      #   # good - if block
+      #   if column.nil?
+      #     raise ArgumentError, "Invalid column"
+      #   end
+      #
+      #   # good - raise without condition
+      #   raise ArgumentError, "Invalid column"
+      class RaiseUnlessBlock < Base
+        extend AutoCorrector
+
+        MSG = "Use `if/end` block instead of inline modifier for `raise`."
+
+        # Check if nodes for raise with if/unless modifier.
+        #
+        # @param [RuboCop::AST::Node] node The if node.
+        # @return [void]
+        def on_if(node)
+          return unless node.modifier_form?
+          return unless raise_call?(node.body)
+
+          add_offense(node) do |corrector|
+            autocorrect(corrector, node)
+          end
+        end
+
+        private
+
+        # Check if the node is a raise method call.
+        #
+        # @param [RuboCop::AST::Node] node The node to check.
+        # @return [Boolean]
+        def raise_call?(node)
+          node.send_type? && node.method?(:raise)
+        end
+
+        # Autocorrect the offense by converting to if block.
+        #
+        # @param [RuboCop::Cop::Corrector] corrector The corrector.
+        # @param [RuboCop::AST::Node] node The if node.
+        # @return [void]
+        def autocorrect(corrector, node)
+          replacement = build_replacement(node)
+
+          corrector.replace(node, replacement)
+        end
+
+        # Build the replacement code for the raise statement.
+        #
+        # @param [RuboCop::AST::Node] node The if node.
+        # @return [String] The replacement code.
+        def build_replacement(node)
+          condition    = build_condition(node)
+          raise_source = node.body.source
+          base_indent  = " " * node.loc.column
+          inner_indent = "#{base_indent}  "
+
+          [
+            "if #{condition}",
+            "#{inner_indent}#{raise_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?
+            "!#{node.condition.source}"
+          else
+            node.condition.source
+          end
+        end
+      end
+    end
+  end
+end