rubocop-vibe 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 66c4596677b86001b40036ed73d0ce8300b9010cc3ea16af13436cc7a1ab3cfd
-  data.tar.gz: b27f79a610368b858a565c70c90fcf7db80e0b258e7efc3ce17942ccfdef79cc
+  metadata.gz: e91f63c7c86e77f854c0dd424a1d40d1fd5ad8f0407836dc74467d59e786e6ab
+  data.tar.gz: d4cdc851197a8a1fcbbdebe14551c369029469f6c2e6c4a09b50060fb40b39f8
 SHA512:
-  metadata.gz: 57f43f61aba7ac210141f1d3aafff845f9b9a356ab88a42174de2344035825377bfc3ed1603d37e4b9662208f013a027be6be28cf2da40a514acb44f517469a6
-  data.tar.gz: fbe66437855c42030400323044fa53d3526e017fea1db8962d342aa9df7484072746a31c86791d7448c7f100b465ce72430318117d11967dfbb19fde09ee3d46
+  metadata.gz: eaebb568a44bd514577f6e3dc63a3b4a05d6c78762b5520462a0ba55119549bece813953d35cd2956fb03830a703d7a90e23d6b9c25204a3f41ee40281d87852
+  data.tar.gz: 0d66492bf54277b78dfa228bfdd7ef3cb2ba46f715ef32dc5304371d6af7ab9eff2e7c1a1ff3ca0fcd1ca4abd82ae8d01e41be9154fdb66a15b1546c504fb2cc

data/config/default.yml

@@ -74,6 +74,18 @@ Vibe/ConsecutiveAssignmentAlignment:
   SafeAutoCorrect: true
   VersionAdded: "0.1.0"
 
+Vibe/ConsecutiveConstantAlignment:
+  Description: "Enforces alignment of consecutive constant assignments at the = operator."
+  Enabled: true
+  SafeAutoCorrect: true
+  VersionAdded: "0.2.0"
+
+Vibe/ConsecutiveLetAlignment:
+  Description: "Enforces alignment of consecutive let declarations at the { brace."
+  Enabled: true
+  SafeAutoCorrect: true
+  VersionAdded: "0.2.0"
+
 Vibe/DescribeBlockOrder:
   Description: "Enforces consistent ordering of describe blocks in RSpec files."
   Enabled: true
@@ -101,6 +113,7 @@ Vibe/NoAssignsAttributeTesting:
 Vibe/NoRubocopDisable:
   Description: "Enforces that rubocop:disable comments are not used inline."
   Enabled: true
+  AllowedCops: []
   VersionAdded: "0.1.0"
 
 Vibe/NoSkippedTests:
@@ -120,6 +133,18 @@ Vibe/PreferOneLinerExpectation:
   SafeAutoCorrect: true
   VersionAdded: "0.1.0"
 
+Vibe/RaiseUnlessBlock:
+  Description: "Enforces using if/end blocks instead of inline modifiers for raise statements."
+  Enabled: true
+  SafeAutoCorrect: true
+  VersionAdded: "0.2.0"
+
+Vibe/RspecStubChainStyle:
+  Description: "Enforces that RSpec stub chains are split across lines when too long."
+  Enabled: true
+  SafeAutoCorrect: true
+  VersionAdded: "0.2.0"
+
 Vibe/ServiceCallMethod:
   Description: "Service objects should define `self.call` and `call` methods."
   Enabled: true

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

