rubocop-vibe 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e14c979862da1db7feb6dc28697248359d9320450a1bbfca24db50101d9f4c43
-  data.tar.gz: e13a6d3fe34d9a24edc775dba8800e901a2a5a59ca5b3f35f516838e4ca79853
+  metadata.gz: cdbef6b6693f735e021fc40b2ff54c091942cacc146e6d7314b93597d92d5f0a
+  data.tar.gz: 1d612390dcb873c62803cfce7357dc6e73f2dd76cc63adff21478f62d513743f
 SHA512:
-  metadata.gz: 1d89ddcdf3d94bb0aeca2ce767157e305a75990b540f2bd91d1e9255e26e29915da0eb7b3188d293a96b0d4bf2ce4ac25c700f4601238705e82f7c62dbdaaeac
-  data.tar.gz: 064b6dfe86613f8af93718a277db85d6bd705d7580fa27fe69469c41579aa0e4653c14dd4bcc48b56dd1d808c752921b2f69336816fe0ef3fcbb1098dd0d22f2
+  metadata.gz: 4b57b54a638c0cd84c19e2096d5792c145964bfab9c96f5f47f6a19d44f17bf8830260b536f6913cacb1f154da30dd26226ac688b3c5fa074fbcd90346cfbfb9
+  data.tar.gz: dfec2e07080d666343b0ebd686042299eaa129884fa47c35cab9b0f5ccdd54747d7227edecc970bff1e0e3a1279c4ac8c6eedc7a29e0da54df9fbd3edbed7a8e

data/config/default.yml

@@ -98,6 +98,12 @@ Vibe/ConsecutiveIndexedAssignmentAlignment:
   SafeAutoCorrect: true
   VersionAdded: "0.3.0"
 
+Vibe/ConsecutiveInstanceVariableAssignmentAlignment:
+  Description: "Enforces alignment of consecutive instance variable assignments at the = operator."
+  Enabled: true
+  SafeAutoCorrect: true
+  VersionAdded: "0.4.0"
+
 Vibe/ConsecutiveLetAlignment:
   Description: "Enforces alignment of consecutive let declarations at the { brace."
   Enabled: true
@@ -122,6 +128,12 @@ Vibe/IsExpectedOneLiner:
   SafeAutoCorrect: true
   VersionAdded: "0.1.0"
 
