rubocop-vibe 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e91f63c7c86e77f854c0dd424a1d40d1fd5ad8f0407836dc74467d59e786e6ab
-  data.tar.gz: d4cdc851197a8a1fcbbdebe14551c369029469f6c2e6c4a09b50060fb40b39f8
+  metadata.gz: e14c979862da1db7feb6dc28697248359d9320450a1bbfca24db50101d9f4c43
+  data.tar.gz: e13a6d3fe34d9a24edc775dba8800e901a2a5a59ca5b3f35f516838e4ca79853
 SHA512:
-  metadata.gz: eaebb568a44bd514577f6e3dc63a3b4a05d6c78762b5520462a0ba55119549bece813953d35cd2956fb03830a703d7a90e23d6b9c25204a3f41ee40281d87852
-  data.tar.gz: 0d66492bf54277b78dfa228bfdd7ef3cb2ba46f715ef32dc5304371d6af7ab9eff2e7c1a1ff3ca0fcd1ca4abd82ae8d01e41be9154fdb66a15b1546c504fb2cc
+  metadata.gz: 1d89ddcdf3d94bb0aeca2ce767157e305a75990b540f2bd91d1e9255e26e29915da0eb7b3188d293a96b0d4bf2ce4ac25c700f4601238705e82f7c62dbdaaeac
+  data.tar.gz: 064b6dfe86613f8af93718a277db85d6bd705d7580fa27fe69469c41579aa0e4653c14dd4bcc48b56dd1d808c752921b2f69336816fe0ef3fcbb1098dd0d22f2

data/config/default.yml

@@ -62,12 +62,24 @@ Style/StringLiterals:
 Style/StringLiteralsInInterpolation:
   EnforcedStyle: double_quotes
 
+Vibe/BlankLineAfterAssignment:
+  Description: "Enforces a blank line after variable assignments when followed by other code."
+  Enabled: true
+  SafeAutoCorrect: true
+  VersionAdded: "0.3.0"
+
 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/ClassOrganization:
+  Description: "Enforces consistent organization of class definitions."
+  Enabled: true
+  SafeAutoCorrect: false
+  VersionAdded: "0.1.0"
+
 Vibe/ConsecutiveAssignmentAlignment:
   Description: "Enforces alignment of consecutive variable assignments at the = operator."
   Enabled: true
@@ -80,6 +92,12 @@ Vibe/ConsecutiveConstantAlignment:
   SafeAutoCorrect: true
   VersionAdded: "0.2.0"
 
+Vibe/ConsecutiveIndexedAssignmentAlignment:
+  Description: "Enforces alignment of consecutive indexed assignments at the = operator."
+  Enabled: true
+  SafeAutoCorrect: true
+  VersionAdded: "0.3.0"
+
 Vibe/ConsecutiveLetAlignment:
   Description: "Enforces alignment of consecutive let declarations at the { brace."
   Enabled: true
@@ -92,17 +110,23 @@ Vibe/DescribeBlockOrder:
   SafeAutoCorrect: false
   VersionAdded: "0.1.0"
 
+Vibe/ExplicitReturnConditional:
+  Description: "Enforces explicit if/else/end blocks instead of ternary or trailing conditionals for return values."
+  Enabled: true
+  SafeAutoCorrect: true
+  VersionAdded: "0.3.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."
+Vibe/MultilineHashArgumentStyle:
+  Description: "Enforces one-per-line and alphabetical ordering for hash arguments in multiline method calls."
   Enabled: true
-  SafeAutoCorrect: false
-  VersionAdded: "0.1.0"
+  SafeAutoCorrect: true
+  VersionAdded: "0.3.0"
 
 Vibe/NoAssignsAttributeTesting:
   Description: "Enforces that controller specs only test assignment identity, not attributes or associations."
@@ -110,6 +134,11 @@ Vibe/NoAssignsAttributeTesting:
   SafeAutoCorrect: false
   VersionAdded: "0.1.0"
 