@@ -0,0 +1,229 @@
+# 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
+
+        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_constants(statements)
+          groups.each { |group| check_group_alignment(group) }
+        end
+
+        # Extract statements from a body node.
+        #
+        # @param [RuboCop::AST::Node] body The body node.
+        # @return [Array<RuboCop::AST::Node>]
+        def extract_statements(body)
+          if body.begin_type?
+            body.children
+          else
+            [body]
+          end
+        end
+
+        # Group consecutive constant assignments together.
+        #
+        # @param [Array<RuboCop::AST::Node>] statements The statements.
+        # @return [Array<Array<RuboCop::AST::Node>>] Groups of consecutive constants.
+        def group_consecutive_constants(statements)
+          groups        = []
+          current_group = []
+          previous_line = nil
+
+          statements.each do |statement|
+            current_group, previous_line = process_statement(statement, current_group, previous_line, groups)
+          end
+
+          finalize_groups(groups, current_group)
+        end
+
+        # Process a single statement for grouping.
+        #
+        # @param [RuboCop::AST::Node] statement The statement.
+        # @param [Array<RuboCop::AST::Node>] current_group The current group.
+        # @param [Integer, nil] previous_line The previous line number.
+        # @param [Array<Array<RuboCop::AST::Node>>] groups The groups.
+        # @return [Array] The updated current_group and previous_line.
+        def process_statement(statement, current_group, previous_line, groups)
+          if constant_assignment?(statement)
+            current_group = handle_constant(statement, current_group, previous_line, groups)
+          else
+            save_group_if_valid(groups, current_group)
+            current_group = []
+          end
+          [current_group, statement.loc.last_line]
+        end
+
+        # Check if node is a single-line constant assignment.
+        #
+        # Only single-line constants are considered for alignment to avoid
+        # conflicts with multi-line hash/array constants and Layout/ExtraSpacing.
+        #
+        # @param [RuboCop::AST::Node] node The node.
+        # @return [Boolean]
+        def constant_assignment?(node)
+          node.casgn_type? && single_line?(node)
+        end
+
+        # Check if node is on a single line.
+        #
+        # @param [RuboCop::AST::Node] node The node.
+        # @return [Boolean]
+        def single_line?(node)
+          node.single_line?
+        end
+
+        # Handle a constant assignment.
+        #
+        # @param [RuboCop::AST::Node] statement The constant assignment.
+        # @param [Array<RuboCop::AST::Node>] current_group The current group.
+        # @param [Integer, nil] previous_line The previous line number.
+        # @param [Array<Array<RuboCop::AST::Node>>] groups The groups.
+        # @return [Array<RuboCop::AST::Node>] The updated current group.
+        def handle_constant(statement, current_group, previous_line, groups)
+          if previous_line && statement.loc.line - previous_line > 1
+            save_group_if_valid(groups, current_group)
+            current_group = []
+          end
+          current_group << statement
+          current_group
+        end
+
+        # Save group if it has multiple constant assignments.
+        #
+        # @param [Array<Array<RuboCop::AST::Node>>] groups The groups.
+        # @param [Array<RuboCop::AST::Node>] group The group to potentially save.
+        # @return [void]
+        def save_group_if_valid(groups, group)
+          groups << group if group.size > 1
+        end
+
+        # Finalize groups by adding any remaining valid group.
+        #
+        # @param [Array<Array<RuboCop::AST::Node>>] groups The groups.
+        # @param [Array<RuboCop::AST::Node>] current_group The current group.
+        # @return [Array<Array<RuboCop::AST::Node>>] The finalized groups.
+        def finalize_groups(groups, current_group)
+          save_group_if_valid(groups, current_group)
+          groups
+        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
+
+        # 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/consecutive_let_alignment.rb

