rubocop-asjer 0.4.0 → 0.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 772cbb0491de18ffeb19b27e41336474005b2c9295f5f2c152c842883e250654
-  data.tar.gz: f2b5e866ba2bccd3fee26d59868f80b8f12de62e57b161e203e932f8aa70533f
+  metadata.gz: 447e874612f95f1d94bce6efa0da2fcfe9e06c1b72f624fb707ddc147c5280c3
+  data.tar.gz: a815ca7e0101b2e2d1bac4bfed12718ef10e95da304dfafa83c2bc74ef10b094
 SHA512:
-  metadata.gz: 891112aad96477909e4a2de0a24660655b5573b6ef8f837cd70fe84927502390a3544f47994a9644b4d5b12b826aba74c8ab09f73dde3d49b044bb5fa6cc62cf
-  data.tar.gz: f6c1dd35c8a2fe82392a38576b5c26af9b4958ad732d35493d4ae8e35cd0f423610b4263ff80909ce31c99f28d044a979eb8c0d124a5d4738777f984dc753fb6
+  metadata.gz: 59c42f2eb2390c5356d9afbe628a48652707c9ff3527306e2e83c29e48e9fbd04f1cfefd01f0d6b7d6da06198777d4a31721f2cce51319652ba24325d93a71a7
+  data.tar.gz: f0486413521d14aded52af6e496addd3f015c44ca832e393bb445b127c065f82e0aa0d3e906dd72bcda71439f5a451fbf68729afb89dec09182e7de06639d81a

data/.release-please-manifest.json

@@ -1,3 +1,3 @@
 {
-  ".": "0.4.0"
+  ".": "0.4.2"
 }