+Vibe/NoCompoundConditions:
+  Description: "Enforces extracting compound boolean conditions into named methods."
+  Enabled: true
+  VersionAdded: "0.3.0"
+
 Vibe/NoRubocopDisable:
   Description: "Enforces that rubocop:disable comments are not used inline."
   Enabled: true
@@ -139,6 +168,12 @@ Vibe/RaiseUnlessBlock:
   SafeAutoCorrect: true
   VersionAdded: "0.2.0"
 
+Vibe/RspecBeforeBlockStyle:
+  Description: "Enforces using do...end syntax instead of braces for RSpec before/after/around blocks."
+  Enabled: true
+  SafeAutoCorrect: true
+  VersionAdded: "0.3.0"
+
 Vibe/RspecStubChainStyle:
   Description: "Enforces that RSpec stub chains are split across lines when too long."
   Enabled: true

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

@@ -0,0 +1,217 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Vibe
+      # Enforces a blank line after variable assignments when followed by other code.
+      #
+      # Variable assignments should be visually separated from the code that uses them.
+      # Consecutive assignments are allowed without blank lines between them, but there
+      # should be a blank line before non-assignment code.
+      #
+      # @example
+      #   # bad
+      #   deleted_count = delete_batch
+      #   break if deleted_count < BATCH_SIZE
+      #
+      #   # good
+      #   deleted_count = delete_batch
+      #
+      #   break if deleted_count < BATCH_SIZE
+      #
+      #   # good - consecutive assignments don't need blank lines
+      #   user = find_user
+      #   account = user.account
+      #
+      #   process(user, account)
+      #
+      #   # good - next line uses the assigned variable
+      #   forwarded = request.headers["X-Forwarded-For"]
+      #   forwarded.to_s.split(",").first.to_s.strip.presence
+      #
+      #   # good - consecutive FactoryBot calls
+      #   website   = create(:website)
+      #   page_view = create(:page_view, website: website)
+      #   create(:page_view, website: website)
+      class BlankLineAfterAssignment < Base
+        extend AutoCorrector
+
+        MSG = "Add a blank line after variable assignment."
+
+        FACTORY_BOT_METHODS = %i(
+          create build build_stubbed attributes_for
+          create_list build_list build_stubbed_list attributes_for_list
+        ).freeze
+
+        # Check block nodes for assignment statements.
+        #
+        # @param [RuboCop::AST::Node] node The block node.
+        # @return [void]
+        def on_block(node)
+          if node.body
+            check_body(node.body)
+          end
+        end
+        alias on_numblock on_block
+
+        # Check method definitions for assignment statements.
+        #
+        # @param [RuboCop::AST::Node] node The def node.
+        # @return [void]
+        def on_def(node)
+          if node.body
+            check_body(node.body)
+          end
+        end
+        alias on_defs on_def
+
+        private
+
+        # Check the body for missing blank lines after assignments.
+        #
+        # @param [RuboCop::AST::Node] body The body node.
+        # @return [void]
+        def check_body(body)
+          statements = extract_statements(body)
+
+          return if statements.size < 2
+
+          statements.each_cons(2) do |current, following|
+            check_statement_pair(current, following)
+          end
+        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
+
+        # Check a pair of statements for missing blank line after assignment.
+        #
+        # @param [RuboCop::AST::Node] current The current statement.
+        # @param [RuboCop::AST::Node] following The following statement.
+        # @return [void]
+        def check_statement_pair(current, following)
+          return unless assignment?(current)
+
+          inner_following = inner_statement(following)
+
+          return if assignment?(inner_following)
+          return if blank_line_between?(current, following)
+          return if following_uses_assigned_variable?(current, inner_following)
+          return if consecutive_factory_bot_calls?(current, following)
+
+          add_offense(following) do |corrector|
+            corrector.insert_after(current, "\n")
+          end
+        end
+
+        # Get the inner statement from a modifier node.
+        #
+        # @param [RuboCop::AST::Node] node The node to unwrap.
+        # @return [RuboCop::AST::Node]
+        def inner_statement(node)
+          return node.if_branch if node.type?(:if) && node.modifier_form?
+          return node.body if node.type?(:while, :until) && node.modifier_form?
+
+          node
+        end
+
+        # Check if both statements are FactoryBot calls.
+        #
+        # @param [RuboCop::AST::Node] assignment The assignment node.
+        # @param [RuboCop::AST::Node] following The following statement.
+        # @return [Boolean]
+        def consecutive_factory_bot_calls?(assignment, following)
+          factory_bot_call?(assignment_value(assignment)) && factory_bot_call?(following)
+        end
+
+        # Get the value being assigned.
+        #
+        # @param [RuboCop::AST::Node] node The assignment node.
+        # @return [RuboCop::AST::Node, nil]
+        def assignment_value(node)
+          node.children.last
+        end
+
+        # Check if a node is a FactoryBot method call.
+        #
+        # @param [RuboCop::AST::Node] node The node to check.
+        # @return [Boolean]
+        def factory_bot_call?(node)
+          node.send_type? && FACTORY_BOT_METHODS.include?(node.method_name)
+        end
+
+        # Check if the following statement starts with the assigned variable.
+        #
+        # @param [RuboCop::AST::Node] assignment The assignment node.
+        # @param [RuboCop::AST::Node] following The following statement.
+        # @return [Boolean]
+        def following_uses_assigned_variable?(assignment, following)
+          var_name = assigned_variable_name(assignment)
+
+          return false unless var_name
+
+          receiver = leftmost_receiver(following)
+
+          return false unless receiver
+
+          receiver.lvar_type? && receiver.children.first == var_name
+        end
+
+        # Get the variable name from an assignment node.
+        #
+        # @param [RuboCop::AST::Node] node The assignment node.
+        # @return [Symbol, nil]
+        def assigned_variable_name(node)
+          return node.children.first if node.lvasgn_type?
+
+          target = node.children.first
+
+          if target.lvasgn_type?
+            target.children.first
+          end
+        end
+
+        # Get the leftmost receiver in a method chain.
+        #
+        # @param [RuboCop::AST::Node] node The node to check.
+        # @return [RuboCop::AST::Node, nil]
+        def leftmost_receiver(node)
+          return node if node.lvar_type?
+          return unless node.send_type?
+
+          current = node
+
+          current = current.receiver while current.send_type? && current.receiver
+
+          current
+        end
+
+        # Check if a node is a variable assignment.
+        #
+        # @param [RuboCop::AST::Node] node The node to check.
+        # @return [Boolean]
+        def assignment?(node)
+          node.type?(:lvasgn, :op_asgn, :or_asgn, :and_asgn)
+        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

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

