typical_sort 0.0.2 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e562e9296dbb12e4cf437144bfe2b108fe07409f8b70bf844e20f69de7193908
-  data.tar.gz: 9c3565e404b3b5bcd6eacb58ff52061b0c7f09a3a4be8350c80f48c96d3e1964
+  metadata.gz: 9039e103d0aab48801238a87171c7b5294780714acc3df4251f3b4e72cab03d1
+  data.tar.gz: 5717da3c8409651f5b96b2627ceeb419228cf1c643347ab7b9df0583406eb362
 SHA512:
-  metadata.gz: 215dd94a7bb316c864574d106b8fae4980e8a36383408bbbdf038d6d538ac9c52e22b82d0e9f8c7d7b2e7569ea4223a250f1650ac14433aa8d8c0cbbb86b3642
-  data.tar.gz: 4039750518702381bbe6dedffe1618dd44544307f30e46692a6204f9310099e48ef2645e858719d6beae2cf785e74474c695e8b12dcfcb88e8360b21c5906c25
+  metadata.gz: a15dce023ef4db25e7b0b362681db3b7fa95c088141dd9d09c0d3d882b6d9b3f45518901cd7536a3abf3cde629815b4fc8c125b3cee1f0cb74c718f0603d8ab3
+  data.tar.gz: 1947b566ed290db9894688c3025b336b2b98138db56503f8e651c1dea90ce82694a5f9152da03a7baacb1429f038c1db1257689c11bb6ecfbbe0f600775f0d10

data/README.md

@@ -42,6 +42,24 @@ Supported params:
 
 Only declared sorts are allowed. Unknown request sort params are ignored by default, or raised as `TypicalSort::InvalidSort` when configured with `invalid_sort = :raise`.
 
+## Multi-sort
+
+Pass a comma-separated list to sort by multiple fields, in priority order:
+
+```txt
+?sort=last_name,-created_at&sort_dir=asc
+?sort=account.name,last_name&sort_dir=asc
+?sort=insurance_plans.name,-created_at&sort_dir=asc
+```
+
+The first example sorts by last name ascending, then creation time descending. Each field must be declared using the existing `sort` DSL; base columns, association paths, aggregates, and scope sorts can be mixed.
+
+Direction follows the same rules as a single sort: a `-` prefix forces descending; unprefixed fields use `sort_dir`, then the controller's default direction, then the global default direction. For ascending unprefixed fields, pass `sort_dir=asc` if your default is descending.
+
+Whitespace around entries is ignored. Repeated fields use their first occurrence. Invalid entries (including empty entries) are skipped without discarding valid sorts, or raise `TypicalSort::InvalidSort` in strict mode. The primary-key tie-breaker is appended once, after all requested sorts, unless disabled.
+
+Scope sorts receive their field's resolved direction. Use scopes that append `order` clauses to preserve earlier sorts; a scope using `reorder` explicitly replaces preceding ordering.
+
 ## Base and association sorting
 
 Declare base-table columns with symbols:
@@ -194,35 +212,18 @@ bundle exec appraisal rspec
 bundle exec standardrb
 ```
 
-## Releases
-
-Releases are driven by git tags. The version lives in `lib/typical_sort/version.rb`, and the gemspec reads `TypicalSort::VERSION`.
-
-
-```bash
-bundle install
-bin/release patch # or: minor, major
-```
-
-To publish an RC for a specific version:
+### Releasing
 
-```bash
-bin/release rc 1.2.0
-```
-
-This sets the version to `1.2.0-rc` and tags it as `v1.2.0-rc`.
-
-Prereleases can also use `bump`'s native `pre` increment:
+Create a release from `main`:
 
-```bash
-bin/release pre
+```sh
+bin/release {major|minor|patch|pre}
+git push --follow-tags
 ```
 
