activerecord-sort 8.0.1 → 10.0.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '00973c2942f313280f8239187ec8c9e0a6ae444211606154c92b10c54333b109'
-  data.tar.gz: d00b63b7250b0b7789c9d02aa6d4654db904ffca88a99e19650715ccd9c25884
+  metadata.gz: 55d032ac200c1f9c9bc9a06f988d54744427dcb2afbb2d0f82e89b7f7e6f32de
+  data.tar.gz: 5e10e73498fb36d17d579f9610a79d54ff254b3e36eb5940f9971e5538f15300
 SHA512:
-  metadata.gz: e50419cf6d24fb591606d97f39d7928b16daffd65ee8d2f70e3f105508e3c5073d2bdd3d1187cc150f0ef3014e422277ba91afad44d6287e19cc3b8fd12fe784
-  data.tar.gz: dfc4e53f7e3f115c84c2804220e91475dd85c930759ac67af1cdf9b0c0f40d0be9327e0e789f5c15481d74837b7c9c83231311ff1c0723d4e729a0f4f813eb5a
+  metadata.gz: 91149455ebd6e9bf3f44b78a4e249c11335ca900923898dc4b90a10113b00276ab44dbe6412f58829f41aa40a04b3d664238e261633c8d3efcfee9087480d78f
+  data.tar.gz: 6e8028be2e9a156bd5a36ff0fc566121b2313aaa4aa48a51b48e41d344f7f59f10837f7c4cdee2fc8a98c763e8962b6fe9a406d560c77f482b26dc4c03651248

data/CHANGELOG.md

@@ -1,39 +1,11 @@
 # Changelog
 
-## [8.0.1] - 2026-09-04
+## 10.0.0.rc1 (July 15, 2026)
 
-### Changed
-
-- Enabled `# frozen_string_literal: true`, so the gem no longer allocates a
-  new String for each literal it evaluates.
-- An unrecognized value in the nulls position now raises
-  `ActiveRecord::Sort::InvalidSort` instead of being silently dropped.
-  `sort(:name => {:asc => :nulls_frist})` previously ordered by a plain
-  `ASC`, quietly returning results in the wrong null order; it now raises,
-  like any other unknown sort value. A blank nulls value still means "no
-  `NULLS` clause" rather than an invalid one — `""` (what query params
-  send) and `nil` (what JSON sends) are both absent, not wrong.
-
-### Fixed
-
-- Directions and nulls values are now matched case-insensitively wherever
-  they appear. `sort(:name => 'DESC')` already downcased, but the hash forms
-  did not, so `sort(:name => {'DESC' => 'NULLS_LAST'})` raised on the same
-  input the bare form accepted.
-- `sort(:name => {})` now sorts ascending instead of raising. An empty hash
-  states no direction, which is what `""` (from a query string) and `nil`
-  (from JSON) already meant; the blank check simply sat after the hash
-  check and so never saw it.
-- Sort parameters holding `nil` or a non-string key no longer raise
-  `NoMethodError`. `{"name" => {"asc" => nil}}`, `{"name" => {nil =>
-  "asc"}}` and a non-string column such as `{123 =>
-  "asc"}` — all reachable from a JSON request body, where a query string
-  would send `""` — now raise `ActiveRecord::Sort::InvalidSort`, or sort
-  normally where the value is merely absent, honoring the documented
-  contract that unfiltered params are rescuable as
-  `ActiveRecord::StatementInvalid`.
-
-## [8.0.0] - 2026-08-27
+Starting with this release the gem is versioned independently of Rails,
+following [semantic versioning](https://semver.org). Earlier releases
+(6.x) tracked the minimum supported Rails version; the jump to 10 makes
+the break explicit so the version can't be misread as a Rails version.
 
 ### Breaking changes
 
@@ -66,19 +38,13 @@
   `Address.sort(property: :name)`) now defaults to ascending, matching
   every other sort form (previously descending).
 - An unknown sort direction on a relation sort (e.g. `:dsc`) now raises
-  `ActiveRecord::Sort::InvalidSort` (previously sorted ascending
+  `ActiveRecord::StatementInvalid` (previously sorted ascending
   silently), matching column sorts.
+- ActiveRecord 7.1 or newer is required (previously 6.1).
 
 ### Added
 
 - Sorting by `has_and_belongs_to_many` relations.
-- Unrecognized sort columns, associations, and directions raise
-  `ActiveRecord::Sort::InvalidSort`, a subclass of
-  `ActiveRecord::StatementInvalid` — so existing
-  `rescue ActiveRecord::StatementInvalid` handlers still catch bad sort
-  parameters, while callers can rescue the narrower class. Relation sort
-  columns are now validated up front (against the associated model's
-  columns) instead of only failing once the query reaches the database.
 - Sorts of different types compose: they can be combined in one call
   (`Property.sort(:name, tags: :name, addresses: :id)`) or chained
   (`.sort(...).sort(...)`), sharing a single `GROUP BY`.
@@ -100,33 +66,3 @@
   there).
 - Combining a `has_and_belongs_to_many` sort with another relation sort
   raised `PG::GroupingError`.