@@ -67,7 +67,11 @@ module RuboCop
         # @param [RuboCop::AST::Node] body The block body.
         # @return [Array<RuboCop::AST::Node>]
         def extract_statements(body)
-          body.begin_type? ? body.children : [body]
+          if body.begin_type?
+            body.children
+          else
+            [body]
+          end
         end
 
         # Check statements for missing blank lines before expectations.
@@ -89,6 +93,7 @@ module RuboCop
         # @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)

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

@@ -100,6 +100,7 @@ module RuboCop
         # @return [void]
         def check_violations(node, elements, is_model)
           violations = find_violations(elements)
+
           return if violations.empty?
 
           message = is_model ? MODEL_MSG : CLASS_MSG
@@ -117,9 +118,11 @@ module RuboCop
         def on_class(node)
           is_model      = rails_model?(node)
           is_controller = rails_controller?(node)
+
           return if !is_model && !is_controller && !node.body
 
           elements = extract_elements(node, is_model: is_model, is_controller: is_controller)
+
           return if elements.size < 2
 
           check_violations(node, elements, is_model)
@@ -135,6 +138,7 @@ module RuboCop
           return false unless node.parent_class
 
           parent_name = node.parent_class.const_name
+
           return false unless parent_name
 
           # Check for direct ActiveRecord inheritance.
@@ -151,6 +155,7 @@ module RuboCop
           return false unless node.parent_class
 
           parent_name = node.parent_class.const_name
+
           return false unless parent_name
 
           # Check for direct ActionController inheritance.
