rubocop-asjer 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 421e0eeba6d681b0ee11e88059773f9278c24aa02c30f509e2bd23713ca321e8
-  data.tar.gz: fc1298e689e874814629eab4120349f7658fc848719fff602608f92feb81bb0c
+  metadata.gz: 772cbb0491de18ffeb19b27e41336474005b2c9295f5f2c152c842883e250654
+  data.tar.gz: f2b5e866ba2bccd3fee26d59868f80b8f12de62e57b161e203e932f8aa70533f
 SHA512:
-  metadata.gz: 5e9d9d5a7d0169b30cafb338aa14c61dacfceca1f423d66892791f51fca3d4f3be8a400cc14a834360cdd3ab5e52153658ff1725922a293bf7bca70d81854c31
-  data.tar.gz: 9186614b1209094a659de0a9ec93bc3c5ab7d581db77528977f6ecf4f188350bc9ec32348c356dcb8d1b38e78f82aeb7b4a9f03323eefc5c1c788b5ce6e47ee7
+  metadata.gz: 891112aad96477909e4a2de0a24660655b5573b6ef8f837cd70fe84927502390a3544f47994a9644b4d5b12b826aba74c8ab09f73dde3d49b044bb5fa6cc62cf
+  data.tar.gz: f6c1dd35c8a2fe82392a38576b5c26af9b4958ad732d35493d4ae8e35cd0f423610b4263ff80909ce31c99f28d044a979eb8c0d124a5d4738777f984dc753fb6

data/.release-please-manifest.json

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

