rubocop-vibe 0.1.0

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Vibe
+      # Enforces that inline rubocop:disable directive comments are not used.
+      #
+      # This cop encourages fixing issues rather than disabling cops on a
+      # 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
+      #
+      # @example Bad - block disable directive
+      #   # rubocop_disable Style/SomeCop  (triggers offense)
+      #   def method
+      #     do_something
+      #   end
+      #   # rubocop_enable Style/SomeCop
+      #
+      # @example Good - fix the issue instead
+      #   def method
+      #     do_something_correctly
+      #   end
+      #
+      # @example Good - configure globally in .rubocop.yml
+      #   # Style/SomeCop:
+      #   #   Enabled: false
+      class NoRubocopDisable < Base
+        MSG = "Do not use `# rubocop:disable`. Fix the issue or configure globally in `.rubocop.yml`."
+
+        DISABLE_PATTERN = /\A#\s*rubocop\s*:\s*disable\b/i
+
+        # Check for rubocop:disable comments.
+        #
+        # @return [void]
+        def on_new_investigation
+          processed_source.comments.each do |comment|
+            next unless disable_comment?(comment)
+
+            add_offense(comment)
+          end
+        end
+
+        private
+
+        # Check if the comment is a rubocop:disable directive.
+        #
+        # @param [Parser::Source::Comment] comment The comment to check.
+        # @return [Boolean]
+        def disable_comment?(comment)
+          DISABLE_PATTERN.match?(comment.text)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Vibe
+      # Enforces that tests are not skipped or marked as pending.
+      #
+      # This cop encourages completing tests rather than leaving them
+      # skipped or pending. If a test cannot be implemented, it should
+      # be deleted rather than left as a placeholder.
+      #
+      # @example
+      #   # bad - skip call
+      #   it "does something" do
+      #     skip "not implemented yet"
+      #   end
+      #
+      #   # bad - pending call
+      #   it "does something" do
+      #     pending "waiting on feature"
+      #   end
+      #
+      #   # bad - xit (skipped it)
+      #   xit "does something" do
+      #     expect(true).to be true
+      #   end
+      #
+      #   # bad - xdescribe/xcontext
+      #   xdescribe "MyClass" do
+      #     it "works" do
+      #     end
+      #   end
+      #
+      #   # good - implement the test
+      #   it "does something" do
+      #     expect(result).to eq(expected)
+      #   end
+      class NoSkippedTests < Base
+        include SpecFileHelper
+
+        MSG_SKIP    = "Do not skip tests. Implement or delete the test."
+        MSG_PENDING = "Do not mark tests as pending. Implement or delete the test."
+        MSG_XMETHOD = "Do not use `%<method>s`. Implement or delete the test."
+
+        SKIP_METHODS    = %i(skip).freeze
+        PENDING_METHODS = %i(pending).freeze
+        X_METHODS       = %i(xit xspecify xexample xscenario xdescribe xcontext xfeature).freeze
+
+        # @!method skip_call?(node)
+        #   Check if node is a skip call.
+        def_node_matcher :skip_call?, <<~PATTERN
+          (send nil? {:skip} ...)
+        PATTERN
+
+        # @!method pending_call?(node)
+        #   Check if node is a pending call.
+        def_node_matcher :pending_call?, <<~PATTERN
+          (send nil? {:pending} ...)
+        PATTERN
+
+        # @!method x_method_call?(node)
+        #   Check if node is an x-prefixed test method.
+        def_node_matcher :x_method_call?, <<~PATTERN
+          (send nil? ${:xit :xspecify :xexample :xscenario :xdescribe :xcontext :xfeature} ...)
+        PATTERN
+
+        # Check for skip calls in spec files.
+        #
+        # @param [RuboCop::AST::Node] node The send node.
+        # @return [void]
+        def on_send(node)
+          if spec_file?
+            check_skip(node)
+            check_pending(node)
+            check_x_method(node)
+          end
+        end
+        alias on_csend on_send
+
+        private
+
+        # Check for skip method calls.
+        #
+        # @param [RuboCop::AST::Node] node The send node.
+        # @return [void]
+        def check_skip(node)
+          if skip_call?(node)
+            add_offense(node, message: MSG_SKIP)
+          end
+        end
+
+        # Check for pending method calls.
+        #
+        # @param [RuboCop::AST::Node] node The send node.
+        # @return [void]
+        def check_pending(node)
+          if pending_call?(node)
+            add_offense(node, message: MSG_PENDING)
+          end
+        end
+
+        # Check for x-prefixed test method calls.
+        #
+        # @param [RuboCop::AST::Node] node The send node.
+        # @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
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,250 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Vibe
+      # Enforces using positive `if` conditions instead of `unless` for guard clauses.
+      #
+      # Guard clauses with `unless` can be harder to read because they introduce
+      # double negatives. This cop enforces converting guard clauses from negative
+      # `unless` conditions to positive `if` conditions with the logic in a block.
+      #
+      # @example
+      #   # bad - unless guard clause with implicit nil return
+      #   def unless_example
+      #     return unless valid?
+      #
+      #     4
+      #   end
+      #
+      #   # good - positive if condition
+      #   def unless_example_valid
+      #     if valid?
+      #       4
+      #     end
+      #   end
+      #
+      #   # bad - unless guard clause with explicit return value
+      #   def unless_example
+      #     return 32 unless valid?
+      #
+      #     4
+      #   end
+      #
+      #   # good - positive if/else condition
+      #   def unless_example_valid
+      #     if valid?
+      #       4
+      #     else
+      #       32
+      #     end
+      #   end
+      #
+      #   # good - regular if guard clauses are allowed
+      #   def if_example
+      #     return if valid?
+      #
+      #     4
+      #   end
+      class NoUnlessGuardClause < Base
+        extend AutoCorrector
+
+        MSG = "Use positive `if` condition instead of `unless` for guard clauses."
+
+        # @!method unless_modifier?(node)
+        #   Check if node is a statement with an unless modifier.
+        def_node_matcher :unless_modifier?, <<~PATTERN
+          (if $_ $_ nil?)
+        PATTERN
+
+        # Check if nodes for unless guard clauses.
+        #
+        # @param [RuboCop::AST::Node] node The if node.
+        # @return [void]
+        def on_if(node)
+          return unless node.unless? && node.modifier_form? && guard_clause?(node)
+          return if part_of_guard_clause_sequence?(node)
+          return if would_create_nested_conditional?(node)
+
+          add_offense(node) do |corrector|
+            autocorrect(corrector, node)
+          end
+        end
+
+        private
+
+        # Check if the unless statement is a guard clause (early return).
+        #
+        # @param [RuboCop::AST::Node] node The if node.
+        # @return [Boolean]
+        def guard_clause?(node)
+          if node.body.return_type?
+            parent = node.parent
+            if parent.begin_type?
+              following_statements?(parent, node)
+            else
+              false
+            end
+          else
+            false
+          end
+        end
+
+        # Check if there are statements after the node in the parent block.
+        #
+        # @param [RuboCop::AST::Node] parent The parent begin block.
+        # @param [RuboCop::AST::Node] node The current node.
+        # @return [Boolean]
+        def following_statements?(parent, node)
+          siblings   = parent.children
+          node_index = siblings.index(node)
+          siblings[(node_index + 1)..].any?
+        end
+
+        # Check if this unless guard clause is part of a sequence of guard clauses.
+        # When there are multiple guard clauses together, they should stay at the same level.
+        #
+        # @param [RuboCop::AST::Node] node The if node.
+        # @return [Boolean]
+        def part_of_guard_clause_sequence?(node)
+          siblings   = node.parent.children
+          node_index = siblings.index(node)
+
+          # Check for other guard clauses before this one.
+          preceding_guards = siblings[0...node_index].any? { |sibling| any_guard_clause?(sibling) }
+
+          # Check for other guard clauses after this one.
+          following_guards = siblings[(node_index + 1)..].any? { |sibling| any_guard_clause?(sibling) }
+
+          preceding_guards || following_guards
+        end
+
+        # Check if a node is any type of guard clause (if or unless).
+        #
+        # @param [RuboCop::AST::Node] node The node to check.
+        # @return [Boolean]
+        def any_guard_clause?(node)
+          node.if_type? && node.modifier_form? && node.body.return_type?
+        end
+
+        # Check if transforming this guard clause would create nested conditionals.
+        # If the remaining code is a conditional, we'd nest it inside our new if block.
+        #
+        # Note: This is only called after guard_clause? returns true, which means
+        # there are statements after this node, so remaining will never be empty.
+        #
+        # @param [RuboCop::AST::Node] node The if node.
+        # @return [Boolean]
+        def would_create_nested_conditional?(node)
+          siblings        = node.parent.children
+          node_index      = siblings.index(node)
+          first_statement = siblings[node_index + 1]
+
+          first_statement.type?(:if, :case)
+        end
+
+        # Autocorrect the offense by converting to positive if condition.
+        #
+        # @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)
+          range       = replacement_range(node)
+          corrector.replace(range, replacement)
+        end
+
+        # Build the replacement code for the guard clause.
+        #
+        # @param [RuboCop::AST::Node] node The if node.
+        # @return [String] The replacement code.
+        def build_replacement(node)
+          condition      = node.condition.source
+          return_value   = extract_return_value(node.body)
+          base_indent    = " " * node.loc.column
+          inner_indent   = "#{base_indent}  "
+          remaining_code = get_remaining_code(node)
+
+          if return_value
+            build_if_else_replacement(condition, remaining_code, return_value, base_indent, inner_indent)
+          else
+            build_if_replacement(condition, remaining_code, base_indent, inner_indent)
+          end
+        end
+
+        # Build if/else replacement code.
+        #
+        # @param condition [String] The condition expression.
+        # @param remaining_code [String] The remaining code to execute.
+        # @param return_value [String] The return value for the else branch.
+        # @param base_indent [String] The base indentation level.
+        # @param inner_indent [String] The inner indentation level.
+        # @return [String]
+        def build_if_else_replacement(condition, remaining_code, return_value, base_indent, inner_indent)
+          [
+            "if #{condition}",
+            indent_lines(remaining_code, inner_indent),
+            "#{base_indent}else",
+            indent_lines(return_value, inner_indent),
+            "#{base_indent}end"
+          ].join("\n")
+        end
+
+        # Build if replacement code.
+        #
+        # @param condition [String] The condition expression.
+        # @param remaining_code [String] The remaining code to execute.
+        # @param base_indent [String] The base indentation level.
+        # @param inner_indent [String] The inner indentation level.
+        # @return [String]
+        def build_if_replacement(condition, remaining_code, base_indent, inner_indent)
+          [
+            "if #{condition}",
+            indent_lines(remaining_code, inner_indent),
+            "#{base_indent}end"
+          ].join("\n")
+        end
+
+        # Get the code remaining after the guard clause.
+        #
+        # @param [RuboCop::AST::Node] node The if node.
+        # @return [String] The remaining code.
+        def get_remaining_code(node)
+          siblings   = node.parent.children
+          node_index = siblings.index(node)
+          siblings[(node_index + 1)..].map(&:source).join("\n")
+        end
+
+        # Get the replacement range.
+        #
+        # @param [RuboCop::AST::Node] node The if node.
+        # @return [Parser::Source::Range] The range to replace.
+        def replacement_range(node)
+          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
+
+        # Extract the return value from a return node.
+        #
+        # @param [RuboCop::AST::Node] node The return node.
+        # @return [String, nil] The return value source or nil if no value.
+        def extract_return_value(node)
+          if node.children.any?
+            node.children.first.source
+          end
+        end
+
+        # Indent each line of code with the specified indentation.
+        #
+        # @param [String] code The code to indent.
+        # @param [String] indentation The indentation string.
+        # @return [String] The indented code.
+        def indent_lines(code, indentation)
+          code.lines.map { |line| "#{indentation}#{line}" }.join.chomp
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Vibe
+      # Enforces one-liner syntax for simple RSpec expectations with subject.
+      #
+      # @example
+      #   # bad
+      #   it "responds with ok" do
+      #     expect(subject).to respond_with(:ok)
+      #   end
+      #
+      #   # good
+      #   it { is_expected.to respond_with(:ok) }
+      #
+      #   # good - descriptions allowed for non-subject expectations
+      #   it "inherits from base class" do
+      #     expect(described_class.superclass).to eq(BaseClass)
+      #   end
+      #
+      #   # good - multi-line allowed for change expectations
+      #   it "creates a record" do
+      #     expect { subject }.to change(Resource, :count).by(1)
+      #   end
+      #
+      #   # good - multi-line allowed for setup
+      #   it "processes the record" do
+      #     record.process
+      #
+      #     expect(record).to be_processed
+      #   end
+      class PreferOneLinerExpectation < Base
+        extend AutoCorrector
+        include SpecFileHelper
+
+        MSG = "Use one-liner `it { is_expected.to }` syntax for simple expectations."
+
+        # @!method example_block_with_description?(node)
+        #   Check if block is an example block (it, specify) with a description.
+        def_node_matcher :example_block_with_description?, <<~PATTERN
+          (block (send nil? {:it :specify} _ ...) ...)
+        PATTERN
+
+        # @!method expectation_method?(node)
+        #   Check if node is an expect or is_expected call.
+        def_node_matcher :expectation_method?, <<~PATTERN
+          (send nil? {:expect :is_expected} ...)
+        PATTERN
+
+        # Check block nodes for multi-line it blocks with simple expectations.
+        #
+        # @param [RuboCop::AST::Node] node The block node.
+        # @return [void]
+        def on_block(node)
+          return unless processable_block?(node)
+          return unless single_statement?(node.body)
+
+          expectation = extract_expectation(node.body)
+          return unless simple_expectation?(expectation)
+          return if complex_expectation?(node)
+
+          add_offense(node.send_node) do |corrector|
+            autocorrect(corrector, node)
+          end
+        end
+        alias on_numblock on_block
+
+        private
+
+        # 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
+
+        # Check if the block should be processed.
+        #
+        # @param [RuboCop::AST::Node] node The block node.
+        # @return [Boolean]
+        def processable_block?(node)
+          spec_file? && example_block_with_description?(node)
+        end
+
+        # Check if the body contains only a single statement.
+        #
+        # @param [RuboCop::AST::Node] body The block body.
+        # @return [Boolean]
+        def single_statement?(body)
+          if body
+            !body.begin_type?
+          else
+            false
+          end
+        end
+
+        # Extract the expectation node from the body.
+        #
+        # @param [RuboCop::AST::Node] body The block body.
+        # @return [RuboCop::AST::Node]
+        # @return [nil] When no expectation is found.
+        def extract_expectation(body)
+          if body.send_type?
+            find_expectation_in_chain(body)
+          end
+        end
+
+        # Find expectation node in method chain.
+        #
+        # @param [RuboCop::AST::Node] node The node to search.
+        # @return [RuboCop::AST::Node]
+        # @return [nil] When no expectation is found.
+        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)
+
+            current = current.receiver
+          end
+
+          nil
+        end
+
+        # Check if the expectation is simple (not a block expectation).
+        #
+        # Simple expectations use expect(subject).
+        # Block expectations use expect { ... } and are not simple.
+        # is_expected is handled by IsExpectedOneLiner cop.
+        # expect with non-subject receivers should keep descriptions.
+        #
+        # @param [RuboCop::AST::Node] node The expectation node.
+        # @return [Boolean] True if simple expectation with subject, false otherwise.
+        def simple_expectation?(node)
+          return false unless node
+          return false unless node.method?(:expect) && !node.block_node
+
+          # Only enforce one-liners for expect(subject).
+          # Other receivers (user.email, described_class, etc.) should keep descriptions.
+          expect_subject?(node)
+        end
+
+        # Check if the expectation is using subject as the receiver.
+        #
+        # @param [RuboCop::AST::Node] node The expect node.
+        # @return [Boolean]
+        def expect_subject?(node)
+          argument = node.first_argument
+          return false unless argument
+          return false unless argument.send_type?
+
+          argument.method?(:subject)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Vibe
+      # Enforces that service objects define both `self.call` and `call` methods.
+      #
+      # Service objects should provide a consistent public interface through
+      # a `self.call` class method that delegates to an instance `call` method.
+      #
+      # @example
+      #   # bad - missing both methods
+      #   class MyService
+      #     def perform
+      #       # ...
+      #     end
+      #   end
+      #
+      #   # bad - missing instance call
+      #   class MyService
+      #     def self.call(arg)
+      #       # ...
+      #     end
+      #   end
+      #
+      #   # bad - missing self.call
+      #   class MyService
+      #     def call
+      #       # ...
+      #     end
+      #   end
+      #
+      #   # good
+      #   class MyService
+      #     def self.call(arg)
+      #       new(arg).call
+      #     end
+      #
+      #     def call
+      #       # implementation
+      #     end
+      #   end
+      class ServiceCallMethod < Base
+        MSG = "Service objects should define `self.call` and `call` methods."
+
+        SERVICE_FILE_PATTERN = %r{app/services/.*\.rb\z}
+
+        # @!method class_call_method?(node)
+        #   Check if node is a self.call class method definition.
+        def_node_search :class_call_method?, <<~PATTERN
+          (defs _ :call ...)
+        PATTERN
+
+        # @!method instance_call_method?(node)
+        #   Check if node is a call instance method definition.
+        def_node_search :instance_call_method?, <<~PATTERN
+          (def :call ...)
+        PATTERN
+
+        # Check class definitions for missing call methods.
+        #
+        # @param [RuboCop::AST::Node] node The class node.
+        # @return [void]
+        def on_class(node)
+          return unless service_file?
+          return if class_call_method?(node) && instance_call_method?(node)
+
+          add_offense(node.loc.name)
+        end
+
+        private
+
+        # Check if current file is a service file.
+        #
+        # @return [Boolean]
+        def service_file?
+          processed_source.file_path.match?(SERVICE_FILE_PATTERN)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/vibe_cops.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+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/describe_block_order"
+require_relative "vibe/is_expected_one_liner"
+require_relative "vibe/no_assigns_attribute_testing"
+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/service_call_method"