activerecord-sort 8.0.1 → 8.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '00973c2942f313280f8239187ec8c9e0a6ae444211606154c92b10c54333b109'
-  data.tar.gz: d00b63b7250b0b7789c9d02aa6d4654db904ffca88a99e19650715ccd9c25884
+  metadata.gz: ac06d1612ad8c40162ba17e9773ff79b9d3be2808a9357cb99baa213d49366dc
+  data.tar.gz: fbe32a2fbd355362ddafe5961170dcfda5ceb45bca56753fe9e909a636d0fca8
 SHA512:
-  metadata.gz: e50419cf6d24fb591606d97f39d7928b16daffd65ee8d2f70e3f105508e3c5073d2bdd3d1187cc150f0ef3014e422277ba91afad44d6287e19cc3b8fd12fe784
-  data.tar.gz: dfc4e53f7e3f115c84c2804220e91475dd85c930759ac67af1cdf9b0c0f40d0be9327e0e789f5c15481d74837b7c9c83231311ff1c0723d4e729a0f4f813eb5a
+  metadata.gz: 9dee845ccc33507878d09c6c1b3adb31f0e01fa94b70630086fc83fff7a472aa05fec70949d747a18da0c1c97ad54cd11963d4734cc25ea04194075f9470432f
+  data.tar.gz: 8d0d7b0feb26f2ba93a20ada61308b5b363328c3d3f31466c75143c6b239cc2ea25b5c25e4eb6d67e51bd5cd03f1964ed4771f2d4e6099dd2a419f0e52c71cae

data/CHANGELOG.md

@@ -1,5 +1,47 @@
 # Changelog
 
+## [8.1.0] - 2026-10-21
+
+### Added
+
+- `#resort`, which sorts like `#sort` but replaces any order the relation
+  already has, as `reorder` does for `order`, including the order of an
+  association's or default scope. `Property.order(:name).resort(:id)` orders
+  by `id` alone, and `resort(nil)` removes the order as `reorder(nil)` does
+  (a Rails 8.2 `default_order` still applies, as it does after
+  `reorder(nil)`).
+
+### Fixed
+
+- Aggregates on a relation sort now honor `limit` and `offset`. The
+  subquery that restricts them to the sorted records dropped the sort's
+  `GROUP BY` and `ORDER BY` but kept the `LIMIT`, so the limit applied to
+  the join's fanned-out, unordered rows: `Property.sort(addresses:
+  :id).limit(2).count` returned 1 where two records load, and `sum` added
+  up whichever records those rows happened to belong to. The subquery now
+  keeps the group and order, so it selects the same records loading would.
+- Aggregates on a relation sort no longer put back a default scope the
+  relation removed. The outer query restricting them to the sorted records
+  started from the model, re-applying its `default_scope`, so with
+  `default_scope { where(active: true) }`,
+  `Property.unscoped.sort(addresses: :id).count` counted only the active
+  records while loading returned them all. A relation that keeps its
+  default scope still counts within it.
+- Relation sorts now order by the association's own join when its table is
+  joined more than once. Rails aliases the later joins of a table — a
+  second `belongs_to` to the same model, a scoped `has_many`, a
+  self-referential association, or a table the caller already joined —
+  but the sort always named the plain table, so it silently ordered by
+  another join: `Property.joins(:landlord).sort(manager: :name)` ordered
+  by the landlord, `Property.sort(children: :name)` by each record's own
+  name, and `Property.sort(manager: :name).sort(landlord: :name)` dropped
+  the second sort as a duplicate of the first. The sort now finds the
+  alias Rails gave its join when the query is built, so it follows joins
+  added after it too. If that join has been removed (e.g.
+  `unscope(:left_outer_joins)`), building the query raises
+  `ActiveRecord::Sort::InvalidSort` instead of ordering by whichever join
+  has the table's name.
+
 ## [8.0.1] - 2026-09-04
 
 ### Changed
@@ -128,5 +170,7 @@ The gem's version is now independent of the Rails version it targets.
   `ActiveRecord::QueryMethods.public_instance_methods(false)` — which keeps
   Rails' internal delegation invariants intact.
 
+[8.1.0]: https://github.com/malomalo/activerecord-sort/releases/tag/v8.1.0
+[8.0.1]: https://github.com/malomalo/activerecord-sort/releases/tag/v8.0.1
 [8.0.0]: https://github.com/malomalo/activerecord-sort/releases/tag/v8.0.0
 [7.0.0]: https://github.com/malomalo/activerecord-sort/releases/tag/v7.0.0

data/README.md

@@ -115,6 +115,37 @@ Property.all.sort            # => Array of Property, sorted by <=>
 Property.sort(nil)           # => relation (unchanged), for chaining
 ```
 