-`pre` cycles prerelease labels in order: `alpha`, `beta`, `rc`, then the final version. For example, `1.2.0-rc` becomes `1.2.0`, tagged as `v1.2.0`.
-
-`bin/release` uses `bump`, commits the version file, creates a `v<version>` tag, pushes the branch, and pushes the tag.
+The release script validates the repository, bumps the version, creates a git tag.
 
-GitHub Actions publishes only when a `v*` tag is pushed. The publish workflow builds the gem and pushes it to RubyGems with `RUBYGEMS_API_KEY`.
+Publishing to RubyGems and creating a GitHub Release are handled automatically by GitHub Actions.
 
 ## Contributing
 

data/lib/typical_sort/aggregate_sorter.rb

@@ -4,9 +4,16 @@ module TypicalSort
   class AggregateSorter
     VALID_AGGREGATES = %i[min max sum avg count directional].freeze
 
-    attr_reader :records, :relation_name, :reflection, :column_name, :direction, :definition, :configuration
+    attr_reader :records, :relation_name, :reflection, :column_name, :direction, :definition, :configuration, :table_alias
 
-    def initialize(records:, relation_name:, reflection:, column_name:, direction:, definition:, configuration:)
+    # Collapse collection joins once, before applying any requested ordering.
+    def self.prepare(records)
+      table = records.klass.arel_table
+      base_ids = records.except(:select, :order).select(table[records.klass.primary_key])
+      records.klass.where(records.klass.primary_key => base_ids)
+    end
+
+    def initialize(records:, relation_name:, reflection:, column_name:, direction:, definition:, configuration:, table_alias: "typical_sort_scope")
       @records = records
       @relation_name = relation_name.to_sym
       @reflection = reflection
@@ -14,6 +21,7 @@ module TypicalSort
       @direction = direction.to_sym
       @definition = definition
       @configuration = configuration
+      @table_alias = table_alias
     end
 
     def call
@@ -25,10 +33,6 @@ module TypicalSort
       quoted_base_pk = connection.quote_column_name(base_pk)
       sort_value_sql = value_sql(connection)
 
-      base_ids = records
-        .except(:select, :order)
-        .select("#{quoted_base_table}.#{quoted_base_pk}")
-
       filtered_ids = records
         .except(:select, :order, :limit, :offset, :group)
         .select("#{quoted_base_table}.#{quoted_base_pk}")
@@ -42,13 +46,14 @@ module TypicalSort
         )
         .group("#{quoted_base_table}.#{quoted_base_pk}")
 