@@ -183,10 +188,12 @@ module RuboCop
           visibility = :public
           elements   = []
           index      = 0
+
           process_body_nodes(body).each do |child|
             visibility = child.method_name if visibility_modifier?(child)
 
             element = build_element(child, visibility, index, is_model, is_controller)
+
             elements << element and index += 1 if element
           end
 
@@ -206,6 +213,7 @@ module RuboCop
           return unless categorizable?(child)
 
           category = categorize_node(child, visibility, is_model)
+
           return unless category
 
           # Skip public instance methods in controllers (Rails/ActionOrder handles them).
@@ -242,6 +250,7 @@ module RuboCop
         # @return [Array<Hash>] Array of hashes with :text and :column.
         def extract_source_with_comments(node)
           lines = extract_comment_lines(node)
+
           lines.concat(extract_node_lines(node))
         end
 
@@ -264,6 +273,7 @@ module RuboCop
 
           node.source.lines.map.with_index do |line, idx|
             col = idx.zero? ? node_column : line[/\A\s*/].length
+
             { text: line.chomp, column: col }
           end
         end
@@ -384,6 +394,7 @@ module RuboCop
         # @return [Integer]
         def priority_for(category, _node, is_model)
           priorities = is_model ? MODEL_PRIORITIES : CLASS_PRIORITIES
+
           priorities[category] || 999
         end
 
@@ -410,6 +421,7 @@ module RuboCop
         # @return [String]
         def scope_sort_key(node)
           first_arg = node.first_argument
+
           return "" if first_arg.nil?
           return "" unless first_arg.sym_type?
 
@@ -471,6 +483,7 @@ module RuboCop
           base_column = calculate_base_indent(elements)
           replacement = build_replacement(sorted, base_column)
           range       = replacement_range(class_node, elements)
+
           corrector.replace(range, replacement.chomp)
         end
 
@@ -544,6 +557,7 @@ module RuboCop
         # @return [Integer] The base indentation column.
         def calculate_base_indent(elements)
           first_elem = elements.min_by { |e| e[:node].source_range.begin_pos }
+
           first_elem[:node].source_range.column
         end
 
@@ -558,6 +572,7 @@ module RuboCop
 
           source_lines.map do |line|
             relative_indent = " " * [0, line[:column] - min_column].max
+
             "#{indent}#{relative_indent}#{line[:text].lstrip}"
           end.join("\n")
         end
@@ -575,6 +590,7 @@ module RuboCop
           state[:category] = element[:category]
 
           rendered_source = render_source(element[:source], state[:column])
+
           state[:parts] << rendered_source << "\n"
         end
 
@@ -587,6 +603,7 @@ module RuboCop
           return if new_visibility == state[:visibility]
 
           indent = " " * state[:column]
+
           state[:parts] << "\n" if state[:parts].any?
           state[:parts] << "#{indent}#{new_visibility}\n"
         end
@@ -601,7 +618,9 @@ module RuboCop
         # @param [Symbol] last_category The last category.
         # @return [void]
         def add_category_separator(parts, _category, last_category)
-          parts << "\n" if last_category
+          if last_category
+            parts << "\n"
+          end
         end
       end
     end

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

@@ -26,6 +26,7 @@ module RuboCop
       #   service = Users::Activate.new  # Separate group, not aligned
       class ConsecutiveAssignmentAlignment < Base
         extend AutoCorrector
+        include AlignmentHelpers
 
         MSG = "Align consecutive assignments at the = operator."
 
@@ -59,98 +60,12 @@ module RuboCop
         # @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
+          return if statements.size < 2
 
-        # 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
+          groups = group_consecutive_statements(statements, &:lvasgn_type?)
 
-        # 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?
+          groups.each { |group| check_group_alignment(group) }
         end
 
         # Check alignment for a group of assignments.
@@ -163,6 +78,7 @@ module RuboCop
 
           group.each do |asgn|
             current_column = asgn.loc.operator.column
+
             next if current_column == target_column
 
             add_offense(asgn.loc.name) do |corrector|
@@ -200,19 +116,6 @@ module RuboCop
 
           [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