+Replacing an existing order
+---------------------------
+
+`#sort` adds to any order the relation already has, as `order` does.
+`#resort` replaces it, as `reorder` does, including the order of an
+association's or default scope:
+
+```ruby
+Property.order(:name).sort(:id).to_sql
+# => "...ORDER BY properties.name ASC, properties.id ASC"
+
+Property.order(:name).resort(:id).to_sql
+# => "...ORDER BY properties.id ASC"
+
+property.addresses.resort(:id)   # has_many :addresses, -> { order(:name) }
+# => "...ORDER BY addresses.id ASC"
+
+Property.order(:name).resort(nil) # => relation, with no ORDER BY
+```
+
+With no ordering, `#resort` removes the order the way `reorder(nil)` does, so a
+`default_order` (Rails 8.2+), which applies when a relation has no other order,
+still applies:
+
+```ruby
+has_many :addresses, default_order: :likes
+
+property.addresses.resort(nil)    # ORDER BY likes, as with reorder(nil)
+property.addresses.resort(:name)  # ORDER BY name
+```
+
 Restricting what can be sorted
 ------------------------------
 

data/ext/active_record/base.rb

@@ -60,6 +60,21 @@ module ActiveRecord
       resource
     end
 
+    # Like #sort, but replaces any order the relation already has, as
+    # +reorder+ does for +order+, including the order of an association's or
+    # default scope:
+    #
+    #   Property.order(:name).resort(:id)
+    #   # => "...ORDER BY properties.id ASC"
+    #
+    # With no ordering, or a blank one, its order is removed, as
+    # +reorder(nil)+ does. A +default_order+ (Rails 8.2+) still applies when
+    # the relation has no other order, as it does after +reorder(nil)+.
+    def resort(*ordering)
+      resource = reorder(nil)
+      ordering.empty? ? resource : resource.sort(*ordering)
+    end
+
     # Normalizes per-column sort options into [direction, nulls]. A blank
     # direction — a bare column, or "" as query params often produce —
     # means 'asc'; a blank or nil value means no NULLS clause.
@@ -140,12 +155,11 @@ module ActiveRecord
           # A collection (has_many / has_and_belongs_to_many) wraps the
           # attribute in an Arel::Attributes::Relation so the aggregate
           # references the joined table correctly; a singular association
-          # (belongs_to / has_one) uses the plain attribute.
-          column = if relation.collection?
-            Arel::Attributes::Relation.new(relation.klass.arel_table[column_name], relation.name)
-          else
-            relation.klass.arel_table[column_name]
-          end
+          # (belongs_to / has_one) uses the plain attribute. Either way the
+          # attribute is a JoinedAttribute, pointed at the table (or alias)
+          # the association's join actually uses once the query is built.
+          column = JoinedAttribute.new(relation, column_name)
+          column = Arel::Attributes::Relation.new(column, relation.name) if relation.collection?
 
           direction, nulls = sort_direction_and_nulls(column_options)
 
@@ -181,6 +195,100 @@ module ActiveRecord
   end
 
   module Sort
