rubocop-vibe 0.1.0

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

@@ -0,0 +1,219 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Vibe
+      # Enforces alignment of consecutive variable assignments at the `=` operator.
+      #
+      # Consecutive assignments (with no blank lines between) should align their
+      # `=` operators for better readability. Groups are broken by blank lines.
+      #
+      # @example
+      #   # bad
+      #   user = create(:user)
+      #   character = create(:character)
+      #   input = "test"
+      #
+      #   # good
+      #   user      = create(:user)
+      #   character = create(:character)
+      #   input     = "test"
+      #
+      #   # good - blank line breaks the group
+      #   user      = create(:user)
+      #   character = create(:character)
+      #
+      #   service = Users::Activate.new  # Separate group, not aligned
+      class ConsecutiveAssignmentAlignment < Base
+        extend AutoCorrector
+
+        MSG = "Align consecutive assignments at the = operator."
+
+        # Check block nodes for assignment alignment.
+        #
+        # @param [RuboCop::AST::Node] node The block node.
+        # @return [void]
+        def on_block(node)
+          if node.body
+            check_assignments_in_body(node.body)
+          end
+        end
+        alias on_numblock on_block
+
+        # Check method definitions for assignment alignment.
+        #
+        # @param [RuboCop::AST::Node] node The def node.
+        # @return [void]
+        def on_def(node)
+          if node.body
+            check_assignments_in_body(node.body)
+          end
+        end
+        alias on_defs on_def
+
+        private
+
+        # Check assignments in a body node.
+        #
+        # @param [RuboCop::AST::Node] body The body node.
+        # @return [void]
+        def check_assignments_in_body(body)
+          statements = extract_statements(body)
+          return if statements.size < 2
+
+          groups = group_consecutive_assignments(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 assignments together.
+        #
+        # @param [Array<RuboCop::AST::Node>] statements The statements.
+        # @return [Array<Array<RuboCop::AST::Node>>] Groups of consecutive assignments.
+        def group_consecutive_assignments(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 local_variable_assignment?(statement)
+            current_group = handle_assignment(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 an assignment statement.
+        #
+        # @param [RuboCop::AST::Node] statement The assignment 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<RuboCop::AST::Node>] The updated current group.
+        def handle_assignment(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 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 if node is a local variable assignment.
+        #
+        # @param [RuboCop::AST::Node] node The node.
+        # @return [Boolean]
+        def local_variable_assignment?(node)
+          node.lvasgn_type?
+        end
+
+        # Check alignment for a group of assignments.
+        #
+        # @param [Array<RuboCop::AST::Node>] group The assignment group.
+        # @return [void]
+        def check_group_alignment(group)
+          columns       = group.map { |asgn| asgn.loc.operator.column }
+          target_column = columns.max
+
+          group.each do |asgn|
+            current_column = asgn.loc.operator.column
+            next if current_column == target_column
+
+            add_offense(asgn.loc.name) do |corrector|
+              autocorrect_alignment(corrector, asgn, target_column)
+            end
+          end
+        end
+
+        # Auto-correct the alignment of an assignment.
+        #
+        # @param [RuboCop::AST::Corrector] corrector The corrector.
+        # @param [RuboCop::AST::Node] asgn The assignment node.
+        # @param [Integer] target_column The target column for alignment.
+        # @return [void]
+        def autocorrect_alignment(corrector, asgn, target_column)
+          variable_name_end = asgn.loc.name.end_pos
+          operator_start    = asgn.loc.operator.begin_pos
+          total_spaces      = calculate_total_spaces(asgn, target_column)
+
+          corrector.replace(
+            range_between(variable_name_end, operator_start),
+            " " * total_spaces
+          )
+        end
+
+        # Calculate total spaces needed for alignment.
+        #
+        # @param [RuboCop::AST::Node] asgn The assignment node.
+        # @param [Integer] target_column The target column for alignment.
+        # @return [Integer] The number of spaces (minimum 1).
+        def calculate_total_spaces(asgn, target_column)
+          current_column = asgn.loc.operator.column
+          current_spaces = asgn.loc.operator.begin_pos - asgn.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/describe_block_order.rb

@@ -0,0 +1,262 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Vibe
+      # Enforces consistent ordering of describe blocks in RSpec files.
+      #
+      # Universal order: "class" → "constants" → ".class_method" → "#instance_method"
+      # Models add: "associations" and "validations" between "constants" and methods.
+      # Controllers add: RESTful actions between "constants" and methods.
+      #
+      # @example
+      #   # bad
+      #   describe User do
+      #     describe "#name" do
+      #     end
+      #
+      #     describe "class" do
+      #     end
+      #   end
+      #
+      #   # good (universal)
+      #   describe Service do
+      #     describe "class" do
+      #     end
+      #
+      #     describe ".call" do
+      #     end
+      #
+      #     describe "#process" do
+      #     end
+      #   end
+      #
+      #   # good (model with custom sections)
+      #   describe User do
+      #     describe "class" do
+      #     end
+      #
+      #     describe "associations" do
+      #     end
+      #
+      #     describe "validations" do
+      #     end
+      #
+      #     describe ".find_active" do
+      #     end
+      #
+      #     describe "#name" do
+      #     end
+      #   end
+      class DescribeBlockOrder < Base
+        extend AutoCorrector
+        include SpecFileHelper
+
+        MSG = "Describe blocks should be ordered: class → constants → .class_method → #instance_method."
+
+        # Priority for non-special, non-method descriptions (e.g., "callbacks", "scopes")
+        NON_SPECIAL_DESCRIPTION_PRIORITY = 300
+        # Default priority for descriptions that can't be categorized (e.g., constants, variables)
+        DEFAULT_PRIORITY = 999
+
+        MODEL_ORDER = %w(class associations validations).freeze
+        CONTROLLER_ACTIONS = %w(index show new create edit update destroy).freeze
+        SPECIAL_SECTIONS = {
+          "class"        => 0,
+          "constants"    => 5,
+          "associations" => 10,
+          "validations"  => 20
+        }.freeze
+
+        # @!method describe_block?(node)
+        #   Check if node is a describe block (matches both `describe` and `RSpec.describe`).
+        def_node_matcher :describe_block?, <<~PATTERN
+          (block (send _ :describe ...) ...)
+        PATTERN
+
+        # Check block nodes for describe calls.
+        #
+        # @param [RuboCop::AST::Node] node The block node.
+        # @return [void]
+        def on_block(node)
+          return unless spec_file?
+          return unless top_level_describe?(node)
+
+          describe_blocks = extract_describe_blocks(node)
+          return if describe_blocks.size < 2
+
+          violations = find_ordering_violations(describe_blocks)
+          violations.each do |block_info|
+            add_offense(block_info[:node]) do |corrector|
+              autocorrect(corrector, describe_blocks)
+            end
+          end
+        end
+        alias on_numblock on_block
+
+        private
+
+        # Check if this is a top-level describe block.
+        #
+        # @param [RuboCop::AST::Node] node The block node.
+        # @return [Boolean]
+        def top_level_describe?(node)
+          describe_block?(node) &&
+            node.each_ancestor(:block).none? { |ancestor| describe_block?(ancestor) }
+        end
+
+        # Extract second-level describe blocks.
+        #
+        # @param [RuboCop::AST::Node] top_node The top-level describe block.
+        # @return [Array<Hash>] Array of describe block info.
+        def extract_describe_blocks(top_node)
+          if top_node.body
+            block_nodes(top_node).map.with_index { |node, index| build_block_info(node, index) }
+          else
+            []
+          end
+        end
+
+        # Get block nodes from the top-level describe.
+        #
+        # @param [RuboCop::AST::Node] top_node The top-level describe block.
+        # @return [Array<RuboCop::AST::Node>]
+        def block_nodes(top_node)
+          children = top_node.body.begin_type? ? top_node.body.children : [top_node.body]
+
+          children.select { |child| child.block_type? && child.method?(:describe) }
+        end
+
+        # Build block information hash.
+        #
+        # @param [RuboCop::AST::Node] node The block node.
+        # @param [Integer] index The original index.
+        # @return [Hash] Block information.
+        def build_block_info(node, index)
+          description = extract_description(node)
+
+          {
+            node:           node,
+            original_index: index,
+            description:    description,
+            priority:       categorize_description(description)
+          }
+        end
+
+        # Extract description string from describe block.
+        #
+        # Only string and symbol literals are supported for ordering.
+        # Constants and variables return nil and will be assigned DEFAULT_PRIORITY.
+        #
+        # @param [RuboCop::AST::Node] node The describe block node.
+        # @return [String] The description string from a string or symbol literal.
+        # @return [nil] When description is not a string/symbol literal.
+        def extract_description(node)
+          first_arg = node.send_node.first_argument
+          return unless first_arg
+
+          if first_arg.str_type?
+            first_arg.value
+          elsif first_arg.sym_type?
+            first_arg.value.to_s
+            # Intentionally returns nil for constants/variables.
+            # These will get DEFAULT_PRIORITY.
+          end
+        end
+
+        # Categorize description and assign priority.
+        #
+        # Universal order: class (0) → constants (5) → .class_method (100) → #instance_method (200)
+        # Models insert: associations (10), validations (20) between class and methods.
+        # Controllers insert: RESTful actions (30-36) between class and methods.
+        # Non-special descriptions get NON_SPECIAL_DESCRIPTION_PRIORITY (300).
+        # nil descriptions get DEFAULT_PRIORITY (999).
+        #
+        # @param [String, nil] description The describe block description.
+        # @return [Integer] Priority number (lower = earlier).
+        def categorize_description(description)
+          if description
+            special_section_priority(description) ||
+              controller_action_priority(description) ||
+              method_priority(description) ||
+              NON_SPECIAL_DESCRIPTION_PRIORITY
+          else
+            DEFAULT_PRIORITY
+          end
+        end
+
+        # Get priority for special sections.
+        #
+        # @param [String] description The describe block description.
+        # @return [Integer]
+        # @return [nil] When not a special section.
+        def special_section_priority(description)
+          SPECIAL_SECTIONS[description]
+        end
+
+        # Get priority for controller actions.
+        #
+        # @param [String] description The describe block description.
+        # @return [Integer]
+        # @return [nil] When not a controller action.
+        def controller_action_priority(description)
+          # Strip the # prefix for controller actions.
+          action_name = description.start_with?("#") ? description[1..] : description
+          if controller_action?(action_name)
+            30 + CONTROLLER_ACTIONS.index(action_name)
+          end
+        end
+
+        # Get priority for method descriptions.
+        #
+        # @param [String] description The describe block description.
+        # @return [Integer]
+        # @return [nil] When not a method description.
+        def method_priority(description)
+          return 100 if description.start_with?(".")
+          return 200 if description.start_with?("#")
+
+          nil
+        end
+
+        # Check if description is a controller action.
+        #
+        # @param [String] description The describe block description.
+        # @return [Boolean]
+        def controller_action?(description)
+          CONTROLLER_ACTIONS.include?(description)
+        end
+
+        # Find describe blocks that are out of order.
+        #
+        # @param [Array<Hash>] blocks The list of describe blocks.
+        # @return [Array<Hash>] Blocks that violate ordering.
+        def find_ordering_violations(blocks)
+          violations = []
+
+          blocks.each_cons(2) do |current, following|
+            violations << following if current[:priority] > following[:priority]
+          end
+
+          violations.uniq
+        end
+
+        # Auto-correct by reordering describe blocks.
+        #
+        # @param [RuboCop::AST::Corrector] corrector The corrector.
+        # @param [Array<Hash>] blocks The list of describe blocks.
+        # @return [void]
+        def autocorrect(corrector, blocks)
+          sorted_blocks = blocks.sort_by { |b| [b[:priority], b[:original_index]] }
+
+          blocks.each_with_index do |block, index|
+            sorted_block = sorted_blocks[index]
+            next if block == sorted_block
+
+            corrector.replace(block[:node], sorted_block[:node].source)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Vibe
+      # Enforces that `is_expected` is only used in one-liner `it { }` blocks.
+      #
+      # @example
+      #   # bad
+      #   it "returns true" do
+      #     is_expected.to be(true)
+      #   end
+      #
+      #   # good
+      #   it { is_expected.to be(true) }
+      #
+      #   # good - expect with description is allowed
+      #   it "returns the user" do
+      #     expect(result).to eq(user)
+      #   end
+      class IsExpectedOneLiner < Base
+        extend AutoCorrector
+        include SpecFileHelper
+
+        MSG = "Use one-liner `it { is_expected.to ... }` syntax when using `is_expected`."
+
+        # @!method is_expected_call?(node)
+        #   Check if node is an is_expected call.
+        def_node_matcher :is_expected_call?, <<~PATTERN
+          (send nil? :is_expected)
+        PATTERN
+
+        # @!method example_block_with_description?(node)
+        #   Check if block is an example block with a description.
+        def_node_matcher :example_block_with_description?, <<~PATTERN
+          (block (send nil? {:it :specify} (str _) ...) ...)
+        PATTERN
+
+        # Check send nodes for is_expected calls inside described blocks.
+        #
+        # @param [RuboCop::AST::Node] node The send node.
+        # @return [void]
+        def on_send(node)
+          return unless spec_file?
+          return unless is_expected_call?(node)
+
+          example_block = find_example_block(node)
+          return unless example_block
+          return unless example_block_with_description?(example_block)
+          return if complex_expectation?(example_block)
+
+          add_offense(example_block.send_node) do |corrector|
+            autocorrect(corrector, example_block)
+          end
+        end
+        alias on_csend on_send
+
+        private
+
+        # Find the enclosing example block for a node.
+        #
+        # @param [RuboCop::AST::Node] node The node to search from.
+        # @return [RuboCop::AST::Node]
+        # @return [nil] When no example block is found.
+        def find_example_block(node)
+          node.each_ancestor(:block).find do |ancestor|
+            send_node = ancestor.send_node
+            send_node.method?(:it) || send_node.method?(:specify)
+          end
+        end
+
+        # Check if the expectation is too complex for one-liner conversion.
+        #
+        # @param [RuboCop::AST::Node] node The block node.
+        # @return [Boolean]
+        def complex_expectation?(node)
+          expectation_source = node.body.source
+
+          # Multi-line expectations are complex.
+          return true if expectation_source.include?("\n")
+
+          # Expectations with compound matchers (.and, .or) are complex.
+          compound_matcher?(node.body)
+        end
+
+        # Check if the expectation uses compound matchers.
+        #
+        # @param [RuboCop::AST::Node] node The expectation node.
+        # @return [Boolean]
+        def compound_matcher?(node)
+          node.each_descendant(:send).any? do |send_node|
+            send_node.method?(:and) || send_node.method?(:or)
+          end
+        end
+
+        # Autocorrect the offense by converting to one-liner syntax.
+        #
+        # @param [RuboCop::Cop::Corrector] corrector The corrector.
+        # @param [RuboCop::AST::Node] node The block node.
+        # @return [void]
+        def autocorrect(corrector, node)
+          expectation_source = node.body.source
+          corrector.replace(node, "it { #{expectation_source} }")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Vibe
+      module SpecFileHelper
+        SPEC_FILE_PATTERN = %r{spec/.*_spec\.rb}
+
+        private
+
+        # Check if file is a spec file.
+        #
+        # @return [Boolean]
+        def spec_file?
+          processed_source.file_path.match?(SPEC_FILE_PATTERN)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Vibe
+      # Enforces that controller specs only test assignment identity, not attributes or associations.
+      #
+      # Testing model attributes or associations from assigns is considered bad practice
+      # because it couples the controller spec to the model implementation.
+      # Controller specs should only verify that the correct object is assigned,
+      # not test the object's internal state or associations.
+      #
+      # @example
+      #   # bad
+      #   expect(assigns(:user).email).to eq('test@example.com')
+      #   expect(assigns(:user).posts.count).to eq(5)
+      #   expect(assigns(:post).author.name).to eq('John')
+      #
+      #   # good
+      #   expect(assigns(:user)).to eq(user)
+      #   expect(assigns(:post)).to eq(post)
+      #
+      class NoAssignsAttributeTesting < Base
+        include SpecFileHelper
+
+        MSG = "Do not test attributes or associations from assigns. " \
+              "Only test the assignment itself: `expect(assigns(:var)).to eq(object)`"
+
+        CONTROLLER_SPEC_PATTERN = %r{spec/controllers/.*_spec\.rb}
+
+        # Matches assigns(:variable).method_call patterns.
+        # @!method assigns_with_method?(node)
+        def_node_matcher :assigns_with_method?, <<~PATTERN
+          (send
+            (send nil? :assigns ...)
+            $_)
+        PATTERN
+
+        # Checks if assigns is being called with a method in controller specs.
+        #
+        # @param node [RuboCop::AST::SendNode] the node being checked.
+        # @return [void]
+        def on_send(node)
+          return unless controller_spec_file?
+          return unless assigns_with_method?(node)
+
+          add_offense(node.loc.selector)
+        end
+        alias on_csend on_send
+
+        private
+
+        # Checks if the current file is a controller spec.
+        #
+        # @return [Boolean] true if the file is a controller spec.
+        def controller_spec_file?
+          processed_source.file_path.match?(CONTROLLER_SPEC_PATTERN)
+        end
+      end
+    end
+  end
+end