@@ -0,0 +1,219 @@
+# 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
+
+        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_lets(statements)
+          groups.each { |group| check_group_alignment(group) }
+        end
+
+        # Extract statements from a body node.
+        #
+        # @param [RuboCop::AST::Node] body The body node.
+        # @return [Array<RuboCop::AST::Node>]
+        def extract_statements(body)
+          if body.begin_type?
+            body.children
+          else
+            [body]
+          end
+        end
+
+        # Group consecutive let declarations together.
+        #
+        # @param [Array<RuboCop::AST::Node>] statements The statements.
+        # @return [Array<Array<RuboCop::AST::Node>>] Groups of consecutive lets.
+        def group_consecutive_lets(statements)
+          groups        = []
+          current_group = []
+          previous_line = nil
+
+          statements.each do |statement|
+            current_group, previous_line = process_statement(statement, current_group, previous_line, groups)
+          end
+
+          finalize_groups(groups, current_group)
+        end
+
+        # Process a single statement for grouping.
+        #
+        # @param [RuboCop::AST::Node] statement The statement.
+        # @param [Array<RuboCop::AST::Node>] current_group The current group.
+        # @param [Integer, nil] previous_line The previous line number.
+        # @param [Array<Array<RuboCop::AST::Node>>] groups The groups.
+        # @return [Array] The updated current_group and previous_line.
+        def process_statement(statement, current_group, previous_line, groups)
+          if let_declaration?(statement)
+            current_group = handle_let(statement, current_group, previous_line, groups)
+          else
+            save_group_if_valid(groups, current_group)
+            current_group = []
+          end
+          [current_group, statement.loc.last_line]
+        end
+
+        # Handle a let declaration.
+        #
+        # @param [RuboCop::AST::Node] statement The let declaration.
+        # @param [Array<RuboCop::AST::Node>] current_group The current group.
+        # @param [Integer, nil] previous_line The previous line number.
+        # @param [Array<Array<RuboCop::AST::Node>>] groups The groups.
+        # @return [Array<RuboCop::AST::Node>] The updated current group.
+        def handle_let(statement, current_group, previous_line, groups)
+          if previous_line && statement.loc.line - previous_line > 1
+            save_group_if_valid(groups, current_group)
+            current_group = []
+          end
+          current_group << statement
+          current_group
+        end
+
+        # Save group if it has multiple let declarations.
+        #
+        # @param [Array<Array<RuboCop::AST::Node>>] groups The groups.
+        # @param [Array<RuboCop::AST::Node>] group The group to potentially save.
+        # @return [void]
+        def save_group_if_valid(groups, group)
+          groups << group if group.size > 1
+        end
+
+        # Finalize groups by adding any remaining valid group.
+        #
+        # @param [Array<Array<RuboCop::AST::Node>>] groups The groups.
+        # @param [Array<RuboCop::AST::Node>] current_group The current group.
+        # @return [Array<Array<RuboCop::AST::Node>>] The finalized groups.
+        def finalize_groups(groups, current_group)
+          save_group_if_valid(groups, current_group)
+          groups
+        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
+
+        # 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/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,

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

@@ -9,30 +9,37 @@ 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
       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 +48,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 +61,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/raise_unless_block.rb

@@ -0,0 +1,101 @@
+# 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

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