data/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [0.4.0](https://github.com/asjer/rubocop-asjer/compare/v0.3.1...v0.4.0) (2026-01-23)
+
+
+### Features
+
+* add `RailsClassOrder` cop to enforce method ordering in Rails models ([#20](https://github.com/asjer/rubocop-asjer/issues/20)) ([bce5d9b](https://github.com/asjer/rubocop-asjer/commit/bce5d9b2affbf207ad34c99d574340d7437e3a04))
+
+## [0.3.1](https://github.com/asjer/rubocop-asjer/compare/v0.3.0...v0.3.1) (2026-01-03)
+
+
+### Bug Fixes
+
+* enable autocorrect for all `default:` option cases in `NoDefaultTranslation` ([fbd359e](https://github.com/asjer/rubocop-asjer/commit/fbd359e6f252188880535c87b3f5abbbd8bac571))
+
 ## [0.3.0](https://github.com/asjer/rubocop-asjer/compare/v0.2.0...v0.3.0) (2026-01-03)
 
 

data/README.md

@@ -44,6 +44,58 @@ t('some.key')
 I18n.t('some.key')
 ```
 
+### Asjer/RailsClassOrder
+
+Enforces consistent ordering of declarative methods in Rails models. Methods are grouped into three categories: associations, callbacks, and others. Groups are separated by blank lines.
+
+**Supports autocorrect** with `rubocop -a` or `rubocop -A`.
+
+```ruby
+# bad
+class User < ApplicationRecord
+  belongs_to :plan
+  validate :validate_name
+  after_create :after_create_1
+  has_many :messages
+  attr_readonly :email
+  after_create :after_create_2
+  belongs_to :role
+  before_create :set_name
+end
+
+# good
+class User < ApplicationRecord
+  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
+```
+
+By default, this cop only runs on files matching `app/models/**/*.rb`. The method lists are fully configurable:
+
+```yaml
+Asjer/RailsClassOrder:
+  Associations:
+    - belongs_to
+    - has_many
+    - has_one
+    - has_and_belongs_to_many
+  Callbacks:
+    - after_initialize
+    - after_find
+    # ... (see config/default.yml for full list)
+  Others:
+    - attr_readonly
+    - serialize
+```
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `bundle exec rspec` to run the tests.

data/config/default.yml

@@ -2,3 +2,40 @@ Asjer/NoDefaultTranslation:
   Description: Checks for use of the `default:` option in translation calls.
   Enabled: true
   VersionAdded: "0.1.0"
+
+Asjer/RailsClassOrder:
+  Description: Enforces consistent ordering of declarative methods in Rails models.
+  Enabled: true
+  VersionAdded: "0.4.0"
+  Include:
+    - 'app/models/**/*.rb'
+  Associations:
+    - belongs_to
+    - has_many
+    - has_one
+    - has_and_belongs_to_many
+  Callbacks:
+    - 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
+    - after_commit
+    - after_rollback
+  Others:
+    - attr_readonly
+    - serialize

data/lib/rubocop/asjer/version.rb

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

data/lib/rubocop/asjer.rb

@@ -5,6 +5,7 @@ require 'rubocop'
 require_relative 'asjer/version'
 require_relative 'asjer/plugin'
 require_relative 'cop/asjer/no_default_translation'
+require_relative 'cop/asjer/rails_class_order'
 
 module RuboCop
   module Asjer

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

@@ -34,9 +34,6 @@ module RuboCop
         def on_send(node)
           translation_with_default?(node) do |default_pair|
             add_offense(default_pair) do |corrector|
-              # Skip autocorrection if default: is the only hash option
-              next if default_pair.parent.pairs.size == 1
-
               corrector.remove(removal_range(default_pair))
             end
           end
@@ -45,7 +42,20 @@ module RuboCop
         private
 
         def removal_range(node)
-          pairs = node.parent.pairs
+          hash_node = node.parent
+          pairs = hash_node.pairs
+
+          return hash_with_comma_range(hash_node) if pairs.size == 1
+
+          pair_removal_range(node, pairs)
+        end
+
+        def hash_with_comma_range(hash_node)
+          with_space = range_with_surrounding_space(range: hash_node.source_range, side: :left)
+          range_with_surrounding_comma(with_space, :left)
+        end
+
+        def pair_removal_range(node, pairs)
           index = pairs.index(node)
 
           last_pair?(index, pairs) ? leading_range(node, pairs[index - 1]) : trailing_range(node, pairs[index + 1])

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

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    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.
+      #
+      # The order is: associations, then callbacks, then others.
+      #
+      # @example
+      #   # bad
+      #   class User < ApplicationRecord
+      #     belongs_to :plan
+      #     validate :validate_name
+      #     after_create :after_create_1
+      #     has_many :messages
+      #     attr_readonly :email
+      #     after_create :after_create_2
+      #     belongs_to :role
+      #     before_create :set_name
+      #   end
+      #
+      #   # good
+      #   class User < ApplicationRecord
+      #     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
+        ASSOCIATIONS = %w[
+          belongs_to has_many has_one has_and_belongs_to_many
+        ].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
+          after_commit after_rollback
+        ].freeze
+
+        OTHERS = %w[attr_readonly serialize].freeze
+      end
+
+      # Enforces consistent ordering of declarative methods in Rails models.
+      #
+      # @see RailsClassOrderDefaults for default method lists
+      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
+
+        def on_class(node)
+          _name, _superclass, body = *node
+          return unless body&.begin_type?
+
+          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
+        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)
+        end
+
+        def all_target_methods
+          @all_target_methods ||= associations + callbacks + others
+        end
+
+        def target_methods(body)
+          body.children.select do |child|
+            child.send_type? && all_target_methods.include?(child.method_name)
+          end
+        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
+            ]
+          end.map(&:first)
+        end
+
+        def method_type(method)
+          name = method.method_name
+          return :association if associations.include?(name)
+          return :callback if callbacks.include?(name)
+
+          :other
+        end
+
+        def method_type_order(method)
+          TYPE_ORDER[method_type(method)]
+        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)
+        end
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-asjer
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Asjer Querido
@@ -57,6 +57,7 @@ files:
 - lib/rubocop/asjer/plugin.rb
 - lib/rubocop/asjer/version.rb
 - lib/rubocop/cop/asjer/no_default_translation.rb
+- lib/rubocop/cop/asjer/rails_class_order.rb
 - release-please-config.json
 - sig/rubocop/i18n.rbs
 homepage: https://github.com/asjer/rubocop-asjer