+    # A column of a sorted association. Rails aliases a table it joins more
+    # than once — a second belongs_to to the same model, a scoped has_many,
+    # a self-join, or a table the caller already joined — and which join
+    # gets the alias depends on every join in the final query, so the sort
+    # can't name the table up front. This stands in for the column until
+    # the query is built, when JoinAliases swaps in the association's
+    # actual table. The reflection is part of its identity, so sorts on two
+    # associations to the same table aren't deduplicated as one.
+    class JoinedAttribute < Arel::Attributes::Attribute
+      attr_reader :reflection
+
+      def initialize(reflection, name)
+        super(reflection.klass.arel_table, name)
+        @reflection = reflection
+      end
+
+      def eql?(other)
+        super && reflection == other.reflection
+      end
+      alias == eql?
+
+      def hash
+        [super, reflection].hash
+      end
+    end
+
+    module JoinAliases
+      def construct_join_dependency(associations, join_type) # :nodoc:
+        join_dependency = super
+        @sort_join_dependencies << join_dependency if @sort_join_dependencies
+        join_dependency
+      end
+
+      private
+
+      # Builds the query, recording the join dependencies Rails constructs
+      # for it, then points each JoinedAttribute in the ORDER BY at the
+      # table its association was joined as. The orders are rebuilt rather
+      # than modified: order nodes are shared with every relation chained
+      # from this one, and those can join differently.
+      def build_arel(...)
+        return super if order_values.empty?
+
+        @sort_join_dependencies = []
+        arel = super
+        # Plus those built beforehand, as eager loading and merge do.
+        join_dependencies = @sort_join_dependencies +
+          (joins_values + left_outer_joins_values).grep(ActiveRecord::Associations::JoinDependency)
+        arel.ast.orders.map! { |order| resolve_sort_joins(order, join_dependencies) }
+        arel
+      ensure
+        @sort_join_dependencies = nil
+      end
+
+      def resolve_sort_joins(node, join_dependencies)
+        case node
+        when JoinedAttribute
+          table = sort_join_table(node.reflection, join_dependencies)
+          raise InvalidSort.new("Can't find the join for #{node.reflection.name} to sort by") unless table
+          table[node.name]
+        when Arel::Attributes::Relation
+          rebuild_sort_node(node, :relation, resolve_sort_joins(node.relation, join_dependencies))
+        when Arel::Nodes::Unary
+          rebuild_sort_node(node, :expr, resolve_sort_joins(node.expr, join_dependencies))
+        when Arel::Nodes::Function
+          rebuild_sort_node(node, :expressions, node.expressions.map { |e| resolve_sort_joins(e, join_dependencies) })
+        else
+          node
+        end
+      end
+
+      def rebuild_sort_node(node, attribute, value)
+        return node if node.public_send(attribute) == value
+
+        node = node.dup
+        node.public_send(:"#{attribute}=", value)
+        node
+      end
+
+      # The table of a top-level join of the association. Every join of it
+      # (the sort's own LEFT JOIN, the caller's, an eager load's) has the
+      # same conditions, so the first found will do.
+      def sort_join_table(reflection, join_dependencies)
+        join_dependencies.each do |join_dependency|
+          join_dependency.send(:join_root).children.each do |join|
+            if join.table && join.reflection.name == reflection.name && join.reflection.active_record == reflection.active_record
+              return join.table
+            end
+          end
+        end
+        nil
+      end
+    end
+
     module Calculations
       # sort_for_relation groups by the primary key and LEFT JOINs the
       # relation, so aggregates would see grouped, fanned-out rows: count
@@ -190,10 +298,14 @@ module ActiveRecord
       # answer: compute it over the base table restricted to the sorted
       # relation's (distinct) primary keys. User joins and conditions still
       # apply inside the subquery, and a user-added group falls through to
-      # the standard grouped behavior.
+      # the standard grouped behavior. The subquery keeps the group and
+      # order so a limit or offset picks the same records loading would,
+      # rather than counting off fanned-out, unordered rows. The outer query
+      # is unscoped: the subquery already carries whatever default scope the
+      # relation kept, and must not have one it removed put back.
       def calculate(operation, column_name)
         if @sorted_by_relation && group_values == [klass.arel_table[klass.primary_key]]
-          klass.where(klass.primary_key => unscope(:group, :order, :select).select(klass.primary_key))
+          klass.unscoped.where(klass.primary_key => except(:select).select(klass.primary_key))
                .calculate(operation, column_name)
         else
           super
@@ -204,3 +316,4 @@ module ActiveRecord
 end
 
 ActiveRecord::Relation.prepend(ActiveRecord::Sort::Calculations)
+ActiveRecord::Relation.prepend(ActiveRecord::Sort::JoinAliases)

data/lib/active_record/sort/version.rb

@@ -2,6 +2,6 @@
 
 module ActiveRecord
   module Sort
-    VERSION = '8.0.1'
+    VERSION = '8.1.0'
   end
 end

data/lib/active_record/sort.rb

@@ -6,4 +6,4 @@ require 'arel/extensions'
 require File.expand_path(File.join(__FILE__, '../../../ext/active_record/base'))
 
 ActiveRecord::QueryMethods.prepend(ActiveRecord::Sort)
-ActiveRecord::Querying.delegate :sort, to: :all
+ActiveRecord::Querying.delegate :sort, :resort, to: :all

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-sort
 version: !ruby/object:Gem::Version
-  version: 8.0.1
+  version: 8.1.0
 platform: ruby
 authors:
 - Jon Bracy