@@ -0,0 +1,256 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Vibe
+      # Enforces that RSpec stub chains with `.with` or `.and_return` put each
+      # chained method on its own line when the line exceeds the max line length.
+      #
+      # This improves readability by keeping each part of the stub configuration
+      # on its own line rather than creating long horizontal lines.
+      #
+      # The max line length is read from the `Layout/LineLength` cop configuration.
+      #
+      # @example
+      #   # bad (when line exceeds max length)
+      #   allow(Foo).to receive(:bar).with(very_long_argument_name).and_return(result)
+      #
+      #   # good (split when line is too long)
+      #   allow(Foo).to receive(:bar)
+      #     .with(very_long_argument_name)
+      #     .and_return(result)
+      #
+      #   # good - short stubs can stay on one line
+      #   allow(Foo).to receive(:bar).with(arg).and_return(result)
+      #
+      #   # good - simple stubs without .with or .and_return are fine on one line
+      #   allow(Foo).to receive(:bar)
+      #
+      #   # good - .and_return directly after receive is allowed
+      #   allow(Foo).to receive(:bar).and_return(result)
+      class RspecStubChainStyle < Base
+        extend AutoCorrector
+        include SpecFileHelper
+
+        MSG = "Put each chained stub method on its own line when line is too long."
+
+        CHAIN_METHODS = %i(
+          with
+          and_return
+          and_raise
+          and_throw
+          and_yield
+          and_call_original
+          and_wrap_original
+          once
+          twice
+          thrice
+          exactly
+          at_least
+          at_most
+          ordered
+        ).freeze
+
+        RECEIVE_METHODS = %i(receive receive_message_chain receive_messages have_received).freeze
+
+        # @!method allow_to_receive?(node)
+        #   Check if node is an allow/expect.to call with a receive chain argument.
+        def_node_matcher :allow_to_receive?, <<~PATTERN
+          (send
+            (send nil? {:allow :expect :allow_any_instance_of :expect_any_instance_of} ...)
+            :to
+            $send)
+        PATTERN
+
+        # Check send nodes for stub chains that need line breaks.
+        #
+        # @param [RuboCop::AST::Node] node The send node.
+        # @return [void]
+        def on_send(node)
+          if spec_file?
+            allow_to_receive?(node) do |receive_chain|
+              check_receive_chain(node, receive_chain)
+            end
+          end
+        end
+        alias on_csend on_send
+
+        private
+
+        # Check the receive chain for methods that should be on separate lines.
+        #
+        # @param [RuboCop::AST::Node] to_node The .to node.
+        # @param [RuboCop::AST::Node] receive_chain The receive chain argument.
+        # @return [void]
+        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
+
+        # Check if the line containing the node exceeds the max line length.
+        #
+        # @param [RuboCop::AST::Node] node The node to check.
+        # @return [Boolean]
+        def line_exceeds_max_length?(node)
+          line_number = node.loc.line
+          line        = processed_source.lines[line_number - 1]
+
+          line.length > max_line_length
+        end
+
+        # Get the configured max line length from Layout/LineLength.
+        #
+        # @return [Integer]
+        def max_line_length
+          config.for_cop("Layout/LineLength")["Max"] || 120
+        end
+
+        # Extract the method chain from a node.
+        #
+        # @param [RuboCop::AST::Node] node The send node.
+        # @return [Array<RuboCop::AST::Node>]
+        def extract_chain(node)
+          chain   = []
+          current = node
+
+          while current&.send_type?
+            chain.unshift(current)
+            current = current.receiver
+          end
+
+          chain
+        end
+
+        # Find the index of the receive method in the chain.
+        #
+        # @param [Array<RuboCop::AST::Node>] chain The method chain.
+        # @return [Integer, nil]
+        def find_receive_index(chain)
+          chain.index { |n| RECEIVE_METHODS.include?(n.method_name) }
+        end
+
+        # Check if the chain includes a .with call.
+        #
+        # @param [Array<RuboCop::AST::Node>] chain The method chain.
+        # @return [Boolean]
+        def chain_has_with?(chain)
+          chain.any? { |n| n.method?(:with) }
+        end
+
+        # Check alignment of methods after receive.
+        #
+        # @param [RuboCop::AST::Node] to_node The .to node.
+        # @param [RuboCop::AST::Node] receive_node The receive node.
+        # @param [Array<RuboCop::AST::Node>] methods The methods to check.
+        # @return [void]
+        def check_methods_alignment(to_node, receive_node, methods)
+          previous_node = receive_node
+          is_first      = true
+
+          methods.each do |method_node|
+            if should_flag?(previous_node, method_node, is_first) && chainable_method?(method_node)
+              register_offense(method_node, to_node)
+            end
+            previous_node = method_node
+            is_first      = false
+          end
+        end
+
+        # Check if the method should be flagged.
+        #
+        # @param [RuboCop::AST::Node] previous_node The previous node.
+        # @param [RuboCop::AST::Node] method_node The method node.
+        # @param [Boolean] is_first Whether this is the first method after receive.
+        # @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
+
+        # Check if the method is one we care about for chaining.
+        #
+        # @param [RuboCop::AST::Node] node The method node.
+        # @return [Boolean]
+        def chainable_method?(node)
+          CHAIN_METHODS.include?(node.method_name)
+        end
+
+        # Register an offense for a method that should be on its own line.
+        #
+        # @param [RuboCop::AST::Node] method_node The method node.
+        # @param [RuboCop::AST::Node] previous_node The previous node in chain.
+        # @return [void]
+        def register_offense(method_node, previous_node)
+          add_offense(method_node.loc.selector) do |corrector|
+            autocorrect_chain(corrector, method_node, previous_node)
+          end
+        end
+
+        # Auto-correct by inserting a newline before the method.
+        #
+        # @param [RuboCop::Cop::Corrector] corrector The corrector.
+        # @param [RuboCop::AST::Node] method_node The method to move.
+        # @param [RuboCop::AST::Node] to_node The .to node for indentation.
+        # @return [void]
+        def autocorrect_chain(corrector, method_node, to_node)
+          dot_range         = method_node.loc.dot
+          indentation       = calculate_indentation(to_node)
+          replacement_start = find_replacement_start(method_node)
+
+          corrector.replace(
+            range_between(replacement_start, dot_range.begin_pos),
+            "\n#{indentation}"
+          )
+        end
+
+        # Find the starting position for the replacement.
+        #
+        # @param [RuboCop::AST::Node] method_node The method node.
+        # @return [Integer]
+        def find_replacement_start(method_node)
+          method_node.receiver.source_range.end_pos
+        end
+
+        # Calculate the indentation for the new line.
+        #
+        # @param [RuboCop::AST::Node] node The node to base indentation on.
+        # @return [String]
+        def calculate_indentation(node)
+          base_column = find_chain_start_column(node)
+          " " * (base_column + 2)
+        end
+
+        # Find the starting column of the chain.
+        #
+        # @param [RuboCop::AST::Node] node A node in the chain.
+        # @return [Integer]
+        def find_chain_start_column(node)
+          current = node
+
+          current = current.receiver while current.receiver&.send_type?
+
+          current.loc.column
+        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_cops.rb