-      records.klass
-        .where(base_pk => base_ids)
-        .joins(<<~SQL.squish)
-          LEFT JOIN (#{sort_subquery.to_sql}) typical_sort_scope
-            ON typical_sort_scope.typical_sort_record_id = #{quoted_base_table}.#{quoted_base_pk}
-        SQL
-        .order(Arel.sql("typical_sort_scope.typical_sort_value #{sql_direction} NULLS #{nulls_position}"))
+      sort_table = Arel::Table.new(table_alias)
+      join = Arel::Nodes::OuterJoin.new(
+        sort_subquery.arel.as(table_alias),
+        Arel::Nodes::On.new(sort_table[:typical_sort_record_id].eq(records.klass.arel_table[base_pk]))
+      )
+
+      records.joins(join)
+        .order(Arel.sql("#{table_alias}.typical_sort_value #{sql_direction} NULLS #{nulls_position}"))
     end
 
     private

data/lib/typical_sort/params.rb

@@ -11,12 +11,20 @@ module TypicalSort
       @default_direction = default_direction
     end
 
+    def sorts
+      attributes = raw_sort.present? ? raw_sort.to_s.split(",", -1).map(&:strip) : [default_attribute.to_s]
+      attributes.map do |attribute|
+        direction = attribute.start_with?("-") ? :desc : normalized_direction(raw_direction)
+        [attribute.delete_prefix("-"), direction || normalized_direction(default_direction) || configuration.default_direction]
+      end.uniq { |attribute, _direction| attribute }
+    end
+
     def attribute
-      explicit_attribute || default_attribute
+      sorts.first&.first
     end
 
     def direction
-      explicit_direction || normalized_direction(default_direction) || configuration.default_direction
+      sorts.first&.last
     end
 
     def explicit?
@@ -33,18 +41,6 @@ module TypicalSort
       params[configuration.direction_param].presence
     end
 
-    def explicit_attribute
-      return nil if raw_sort.blank?
-
-      raw_sort.to_s.delete_prefix("-")
-    end
-
-    def explicit_direction
-      return :desc if raw_sort.to_s.start_with?("-")
-
-      normalized_direction(raw_direction)
-    end
-
     def normalized_direction(value)
       return nil if value.blank?
 

data/lib/typical_sort/sorter.rb

@@ -5,13 +5,21 @@ require "typical_sort/path_resolver"
 
 module TypicalSort
   class Sorter
-    attr_reader :records, :definition, :direction, :configuration
+    attr_reader :records, :definition, :direction, :configuration, :sort_index
 
-    def initialize(records:, definition:, direction:, configuration:)
+    def self.prepare(records:, definitions:)
+      aggregate = definitions.any? do |definition|
+        !definition.scope? && (definition.aggregate? || PathResolver.new(records: records, path: definition.key).collection_association?)
+      end
+      aggregate ? AggregateSorter.prepare(records) : records
+    end
+
+    def initialize(records:, definition:, direction:, configuration:, sort_index: 0)
       @records = records
       @definition = definition
       @direction = direction.to_sym
       @configuration = configuration
+      @sort_index = sort_index
     end
 
     def call
@@ -28,7 +36,8 @@ module TypicalSort
           column_name: resolver.column_name,
           direction: direction,
           definition: definition,
-          configuration: configuration
+          configuration: configuration,
+          table_alias: "typical_sort_scope_#{sort_index}"
         ).call
       elsif resolver.relation_association?
         sort_relation_association(resolver)

data/lib/typical_sort/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module TypicalSort
-  VERSION = "0.0.2"
+  VERSION = "0.1.0"
 end

data/lib/typical_sort.rb

@@ -56,18 +56,25 @@ module TypicalSort
       default_direction: default_sorting_direction
     )
 
-    attribute = sort_params.attribute
-    return records if attribute.blank?
-
-    definition = sort_definition_for(attribute)
-    return handle_invalid_sort(records, attribute) unless definition
+    sorts = sort_params.sorts.filter_map do |attribute, direction|
+      definition = sort_definition_for(attribute)
+      if definition
+        [definition, direction]
+      elsif TypicalSort.configuration.invalid_sort == :raise
+        raise TypicalSort::InvalidSort, "Invalid sort: #{attribute}"
+      end
+    end
 
-    sorted = TypicalSort::Sorter.new(
-      records: records,
-      definition: definition,
-      direction: sort_params.direction,
-      configuration: request_configuration
-    ).call
+    sorted = TypicalSort::Sorter.prepare(records: records, definitions: sorts.map(&:first))
+    sorts.each_with_index do |(definition, direction), index|
+      sorted = TypicalSort::Sorter.new(
+        records: sorted,
+        definition: definition,
+        direction: direction,
+        configuration: request_configuration,
+        sort_index: index
+      ).call
+    end
 
     append_sort_tiebreaker(sorted)
   end
@@ -76,15 +83,6 @@ module TypicalSort
     typical_sort_set.fetch(attribute)
   end
 
-  def handle_invalid_sort(records, attribute)
-    case TypicalSort.configuration.invalid_sort
-    when :raise
-      raise TypicalSort::InvalidSort, "Invalid sort: #{attribute}"
-    else
-      append_sort_tiebreaker(records)
-    end
-  end
-
   def append_sort_tiebreaker(records)
     return records unless TypicalSort.configuration.tie_breaker == :primary_key
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: typical_sort
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.1.0
 platform: ruby
 authors:
 - Wyatt Kirby