+Vibe/LetOrder:
+  Description: "Enforces alphabetical ordering of consecutive let declarations."
+  Enabled: true
+  SafeAutoCorrect: true
+  VersionAdded: "0.4.0"
+
 Vibe/MultilineHashArgumentStyle:
   Description: "Enforces one-per-line and alphabetical ordering for hash arguments in multiline method calls."
   Enabled: true

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

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Vibe
+      # Enforces alignment of consecutive instance 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
+      #   @activation = service.call
+      class ConsecutiveInstanceVariableAssignmentAlignment < Base
+        extend AutoCorrector
+        include AlignmentHelpers
+
+        MSG = "Align consecutive instance variable 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_statements(statements, &:ivasgn_type?)
+
+          groups.each { |group| check_group_alignment(group) }
+        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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Vibe
+      # Enforces alphabetical ordering of consecutive `let` declarations.
+      #
+      # Consecutive `let` declarations (with no blank lines between) should be
+      # alphabetically ordered by their symbol name for better readability and
+      # easier scanning. Groups are broken by blank lines or non-let statements.
+      #
+      # @example
+      #   # bad
+      #   let(:subcategory) { create(:category, :subcategory) }
+      #   let(:budget)      { subcategory.budget }
+      #   let(:category)    { subcategory.parent }
+      #
+      #   # good
+      #   let(:budget)      { subcategory.budget }
+      #   let(:category)    { subcategory.parent }
+      #   let(:subcategory) { create(:category, :subcategory) }
+      #
+      #   # good - blank line breaks the group
+      #   let(:zebra) { create(:zebra) }
+      #
+      #   let(:apple) { create(:apple) }
+      class LetOrder < Base
+        extend AutoCorrector
+        include SpecFileHelper
+        include AlignmentHelpers
+
+        MSG = "Order consecutive `let` declarations alphabetically."
+
+        # @!method let_declaration?(node)
+        #   Check if node is a let/let! declaration.
+        def_node_matcher :let_declaration?, <<~PATTERN
+          (block (send nil? {:let :let!} (sym _)) ...)
+        PATTERN
+
+        # Check describe/context blocks for let ordering.
+        #
+        # @param [RuboCop::AST::Node] node The block node.
+        # @return [void]
+        def on_block(node)
+          return unless spec_file?
+          return unless describe_or_context?(node)
+          return unless node.body
+
+          check_lets_in_body(node.body)
+        end
+        alias on_numblock on_block
+
+        private
+
+        # Check if block is a describe or context block.
+        #
+        # @param [RuboCop::AST::Node] node The block node.
+        # @return [Boolean]
+        def describe_or_context?(node)
+          node.send_node && %i(describe context).include?(node.method_name)
+        end
+
+        # Check let declarations in a body node.
+        #
+        # @param [RuboCop::AST::Node] body The body node.
+        # @return [void]
+        def check_lets_in_body(body)
+          statements = extract_statements(body)
+
+          return if statements.size < 2
+
+          groups = group_consecutive_statements(statements) { |s| let_declaration?(s) }
+
+          groups.each { |group| check_group_order(group) }
+        end
+
+        # Check ordering for a group of let declarations.
+        #
+        # @param [Array<RuboCop::AST::Node>] group The let group.
+        # @return [void]
+        def check_group_order(group)
+          return if alphabetically_ordered?(group)
+
+          violations = find_ordering_violations(group)
+
+          violations.each do |let|
+            add_offense(let.send_node) do |corrector|
+              autocorrect(corrector, group)
+            end
+          end
+        end
+
+        # Check if let declarations are alphabetically ordered.
+        #
+        # @param [Array<RuboCop::AST::Node>] group The let group.
+        # @return [Boolean]
+        def alphabetically_ordered?(group)
+          names = group.map { |let| extract_let_name(let) }
+
+          names == names.sort
+        end
+
+        # Extract the symbol name from a let declaration.
+        #
+        # @param [RuboCop::AST::Node] let The let block node.
+        # @return [String]
+        def extract_let_name(let)
+          let.send_node.first_argument.value.to_s
+        end
+
+        # Find let declarations that violate ordering.
+        #
+        # @param [Array<RuboCop::AST::Node>] group The let group.
+        # @return [Array<RuboCop::AST::Node>] Lets that violate ordering.
+        def find_ordering_violations(group)
+          violations = []
+
+          group.each_cons(2) do |current, following|
+            current_name   = extract_let_name(current)
+            following_name = extract_let_name(following)
+
+            violations << following if current_name > following_name
+          end
+
+          violations.uniq
+        end
+
+        # Auto-correct by reordering let declarations.
+        #
+        # @param [RuboCop::AST::Corrector] corrector The corrector.
+        # @param [Array<RuboCop::AST::Node>] group The let group.
+        # @return [void]
+        def autocorrect(corrector, group)
+          sorted = group.sort_by { |let| extract_let_name(let) }
+
+          group.each_with_index do |let, index|
+            sorted_let = sorted[index]
+
+            next if let == sorted_let
+
+            corrector.replace(let, sorted_let.source)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/vibe_cops.rb

@@ -9,10 +9,12 @@ 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_instance_variable_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/let_order"
 require_relative "vibe/multiline_hash_argument_style"
 require_relative "vibe/no_assigns_attribute_testing"
 require_relative "vibe/no_compound_conditions"

data/lib/rubocop/vibe/version.rb

@@ -2,6 +2,6 @@
 
 module RuboCop
   module Vibe
-    VERSION = "0.3.0"
+    VERSION = "0.4.0"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-vibe
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Tristan Dunn
@@ -93,10 +93,12 @@ files:
 - 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_instance_variable_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/let_order.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