rubocop-vibe 0.1.0 → 0.3.0

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

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

@@ -1,15 +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

data/lib/rubocop/vibe/version.rb

@@ -2,6 +2,6 @@
 
 module RuboCop
   module Vibe
-    VERSION = "0.1.0"
+    VERSION = "0.3.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.3.0
 platform: ruby
 authors:
 - Tristan Dunn
@@ -87,17 +87,28 @@ extra_rdoc_files: []
 files:
 - config/default.yml
 - lib/rubocop-vibe.rb
+- lib/rubocop/cop/vibe/blank_line_after_assignment.rb
 - 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_indexed_assignment_alignment.rb
+- lib/rubocop/cop/vibe/consecutive_let_alignment.rb
 - lib/rubocop/cop/vibe/describe_block_order.rb
+- lib/rubocop/cop/vibe/explicit_return_conditional.rb
 - lib/rubocop/cop/vibe/is_expected_one_liner.rb
+- lib/rubocop/cop/vibe/mixin/alignment_helpers.rb
 - lib/rubocop/cop/vibe/mixin/spec_file_helper.rb
+- lib/rubocop/cop/vibe/multiline_hash_argument_style.rb
 - lib/rubocop/cop/vibe/no_assigns_attribute_testing.rb
+- lib/rubocop/cop/vibe/no_compound_conditions.rb
 - lib/rubocop/cop/vibe/no_rubocop_disable.rb
 - 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_before_block_style.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
@@ -125,7 +136,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.3
+rubygems_version: 4.0.4
 specification_version: 4
 summary: A set of custom cops to use on AI generated code.
 test_files: []