rubocop-vibe 0.1.0

checksums.yaml

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

data/config/default.yml

@@ -0,0 +1,126 @@
+plugins:
+  - rubocop-performance
+  - rubocop-rake
+  - rubocop-rspec
+
+AllCops:
+  Exclude:
+    - "tmp/**/*"
+    - "vendor/**/*"
+  NewCops: enable
+  TargetRubyVersion: 4.0
+
+Layout/HashAlignment:
+  EnforcedColonStyle: table
+  EnforcedHashRocketStyle: table
+
+Naming/RescuedExceptionsVariableName:
+  Enabled: true
+  PreferredName: error
+
+Naming/VariableNumber:
+  EnforcedStyle: snake_case
+
+Style/ArgumentsForwarding:
+  UseAnonymousForwarding: false
+
+Style/Documentation:
+  Enabled: false
+
+Style/DocumentationMethod:
+  Enabled: true
+  Exclude:
+    - "db/**/*"
+    - "spec/**/*"
+  RequireForNonPublicMethods: true
+
+Style/ExpandPathArguments:
+  Enabled: true
+  Exclude:
+    - bin/*
+
+Style/GuardClause:
+  Enabled: false
+
+Style/HashSyntax:
+  Enabled: false
+
+Style/IfUnlessModifier:
+  Enabled: false
+
+Style/PercentLiteralDelimiters:
+  PreferredDelimiters:
+    "%i": "()"
+    "%w": "()"
+
+Style/RaiseArgs:
+  EnforcedStyle: compact
+
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  EnforcedStyle: double_quotes
+
+Vibe/BlankLineBeforeExpectation:
+  Description: "Enforces a blank line before expectation calls when there is setup code above."
+  Enabled: true
+  SafeAutoCorrect: true
+  VersionAdded: "0.1.0"
+
+Vibe/ConsecutiveAssignmentAlignment:
+  Description: "Enforces alignment of consecutive variable assignments at the = operator."
+  Enabled: true
+  SafeAutoCorrect: true
+  VersionAdded: "0.1.0"
+
+Vibe/DescribeBlockOrder:
+  Description: "Enforces consistent ordering of describe blocks in RSpec files."
+  Enabled: true
+  SafeAutoCorrect: false
+  VersionAdded: "0.1.0"
+
+Vibe/IsExpectedOneLiner:
+  Description: "Enforces that is_expected is only used in one-liner it { } blocks."
+  Enabled: true
+  SafeAutoCorrect: true
+  VersionAdded: "0.1.0"
+
+Vibe/ClassOrganization:
+  Description: "Enforces consistent organization of class definitions."
+  Enabled: true
+  SafeAutoCorrect: false
+  VersionAdded: "0.1.0"
+
+Vibe/NoAssignsAttributeTesting:
+  Description: "Enforces that controller specs only test assignment identity, not attributes or associations."
+  Enabled: true
+  SafeAutoCorrect: false
+  VersionAdded: "0.1.0"
+
+Vibe/NoRubocopDisable:
+  Description: "Enforces that rubocop:disable comments are not used inline."
+  Enabled: true
+  VersionAdded: "0.1.0"
+
+Vibe/NoSkippedTests:
+  Description: "Enforces that tests are not skipped or marked as pending."
+  Enabled: true
+  VersionAdded: "0.1.0"
+
+Vibe/NoUnlessGuardClause:
+  Description: "Enforces using positive if conditions instead of unless for guard clauses."
+  Enabled: true
+  SafeAutoCorrect: true
+  VersionAdded: "0.1.0"
+
+Vibe/PreferOneLinerExpectation:
+  Description: "Enforces one-liner syntax for simple RSpec expectations."
+  Enabled: true
+  SafeAutoCorrect: true
+  VersionAdded: "0.1.0"
+
+Vibe/ServiceCallMethod:
+  Description: "Service objects should define `self.call` and `call` methods."
+  Enabled: true
+  VersionAdded: "0.1.0"

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

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Vibe
+      # Enforces a blank line before expectation calls when there's setup code above.
+      #
+      # @example
+      #   # bad
+      #   it "processes the record" do
+      #     record.process
+      #     expect(record).to be_processed
+      #   end
+      #
+      #   # good
+      #   it "processes the record" do
+      #     record.process
+      #
+      #     expect(record).to be_processed
+      #   end
+      #
+      #   # good - no setup code above
+      #   it "is valid" do
+      #     expect(record).to be_valid
+      #   end
+      class BlankLineBeforeExpectation < Base
+        extend AutoCorrector
+        include SpecFileHelper
+
+        MSG = "Add a blank line before expectation when there is setup code above."
+
+        # @!method example_block?(node)
+        #   Check if block is an example block (it, specify, scenario).
+        def_node_matcher :example_block?, <<~PATTERN
+          (block (send nil? {:it :specify :scenario} ...) ...)
+        PATTERN
+
+        # @!method expect_call?(node)
+        #   Check if node is an expect call.
+        def_node_matcher :expect_call?, <<~PATTERN
+          (send nil? :expect ...)
+        PATTERN
+
+        # Check block nodes for expect calls in example blocks.
+        #
+        # @param [RuboCop::AST::Node] node The block node.
+        # @return [void]
+        def on_block(node)
+          if processable_block?(node)
+            check_statements(extract_statements(node.body))
+          end
+        end
+        alias on_numblock on_block
+
+        private
+
+        # 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?(node) && node.body
+        end
+
+        # Extract statements from the block body.
+        #
+        # @param [RuboCop::AST::Node] body The block body.
+        # @return [Array<RuboCop::AST::Node>]
+        def extract_statements(body)
+          body.begin_type? ? body.children : [body]
+        end
+
+        # Check statements for missing blank lines before expectations.
+        #
+        # @param [Array<RuboCop::AST::Node>] statements The statements to check.
+        # @return [void]
+        def check_statements(statements)
+          statements.each_with_index do |statement, index|
+            next if index.zero?
+
+            check_statement_pair(statements[index - 1], statement)
+          end
+        end
+
+        # Check a pair of statements for missing blank line.
+        #
+        # @param [RuboCop::AST::Node] previous_statement The previous statement.
+        # @param [RuboCop::AST::Node] current_statement The current statement.
+        # @return [void]
+        def check_statement_pair(previous_statement, current_statement)
+          expect_node = find_expect_node(current_statement)
+          return unless expect_node
+          return if blank_line_between?(previous_statement, current_statement)
+          return if find_expect_node(previous_statement)
+
+          register_offense(expect_node, previous_statement)
+        end
+
+        # Register an offense for missing blank line.
+        #
+        # @param [RuboCop::AST::Node] expect_node The expect node.
+        # @param [RuboCop::AST::Node] previous_statement The previous statement.
+        # @return [void]
+        def register_offense(expect_node, previous_statement)
+          add_offense(expect_node.loc.selector) do |corrector|
+            corrector.insert_after(previous_statement, "\n")
+          end
+        end
+
+        # Find the expect node within a statement.
+        #
+        # Searches the node and its descendants for expect calls.
+        # Only searches within the statement's method chain, not into
+        # nested blocks like those passed to other methods.
+        #
+        # @param [RuboCop::AST::Node] node The statement node.
+        # @return [RuboCop::AST::Node] The expect node if found.
+        # @return [nil] When no expect call is found.
+        def find_expect_node(node)
+          return unless node.send_type?
+
+          # Check if this node itself is an expect call.
+          return node if expect_call?(node)
+
+          # Search descendants for expect calls.
+          # This includes expect { ... } which has a block attached.
+          node.each_descendant(:send).find { |send_node| expect_call?(send_node) }
+        end
+
+        # Check if there's a blank line between two statements.
+        #
+        # @param [RuboCop::AST::Node] previous_node The previous statement.
+        # @param [RuboCop::AST::Node] current_node The current statement.
+        # @return [Boolean]
+        def blank_line_between?(previous_node, current_node)
+          current_node.loc.line - previous_node.loc.last_line > 1
+        end
+      end
+    end
+  end
+end