data/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [0.4.2](https://github.com/asjer/rubocop-asjer/compare/v0.4.1...v0.4.2) (2026-01-28)
+
+
+### Bug Fixes
+
+* add missing rails classes to `RailsClassOrder` cop configuration ([0ddc16a](https://github.com/asjer/rubocop-asjer/commit/0ddc16a165530b0aa5c4e0d37195324779fca9a8))
+
+## [0.4.1](https://github.com/asjer/rubocop-asjer/compare/v0.4.0...v0.4.1) (2026-01-28)
+
+
+### Bug Fixes
+
+* improve autocorrect functionality for `RailsClassOrder` cop and add Ruby 4.0 to ci ([#23](https://github.com/asjer/rubocop-asjer/issues/23)) ([16fc637](https://github.com/asjer/rubocop-asjer/commit/16fc63770f05f74e2bc005becd136af7d8ccb0d1))
+
 ## [0.4.0](https://github.com/asjer/rubocop-asjer/compare/v0.3.1...v0.4.0) (2026-01-23)
 
 

data/config/default.yml

@@ -9,33 +9,71 @@ Asjer/RailsClassOrder:
   VersionAdded: "0.4.0"
   Include:
     - 'app/models/**/*.rb'
+  Scopes:
+    - default_scope
+    - scope
+  Attributes:
+    - attr_accessor
+    - attr_reader
+    - attr_writer
+    - attr_readonly
+    - attribute
+    - serialize
+    - store
+    - store_accessor
+  Enums:
+    - enum
   Associations:
     - belongs_to
-    - has_many
     - has_one
+    - has_many
     - has_and_belongs_to_many
+    - has_one_attached
+    - has_many_attached
+  Validations:
+    - validates
+    - validates_acceptance_of
+    - validates_associated
+    - validates_comparison_of
+    - validates_confirmation_of
+    - validates_each
+    - validates_exclusion_of
+    - validates_format_of
+    - validates_inclusion_of
+    - validates_length_of
+    - validates_size_of
+    - validates_numericality_of
+    - validates_presence_of
+    - validates_uniqueness_of
+    - validates_with
+    - validate
   Callbacks:
     - after_initialize
     - after_find
     - after_touch
     - before_validation
-    - validates
-    - validate
     - after_validation
     - before_save
     - around_save
     - before_create
     - around_create
+    - after_create
     - before_update
     - around_update
+    - after_update
+    - after_save
     - before_destroy
     - around_destroy
     - after_destroy
-    - after_update
-    - after_create
-    - after_save
     - after_commit
     - after_rollback
   Others:
-    - attr_readonly
-    - serialize
+    - encrypts
+    - normalizes
+    - delegate
+    - delegate_missing_to
+    - accepts_nested_attributes_for
+    - has_secure_password
+    - has_secure_token
+    - generates_token_for
+    - composed_of

data/lib/rubocop/asjer/version.rb

@@ -2,6 +2,6 @@
 
 module RuboCop
   module Asjer
-    VERSION = '0.4.0'
+    VERSION = '0.4.2'
   end
 end

data/lib/rubocop/cop/asjer/rails_class_order.rb

@@ -5,11 +5,12 @@ module RuboCop
     module Asjer
       # Enforces consistent ordering of declarative methods in Rails models.
       #
-      # Methods are grouped into three categories: associations, callbacks,
-      # and others. Within each category, methods are sorted by their position
-      # in the configured list. Groups are separated by blank lines.
+      # Methods are grouped into seven categories following Rails Style Guide:
+      # scopes, attributes, enums, associations, validations, callbacks, and others.
+      # Within each category, methods are sorted by their position in the configured list.
+      # Groups are separated by blank lines.
       #
-      # The order is: associations, then callbacks, then others.
+      # The order is: scopes, attributes, enums, associations, validations, callbacks, then others.
       #
       # @example
       #   # bad
@@ -18,7 +19,9 @@ module RuboCop
       #     validate :validate_name
       #     after_create :after_create_1
       #     has_many :messages
+      #     scope :active, -> { where(active: true) }
       #     attr_readonly :email
+      #     enum :status, [:pending, :active]
       #     after_create :after_create_2
       #     belongs_to :role
       #     before_create :set_name
@@ -26,34 +29,126 @@ module RuboCop
       #
       #   # good
       #   class User < ApplicationRecord
+      #     scope :active, -> { where(active: true) }
+      #
+      #     attr_readonly :email
+      #
+      #     enum :status, [:pending, :active]
+      #
       #     belongs_to :plan
       #     belongs_to :role
       #     has_many :messages
       #
       #     validate :validate_name
+      #
       #     before_create :set_name
       #     after_create :after_create_1
       #     after_create :after_create_2
-      #
-      #     attr_readonly :email
       #   end
       #
       # Default method lists for RailsClassOrder cop
       module RailsClassOrderDefaults
+        SCOPES = %w[default_scope scope].freeze
+
+        ATTRIBUTES = %w[
+          attr_accessor attr_reader attr_writer attr_readonly
+          attribute serialize store store_accessor
+        ].freeze
+
+        ENUMS = %w[enum].freeze
+
         ASSOCIATIONS = %w[
-          belongs_to has_many has_one has_and_belongs_to_many
+          belongs_to has_one has_many has_and_belongs_to_many
+          has_one_attached has_many_attached
+        ].freeze
+
+        VALIDATIONS = %w[
+          validates validates_acceptance_of validates_associated
+          validates_comparison_of validates_confirmation_of validates_each
+          validates_exclusion_of validates_format_of validates_inclusion_of
+          validates_length_of validates_size_of validates_numericality_of
+          validates_presence_of validates_uniqueness_of validates_with
+          validate
         ].freeze
 
         CALLBACKS = %w[
           after_initialize after_find after_touch
-          before_validation validates validate after_validation
-          before_save around_save before_create around_create
-          before_update around_update before_destroy around_destroy
-          after_destroy after_update after_create after_save
+          before_validation after_validation
+          before_save around_save
+          before_create around_create after_create
+          before_update around_update after_update
+          after_save
+          before_destroy around_destroy after_destroy
           after_commit after_rollback
         ].freeze
 
-        OTHERS = %w[attr_readonly serialize].freeze
+        OTHERS = %w[
+          encrypts normalizes delegate delegate_missing_to
+          accepts_nested_attributes_for has_secure_password
+          has_secure_token generates_token_for composed_of
+        ].freeze
+      end
+
+      # Autocorrect helpers for RailsClassOrder cop
+      module RailsClassOrderCorrector
+        def autocorrect(corrector, body, original, sorted)
+          first_target = original.min_by { |m| body.children.index(m) }
+          new_source = build_sorted_source(sorted, original)
+          corrector.replace(range_with_comments(first_target), new_source.rstrip)
+
+          (original - [first_target]).each do |method|
+            corrector.remove(full_method_range(method))
+          end
+        end
+
+        def range_with_comments(node)
+          comments = preceding_comments(node)
+          start_pos = comments.empty? ? node.loc.expression.begin_pos : comments.first.loc.expression.begin_pos
+          range_between(start_pos, node.loc.expression.end_pos)
+        end
+
+        def preceding_comments(node)
+          collect_adjacent_comments(node.loc.expression)
+        end
+
+        def collect_adjacent_comments(node_pos)
+          expected_line = node_pos.first_line - 1
+          comments_before_node(node_pos).take_while do |comment|
+            pos = comment.loc.expression
+            (pos.last_line == expected_line).tap { expected_line = pos.first_line - 1 }
+          end.reverse
+        end
+
+        def comments_before_node(node_pos)
+          processed_source.comments.select { |c| c.loc.expression.end_pos < node_pos.begin_pos }.reverse
+        end
+
+        def full_method_range(node)
+          range = range_with_comments(node)
+          source = processed_source.buffer.source
+          line_start = source.rindex("\n", range.begin_pos - 1)&.+(1) || 0
+          end_pos = source[range.end_pos] == "\n" ? range.end_pos + 1 : range.end_pos
+          range_between(line_start, end_pos)
+        end
+
+        def build_sorted_source(sorted, original)
+          indent = ' ' * original.first.loc.column
+          grouped = sorted.group_by { |m| method_type(m) }
+          format_grouped_source(grouped, indent)
+        end
+
+        def format_grouped_source(grouped, indent)
+          self.class::TYPE_ORDER.keys.filter_map do |type|
+            next unless grouped[type]&.any?
+
+            grouped[type].map { |m| source_with_comments(m) }.join("\n#{indent}")
+          end.join("\n\n#{indent}")
+        end
+
+        def source_with_comments(node)
+          range = range_with_comments(node)
+          processed_source.buffer.source[range.begin_pos...range.end_pos].lstrip
+        end
       end
 
       # Enforces consistent ordering of declarative methods in Rails models.
@@ -62,66 +157,79 @@ module RuboCop
       class RailsClassOrder < Base
         extend AutoCorrector
         include RangeHelp
-
-        MSG = 'Declarative methods should be sorted by type: associations, callbacks, then others.'
-
-        TYPE_ORDER = { association: 0, callback: 1, other: 2 }.freeze
+        include RailsClassOrderCorrector
+
+        MSG = 'Declarative methods should be sorted by type: scopes, attributes, enums, ' \
+              'associations, validations, callbacks, then others.'
+
+        TYPE_ORDER = {
+          scope: 0,
+          attribute: 1,
+          enum: 2,
+          association: 3,
+          validation: 4,
+          callback: 5,
+          other: 6
+        }.freeze
+
+        CATEGORY_CONFIG = {
+          scope: { key: 'Scopes', const: :SCOPES },
+          attribute: { key: 'Attributes', const: :ATTRIBUTES },
+          enum: { key: 'Enums', const: :ENUMS },
+          association: { key: 'Associations', const: :ASSOCIATIONS },
+          validation: { key: 'Validations', const: :VALIDATIONS },
+          callback: { key: 'Callbacks', const: :CALLBACKS },
+          other: { key: 'Others', const: :OTHERS }
+        }.freeze
 
         def on_class(node)
           _name, _superclass, body = *node
           return unless body&.begin_type?
 
+          check_order(body)
+        end
+
+        private
+
+        def check_order(body)
           targets = target_methods(body)
           return if targets.empty?
 
           sorted = sort_methods(targets)
           return if targets == sorted
 
-          add_offense(body) do |corrector|
-            autocorrect(corrector, body, targets, sorted) if contiguous?(body, targets)
-          end
+          first_misplaced = targets.zip(sorted).find { |a, e| a != e }&.first
+          add_offense(first_misplaced) { |corrector| autocorrect(corrector, body, targets, sorted) }
         end
 
-        private
-
-        def associations
-          @associations ||= cop_config.fetch('Associations', RailsClassOrderDefaults::ASSOCIATIONS).map(&:to_sym)
-        end
-
-        def callbacks
-          @callbacks ||= cop_config.fetch('Callbacks', RailsClassOrderDefaults::CALLBACKS).map(&:to_sym)
-        end
-
-        def others
-          @others ||= cop_config.fetch('Others', RailsClassOrderDefaults::OTHERS).map(&:to_sym)
+        def category_methods(category)
+          cfg = CATEGORY_CONFIG[category]
+          instance_variable_get(:"@#{category}") ||
+            instance_variable_set(
+              :"@#{category}",
+              cop_config.fetch(cfg[:key], RailsClassOrderDefaults.const_get(cfg[:const])).map(&:to_sym)
+            )
         end
 
         def all_target_methods
-          @all_target_methods ||= associations + callbacks + others
+          @all_target_methods ||= TYPE_ORDER.keys.flat_map { |cat| category_methods(cat) }
         end
 
         def target_methods(body)
-          body.children.select do |child|
-            child.send_type? && all_target_methods.include?(child.method_name)
-          end
+          body.children.select { |child| child.send_type? && all_target_methods.include?(child.method_name) }
         end
 
         def sort_methods(methods)
-          # Use sort_by with index to make stable sort (preserve original order for equal elements)
           methods.each_with_index.sort_by do |method, index|
-            [
-              method_type_order(method),
-              method_position_in_type(method),
-              index
-            ]
+            [method_type_order(method), method_position_in_type(method), index]
           end.map(&:first)
         end
 
         def method_type(method)
           name = method.method_name
-          return :association if associations.include?(name)
-          return :callback if callbacks.include?(name)
-
+          TYPE_ORDER.each_key do |category|
+            return category if category_methods(category).include?(name)
+          end
           :other
         end
 
@@ -130,50 +238,8 @@ module RuboCop
         end
 
         def method_position_in_type(method)
-          name = method.method_name
-          list = method_list_for_type(method_type(method))
-          list.index(name) || list.size
-        end
-
-        def method_list_for_type(type)
-          { association: associations, callback: callbacks, other: others }[type]
-        end
-
-        def contiguous?(body, targets)
-          indices = targets.map { |t| body.children.index(t) }
-          indices.max - indices.min + 1 == indices.size
-        end
-
-        def autocorrect(corrector, _body, original, sorted)
-          grouped = group_by_type(sorted)
-          new_source = build_grouped_source(grouped, original)
-          range = methods_range(original)
-          corrector.replace(range, new_source)
-        end
-
-        def group_by_type(methods)
-          methods.group_by { |m| method_type(m) }
-        end
-
-        def build_grouped_source(grouped, original)
-          indent = ' ' * original.first.loc.column
-
-          groups = []
-          %i[association callback other].each do |type|
-            next unless grouped[type]&.any?
-
-            group_lines = grouped[type].map(&:source)
-            groups << group_lines.join("\n#{indent}")
-          end
-
-          groups.join("\n\n#{indent}")
-        end
-
-        def methods_range(methods)
-          first = methods.min_by { |m| m.loc.expression.begin_pos }
-          last = methods.max_by { |m| m.loc.expression.end_pos }
-
-          range_between(first.loc.expression.begin_pos, last.loc.expression.end_pos)
+          list = category_methods(method_type(method))
+          list.index(method.method_name) || list.size
         end
       end
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-asjer
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.4.2
 platform: ruby
 authors:
 - Asjer Querido