-
-## [7.0.0] - 2026-08-27
-
-The gem's version is now independent of the Rails version it targets.
-
-### Breaking Changes
-
-- Removed the public `random_sort` method. Use `sort(:random)` instead.
-
-### Changed
-
-- Require `activerecord >= 8.0.0, < 9.0`; support for Rails 7.1 and 7.2 has
-  been dropped.
-- Require `arel-extensions >= 9.0.0`.
-- `#sort` called with no arguments now falls back to Ruby's `Enumerable#sort`
-  (loads the records and sorts them by `<=>`) instead of returning the
-  relation. Pass arguments to use the ordering DSL; `sort(nil)` and `sort([])`
-  still return the relation for chaining.
-
-### Internal
-
-- The `sort`, `sort_for_column`, and `sort_for_relation` methods are now
-  defined in an `ActiveRecord::Sort` module prepended onto
-  `ActiveRecord::QueryMethods`, rather than reopening `QueryMethods` directly.
-  Relations still respond to them, but they no longer appear in
-  `ActiveRecord::QueryMethods.public_instance_methods(false)` — which keeps
-  Rails' internal delegation invariants intact.
-
-[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

@@ -1,23 +1,11 @@
 # ActiveRecord::Sort
 
-`ActiveRecord::Sort` provides an easy, safe way to accept user input and order a
-query by it. Only recognized columns and associations produce SQL — anything
-else raises `ActiveRecord::StatementInvalid`, so unfiltered request parameters
-can't inject SQL.
-
-Recognized is not the same as permitted, though. Every column on the model and
-on its associations is sortable, including ones you never expose — see
-[Restricting what can be sorted](#restricting-what-can-be-sorted).
-
-Requirements
-------------
-
-- Rails / ActiveRecord >= 8.0
+`ActiveRecord::Sort` provides and easy way to accept user input and order a query by the input.
 
 Installation
 ------------
 
-Add `activerecord-sort` to your Gemfile and run `bundle`:
+Add `sunstone` to your Gemfile and run `bundle`:
 
 ```ruby
 gem 'activerecord-sort', require: 'active_record/sort'
@@ -27,10 +15,8 @@ Or install the gem and require it:
 
 ```sh
 gem install activerecord-sort
-```
-
-```ruby
-require 'active_record/sort'
+irb
+# => require('active_record/sort')
 ```
 
 Examples
@@ -47,10 +33,10 @@ Property.sort(:id, :name).to_sql
 Property.sort(id: :desc).to_sql
 # => "...ORDER BY properties.id DESC"
 
-Property.sort(id: {asc: :nulls_first}).to_sql
+Property.sort(id: {asc: :nulls_first})
 # => "...ORDER BY properties.id ASC NULLS FIRST"
 
-Property.sort(id: {asc: :nulls_last}).to_sql
+Property.sort(id: {asc: :nulls_last})
 # => "...ORDER BY properties.id ASC NULLS LAST"
 ```
 
@@ -58,10 +44,7 @@ It can also sort on relations. A relation sort groups by the sorted table's
 primary key — so each record appears once and records with no associated
 rows are still included — and orders by an aggregate of the requested
 column: `MIN` ascending or `MAX` descending, keying each record by the
-member you'd expect to see first in that direction. A record with no
-associated rows has a `NULL` sort key; where `NULL`s land is
-database-dependent, so pass `nulls_first`/`nulls_last` to place those
-records explicitly:
+member you'd expect to see first in that direction:
 
 ```ruby
 Property.sort(addresses: :id).to_sql
@@ -88,61 +71,3 @@ A relation sort is order-only — it never adds or removes records — so
 aggregates on a sorted relation (`count`, `sum`, `average`, `minimum`,
 `maximum`) are computed over the records themselves, not the sort's
 grouped and joined rows.
-
-Order randomly:
-
-```ruby
-Property.sort(:random).to_sql
-# => "...ORDER BY RANDOM()"
-```
-
-Unrecognized columns raise, so unfiltered params can't inject SQL:
-
-```ruby
-Property.sort(:name_or_something_unexpected)
-# => raises ActiveRecord::Sort::InvalidSort
-```
-
-`ActiveRecord::Sort::InvalidSort` subclasses `ActiveRecord::StatementInvalid`,
-so existing `rescue ActiveRecord::StatementInvalid` handlers keep catching bad
-sort parameters, while callers that want to can rescue the narrower class.
-
-Called with no arguments, `#sort` behaves like Ruby's `Enumerable#sort` —
-it loads the records and sorts them by `<=>` — rather than building a query:
-
-```ruby
-Property.all.sort            # => Array of Property, sorted by <=>
-Property.sort(nil)           # => relation (unchanged), for chaining
-```
-
-Restricting what can be sorted
-------------------------------
-
-`#sort` checks that a name is a real column or association — not that the
-requester is allowed to know about it. Every column is sortable, including the
-ones you don't select:
-
-```ruby
-User.sort(:password_digest)               # valid, and it sorts
-Post.sort(author: :reset_password_token)  # so is this
-```
-
-A sort reveals something about a column even though its values are never
-returned, because the resulting order is a comparison. Someone with a row they
-control can set their own value, see which side of it a target row lands on,
-and narrow the value down over a series of ordinary-looking requests. Equal
-values also sort together, which is enough to tell that two accounts share a
-password hash.
-
-So passing parameters straight through is safe as far as SQL injection goes,
-but *which* columns may be sorted is an authorization question, and only your
-application can answer it. Filter the parameters before they reach `#sort`:
-
-```ruby
-SORTABLE = %w[name created_at].freeze
-
-Property.sort(sort_params.slice(*SORTABLE))
-```
-
-[StandardAPI](https://github.com/malomalo/standardapi) does this with an ACL,
-resolving per request which attributes a user may read and sort by.

data/ext/active_record/base.rb

@@ -1,23 +1,9 @@
-# frozen_string_literal: true
-
 require 'active_record'
 require 'active_record/relation'
 
 module ActiveRecord
-  # Prepended onto ActiveRecord::QueryMethods (see lib/active_record/sort.rb).
-  # Living in a separate module keeps these methods out of
-  # QueryMethods.public_instance_methods(false) — which Rails' own
-  # delegation tests assert against — while relations still respond to them.
-  module Sort
-
-    # Raised when a sort references an unrecognized column or association,
-    # or an unknown direction. Subclasses StatementInvalid so existing
-    # `rescue ActiveRecord::StatementInvalid` handlers — the safety
-    # contract that makes it OK to pass request params straight through —
-    # keep working, while callers can rescue this narrower class to tell a
-    # bad sort parameter apart from a genuine database error.
-    class InvalidSort < ActiveRecord::StatementInvalid
-    end
+  module QueryMethods
+  # class << self
 
     # ordering:
     # :id
@@ -27,14 +13,7 @@ module ActiveRecord
     # :listings => :id
     # :listings => {:id => {:asc => :nulls_first}}
     # :random
-    def sort(*ordering, &block)
-      # With no arguments, fall back to Ruby's Enumerable#sort so code (and
-      # Rails' own test suite) that calls `relation.sort` expecting Ruby
-      # semantics keeps working. The ordering DSL only applies when given
-      # arguments; `sort(nil)`/`sort([])` still return the relation for
-      # chaining.
-      return super(&block) if ordering.empty?
-
+    def sort(*ordering)
       resource = all
       ordering.compact!
       ordering.flatten!
@@ -43,65 +22,48 @@ module ActiveRecord
       ordering.each do |order|
         order = Array(order)
         order.each do |column_or_relation, options|
-          key = column_or_relation.to_s
-
-          if key == 'random'
-            resource = resource.order(Arel::Nodes::RandomOrdering.new)
-          elsif self.column_names.include?(key)
-            resource = resource.sort_for_column(self.arel_table[key], options)
-          elsif reflect_on_association(key)
-            resource = resource.sort_for_relation(key, options)
+          if column_or_relation.to_sym == :random
+            resource = resource.random_sort
+          elsif self.column_names.include?(column_or_relation.to_s)
+            resource = resource.sort_for_column(self.arel_table[column_or_relation.to_s], options)
+          elsif reflect_on_association(column_or_relation.to_sym)
+            resource = resource.sort_for_relation(column_or_relation.to_sym, options)
           else
-            raise InvalidSort.new("Unknown column #{key}")
+            raise ActiveRecord::StatementInvalid.new("Unkown column #{column_or_relation}")
           end
         end
       end
 
       resource
     end
+    
+    def random_sort
+      self.order(Arel::Nodes::RandomOrdering.new)
+    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.
+    # means :asc.
+    # TODO: probably don't need to cast to sym
     def sort_direction_and_nulls(options)
-      if options.blank?
-        ['asc', nil]
-      elsif options.is_a?(Hash) || options.class.name == "ActionController::Parameters"
-        direction = options.keys.first.to_s.downcase
-
-        if direction == 'asc' || direction == 'desc'
-          [direction, sort_nulls(options.values.first)]
-        else
-          [direction, nil]
-        end
+      if options.is_a?(Hash) || options.class.name == "ActionController::Parameters"
+        [options.keys.first.to_sym, options.values.first.to_sym]
+      elsif options.blank?
+        [:asc, nil]
       else
-        [options.to_s.downcase, nil]
+        [options.to_s.downcase.to_sym, nil]
       end
     end
 
-    # Cast on the way out: Arel's visitor matches the nulls value with
-    # `case o.nulls when :nulls_first`, so this is the one value that has
-    # to reach the node as a symbol.
-    def sort_nulls(value)
-      return nil if value.blank?
-
-      nulls = value.to_s.downcase
-      if nulls != 'nulls_first' && nulls != 'nulls_last'
-        raise InvalidSort.new("Unknown nulls ordering #{value}")
-      end
-
-      nulls.to_sym
-    end
-
     def sort_for_column(column, options)
       direction, nulls = sort_direction_and_nulls(options)
 
-      if direction == 'desc'
+      if direction == :desc
         self.order(Arel::Nodes::Descending.new(column, nulls))
-      elsif direction == 'asc'
+      elsif direction == :asc
         self.order(Arel::Nodes::Ascending.new(column, nulls))
       else
-        raise InvalidSort.new("Unknown ordering #{direction}")
+        raise ActiveRecord::StatementInvalid.new("Unkown ordering #{direction}")
       end
     end
 
@@ -114,63 +76,68 @@ module ActiveRecord
     def sort_for_relation(relation, options)
       resource = self
       relation = reflect_on_association(relation)
-      options = [options] if !options.is_a?(Array)
-
-      # LEFT JOIN the association, group by this table's primary key — so
-      # rows don't fan / duplicate and records with an empty collection
-      # still appear — and order by an aggregate of the requested column:
-      #
-      #   SELECT properties.*
-      #   FROM properties
-      #   LEFT JOIN properties_tags ON properties_tags.property_id = properties.id
-      #   LEFT JOIN tags ON tags.id = properties_tags.tag_id
-      #   GROUP BY properties.id
-      #   ORDER BY MIN(tags.name) ASC
-      #
-      # Ascending keys each record by its smallest member (MIN), descending
-      # by its largest (MAX) — the member you'd expect to see first in that
-      # direction. Toggling asc/desc therefore re-keys multi-value records
-      # rather than strictly reversing the list.
-      options.each do |order|
-        Array(order).each do |column_name, column_options|
-          if !relation.klass.column_names.include?(column_name.to_s)
-            raise InvalidSort.new("Unknown column #{column_name}")
-          end
 
-          # 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]
+      if relation.macro == :has_many || relation.macro == :has_and_belongs_to_many
+        options = [options] if !options.is_a?(Array)
+
+        options.each do |order|
+          Array(order).each do |column_name, options|
+            # LEFT JOIN the collection, group by this table's primary key —
+            # so rows don't fan / duplicate and records with an empty
+            # collection still appear — and order by an aggregate of the
+            # requested column:
+            #
+            #   SELECT properties.*
+            #   FROM properties
+            #   LEFT JOIN properties_tags ON properties_tags.property_id = properties.id
+            #   LEFT JOIN tags ON tags.id = properties_tags.tag_id
+            #   GROUP BY properties.id
+            #   ORDER BY MIN(tags.name) ASC
+            #
+            # Ascending keys each record by its smallest member (MIN),
+            # descending by its largest (MAX) — the member you'd expect to
+            # see first in that direction. Toggling asc/desc therefore
+            # re-keys multi-value records rather than strictly reversing
+            # the list.
+            column = Arel::Attributes::Relation.new(relation.klass.arel_table[column_name], relation.name)
+            direction, nulls = sort_direction_and_nulls(options)
+
+            order = if direction == :desc
+              Arel::Nodes::Descending.new(column.maximum, nulls)
+            elsif direction == :asc
+              Arel::Nodes::Ascending.new(column.minimum, nulls)
+            else
+              raise ActiveRecord::StatementInvalid.new("Unkown ordering #{direction}")
+            end
+
+            resource = resource.left_outer_joins(relation.name)
+            resource = resource.order(order)
           end
-
-          direction, nulls = sort_direction_and_nulls(column_options)
-
-          order = if direction == 'desc'
-            Arel::Nodes::Descending.new(column.maximum, nulls)
-          elsif direction == 'asc'
-            Arel::Nodes::Ascending.new(column.minimum, nulls)
-          else
-            raise InvalidSort.new("Unknown ordering #{direction}")
+        end
+      elsif relation.macro == :belongs_to || relation.macro == :has_one
+        options = [options] if !options.is_a?(Array)
+
+        options.each do |order|
+          order = Array(order)
+          order.each do |column, options|
+            column = relation.klass.arel_table[column]
+            direction, nulls = sort_direction_and_nulls(options)
+
+            if direction == :desc
+              order = Arel::Nodes::Descending.new(column.maximum, nulls)
+            elsif direction == :asc
+              order = Arel::Nodes::Ascending.new(column.minimum, nulls)
+            else
+              raise ActiveRecord::StatementInvalid.new("Unkown ordering #{direction}")
+            end
+
+            resource = resource.left_outer_joins(relation.name)
+            resource = resource.order(order)
           end
-
-          resource = resource.left_outer_joins(relation.name)
-          resource = resource.order(order)
         end
       end
 
-      # Group by the primary key so the aggregate collapses the joined,
-      # fanned-out rows to one per record. Every relation sort adds this,
-      # so only add it once: ActiveRecord < 8.1's group! appends rather
-      # than unioning, which would leave a duplicate [pk, pk] that trips
-      # the count override's group_values check below.
-      # TODO: once Rails <= 8.0 is no longer supported, group! unions on
-      # its own — drop the include? guard and just group(primary_key).
-      primary_key = klass.arel_table[klass.primary_key]
-      resource = resource.group(primary_key) unless resource.group_values.include?(primary_key)
+      resource = resource.group(klass.arel_table[klass.primary_key])
       # Tag the relation for the count override below. Chained relations
       # are built with clone, which copies instance variables, so the tag
       # survives further chaining.

data/lib/active_record/sort/version.rb

@@ -1,7 +1,5 @@
-# frozen_string_literal: true
-
 module ActiveRecord
   module Sort
-    VERSION = '8.0.1'
+    VERSION = '10.0.0.rc1'
   end
 end

data/lib/active_record/sort.rb

@@ -1,9 +1,6 @@
-# frozen_string_literal: true
-
 require 'active_record'
 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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-sort
 version: !ruby/object:Gem::Version
-  version: 8.0.1
+  version: 10.0.0.rc1
 platform: ruby
 authors:
 - Jon Bracy
@@ -15,34 +15,28 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 8.0.0
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '9.0'
+        version: '7.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 8.0.0
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '9.0'
+        version: '7.1'
 - !ruby/object:Gem::Dependency
   name: arel-extensions
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 9.0.0
+        version: 6.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 9.0.0
+        version: 6.1.0
 - !ruby/object:Gem::Dependency
   name: pg
   requirement: !ruby/object:Gem::Requirement
@@ -57,6 +51,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -133,14 +141,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 7.0.0
+        version: 6.1.0.2
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 7.0.0
+        version: 6.1.0.2
 - !ruby/object:Gem::Dependency
   name: webmock
   requirement: !ruby/object:Gem::Requirement
@@ -169,14 +177,14 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: 'Adds a #sort query method to ActiveRecord that turns whitelisted user-supplied
-  parameters into ORDER BY clauses -- ordering by columns or associations, ascending/descending,
-  with NULLS handling and random ordering -- without exposing you to SQL injection.'
+description: A safe way to accept user parameters and order against your ActiveRecord
+  Models
 email:
 - jonbracy@gmail.com
 executables: []
 extensions: []
-extra_rdoc_files: []
+extra_rdoc_files:
+- README.md
 files:
 - CHANGELOG.md
 - LICENSE
@@ -187,11 +195,10 @@ files:
 homepage: https://github.com/malomalo/activerecord-sort
 licenses:
 - MIT
-metadata:
-  source_code_uri: https://github.com/malomalo/activerecord-sort
-  changelog_uri: https://github.com/malomalo/activerecord-sort/blob/master/CHANGELOG.md
-  rubygems_mfa_required: 'true'
-rdoc_options: []
+metadata: {}
+rdoc_options:
+- "--main"
+- README.md
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
@@ -205,7 +212,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.11
+rubygems_version: 4.0.2
 specification_version: 4
 summary: A safe way to accept user parameters and order against your ActiveRecord
   Models