@@ -5,6 +5,8 @@ require_relative "vibe/mixin/spec_file_helper"
 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_let_alignment"
 require_relative "vibe/describe_block_order"
 require_relative "vibe/is_expected_one_liner"
 require_relative "vibe/no_assigns_attribute_testing"
@@ -12,4 +14,6 @@ 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_stub_chain_style"
 require_relative "vibe/service_call_method"

data/lib/rubocop/vibe/version.rb

@@ -2,6 +2,6 @@
 
 module RuboCop
   module Vibe
-    VERSION = "0.1.0"
+    VERSION = "0.2.0"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-vibe
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Tristan Dunn
@@ -90,6 +90,8 @@ files:
 - lib/rubocop/cop/vibe/blank_line_before_expectation.rb
 - lib/rubocop/cop/vibe/class_organization.rb
 - lib/rubocop/cop/vibe/consecutive_assignment_alignment.rb
+- lib/rubocop/cop/vibe/consecutive_constant_alignment.rb
+- lib/rubocop/cop/vibe/consecutive_let_alignment.rb
 - lib/rubocop/cop/vibe/describe_block_order.rb
 - lib/rubocop/cop/vibe/is_expected_one_liner.rb
 - lib/rubocop/cop/vibe/mixin/spec_file_helper.rb
@@ -98,6 +100,8 @@ files:
 - lib/rubocop/cop/vibe/no_skipped_tests.rb
 - lib/rubocop/cop/vibe/no_unless_guard_clause.rb
 - lib/rubocop/cop/vibe/prefer_one_liner_expectation.rb
+- lib/rubocop/cop/vibe/raise_unless_block.rb
+- lib/rubocop/cop/vibe/rspec_stub_chain_style.rb
 - lib/rubocop/cop/vibe/service_call_method.rb
 - lib/rubocop/cop/vibe_cops.rb
 - lib/rubocop/vibe.rb