toller 1.0.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 565b78efab21039ddd7025adad94e0ac2e045943acef17e97374aac58b0b3b10
-  data.tar.gz: a73035fb270e002dfd8cfe8ed38dff7317dbbf033e4aac922e5b409fc9aad92b
+  metadata.gz: 14ead1892ebc47f8a2dc0ee254545de4a013e7140d738654b9ad42dfd5c05799
+  data.tar.gz: 39fa2fa6acd9fed9e002b78f020e3b95ed89a920384481b24271b1898f955057
 SHA512:
-  metadata.gz: b6a9f24aeec9383b065c39c3430c63ab90bd75cd963b414418e552d3fdd22a151e0c1da7ece697c92116958d294781c83330145889266d6be739e7ba2698b78a
-  data.tar.gz: b816afc011e2070a7adfeee999702ecdf2ca04af45e50a4ec7966d98ef1fd5486aaa1bcffd4c48a443db9aafdc43a60c5679c7b4dd20e5ff918304b6b38232bd
+  metadata.gz: 71f8f591c8b0d40a0e67cacfb3e9953d4a47d9ad8a542f7327f05e67f6deec12c1a8580547a47acf5d9851c016cae0588e0f20d62c1ae93245d1c0ade14b8807
+  data.tar.gz: 128e6e2f34d0bf6381b57987d73d485eeeb70628c96aba9ce557ba251395e9cfc96c5b12bb6b23f1546c822642af46ca8260a6ea5b46390f2840a9090c970697

data/README.md

@@ -16,7 +16,7 @@ See the [wiki](https://github.com/dfreerksen/toller/wiki) for usage information.
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'toller', '~> 1.0'
+gem 'toller', '~> 1.2'
 ```
 
 And then execute:
@@ -64,7 +64,7 @@ To run tests with Appraisal, run
 $ bundle exec appraisal rspec
 ```
 
-`-n 1` forces Appraisal2 to run one Rails version at a time. Without it, Appraisal2 defaults to running 2 appraisals in parallel, and since every appraisal shares the same `test/dummy/db/test.sqlite3` file, concurrent runs can intermittently fail with `SQLite3::BusyException: database is locked`.
+Without any flags, Appraisal2 defaults to running 2 appraisals in parallel. The test database is in-memory (`database: ":memory:"`), so each appraisal subprocess gets its own isolated database and parallel runs don't conflict. Pass `-n 1` to force one Rails version at a time instead.
 
 ```bash
 $ bundle exec appraisal rails-6-0 rspec

data/lib/toller/filter.rb

@@ -21,7 +21,10 @@ module Toller
     # @option options [Boolean] :default whether this filter applies automatically when no filter params were sent
     # @option options [Symbol] :scope_name for type: :scope, the model scope to call; defaults to +parameter+
     # @return [Toller::Filter] a new instance of Filter
+    # @raise [ArgumentError] if +type+ isn't one of {Toller::VALID_TYPES}
     def initialize(parameter, type, options)
+      validate_type!(parameter, type)
+
       @parameter = parameter
       @type = type
       @properties = options.reverse_merge(
@@ -42,7 +45,7 @@ module Toller
       if type == :scope
         Filters::ScopeHandler.new.call(collection, value, properties)
       else
-        Filters::WhereHandler.new.call(collection, type, value, properties)
+        Filters::ColumnHandler.new.call(collection, type, value, properties)
       end
     end
 
@@ -51,5 +54,19 @@ module Toller
     def default
       properties[:default]
     end
+
+    private
+
+    ##
+    # @param parameter [Symbol] the public filter param name, used in the error message
+    # @param type [Symbol] the filter type to validate
+    # @return [nil]
+    # @raise [ArgumentError] if +type+ isn't one of {Toller::VALID_TYPES}
+    def validate_type!(parameter, type)
+      return if Toller::VALID_TYPES.include?(type)
+
+      raise ArgumentError, "Toller: unknown type `#{type.inspect}` for filter `#{parameter}` " \
+                           "(expected one of #{Toller::VALID_TYPES.join(', ')})"
+    end
   end
 end

data/lib/toller/filters/{where_handler.rb → column_handler.rb}

@@ -4,19 +4,26 @@ module Toller
   # :nodoc:
   module Filters
     ##
-    # Where handler for filter
-    class WhereHandler
+    # Column handler for filter
+    class ColumnHandler
       ##
       # Applies a plain `where` clause to +collection+ for a non-scope filter.
       #
+      # If +field+ isn't a real column on the collection's model, or the column's actual type
+      # doesn't match the declared `type:`, the filter is logged and skipped instead of raising
+      # (or silently applying a mismatched mutator) once the relation is evaluated.
+      #
       # @param collection [ActiveRecord::Relation] the collection to filter
       # @param type [Symbol] the filter type (e.g. :string, :integer, :boolean)
       # @param value [Object] the raw filter param value
       # @param properties [Hash] the filter's properties, used to resolve `:field`
-      # @return [ActiveRecord::Relation] the filtered collection
+      # @return [ActiveRecord::Relation] the filtered collection, or +collection+ unchanged if `:field` is
+      #                                  unknown or its actual column type doesn't match `type`
       def call(collection, type, value, properties)
         field_name = properties[:field]
 
+        return collection unless resolvable_column?(collection, field_name, type)
+
         mutated_value = value_mutator(type, value)
 
         collection.where(field_name => mutated_value)
@@ -24,6 +31,29 @@ module Toller
 
       private
 
+      ##
+      # Confirms +field_name+ is a real column on +collection+'s model whose actual type matches
+      # +type+, logging a warning and returning false otherwise.
+      #
+      # @param collection [ActiveRecord::Relation] the collection to filter
+      # @param field_name [Symbol] the column to look up
+      # @param type [Symbol] the filter's declared type
+      # @return [Boolean] whether +field_name+ exists and its actual column type matches +type+
+      def resolvable_column?(collection, field_name, type)
+        unless collection.klass.column_names.include?(field_name.to_s)
+          Rails.logger.warn("[Toller] Skipping filter: #{collection.klass} has no column `#{field_name}`")
+          return false
+        end
+
+        actual_type = collection.klass.columns_hash[field_name.to_s].type
+        return true if actual_type == type
+
+        Rails.logger.warn(
+          "[Toller] Skipping filter: #{collection.klass}##{field_name} is `#{actual_type}`, declared as `#{type}`"
+        )
+        false
+      end
+
       ##
       # Value mutator
       #

data/lib/toller/filters/mutators/boolean.rb

@@ -16,7 +16,7 @@ module Toller
         # @param value [String] the raw filter param value
         # @return [Boolean] true if +value+ is one of "1", "t", "true", "y", "yes"; false otherwise
         def call(value)
-          %w[1 t true y yes].include?(value)
+          %w[1 t true y yes].include?(value.to_s.downcase)
         end
       end
     end

data/lib/toller/filters/mutators/common/range.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Toller
+  # :nodoc:
+  module Filters
+    # :nodoc:
+    module Mutators
+      # :nodoc:
+      module Common
+        ##
+        # Shared range-parsing behavior for filter mutators. Extend this module to get a
+        # `call(value)` that returns +value+ unchanged, or a Range when +value+ contains
+        # Ruby range syntax (`..` for inclusive, `...` for exclusive).
+        #
+        # Methods here must refer to Ruby's core Range class as `::Range` - a bare
+        # `Range` would resolve to this module (Mutators::Common::Range) instead, since
+        # Ruby's constant lookup checks the lexical scope before the top level.
+        module Range
+          ##
+          # Coerces a raw filter param into its original value or a Range.
+          #
+          # @param value [String] the raw filter param value
+          # @return [String,::Range] the original value, or a Range when the value contains range syntax
+          #                          (`..` or `...`)
+          def call(value)
+            range_dots = inclusive_or_exclusive_range(value)
+
+            return value if range_dots.blank?
+
+            range(value, range_dots)
+          end
+
+          ##
+          # Builds a Range by splitting +value+ on the given range dots.
+          #
+          # @param value [String] the raw range string, e.g. "1..10"
+          # @param dots [String] the range separator, either ".." or "..."
+          # @return [::Range] the resulting range, exclusive when +dots+ is "..."
+          def range(value, dots)
+            ::Range.new(*value.split(dots), dots == "...")
+          end
+
+          ##
+          # Detects whether +value+ contains inclusive or exclusive range syntax.
+          #
+          # @param value [String] the raw filter param value
+          # @return [String,nil] "..." for an exclusive range, ".." for an inclusive range, or nil if +value+ is not
+          #                      a range
+          def inclusive_or_exclusive_range(value)
+            return "..." if value.include?("...")
+            return ".." if value.include?("..")
+
+            nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/toller/filters/mutators/date.rb

@@ -8,43 +8,7 @@ module Toller
       ##
       # Date filter mutator
       module Date
-        module_function
-
-        ##
-        # Coerces a raw filter param into a date value or range.
-        #
-        # @param value [String] the raw filter param value
-        # @return [String,Range] the original value, or a Range when the value contains range syntax (`..` or `...`)
-        def call(value)
-          range_dots = inclusive_or_exclusive_range(value)
-
-          return value if range_dots.blank?
-
-          range(value, range_dots)
-        end
-
-        ##
-        # Builds a Range by splitting +value+ on the given range dots.
-        #
-        # @param value [String] the raw range string, e.g. "2024-01-01..2024-12-31"
-        # @param dots [String] the range separator, either ".." or "..."
-        # @return [Range] the resulting range
-        def range(value, dots)
-          Range.new(*value.split(dots))
-        end
-
-        ##
-        # Detects whether +value+ contains inclusive or exclusive range syntax.
-        #
-        # @param value [String] the raw filter param value
-        # @return [String,nil] "..." for an exclusive range, ".." for an inclusive range, or nil if +value+ is not
-        #                      a range
-        def inclusive_or_exclusive_range(value)
-          return "..." if value.include?("...")
-          return ".." if value.include?("..")
-
-          nil
-        end
+        extend Common::Range
       end
     end
   end

data/lib/toller/filters/mutators/datetime.rb

@@ -8,43 +8,7 @@ module Toller
       ##
       # Datetime filter mutator
       module Datetime
-        module_function
-
-        ##
-        # Coerces a raw filter param into a datetime value or range.
-        #
-        # @param value [String] the raw filter param value
-        # @return [String,Range] the original value, or a Range when the value contains range syntax (`..` or `...`)
-        def call(value)
-          range_dots = inclusive_or_exclusive_range(value)
-
-          return value if range_dots.blank?
-
-          range(value, range_dots)
-        end
-
-        ##
-        # Builds a Range by splitting +value+ on the given range dots.
-        #
-        # @param value [String] the raw range string, e.g. "2024-01-01..2024-12-31"
-        # @param dots [String] the range separator, either ".." or "..."
-        # @return [Range] the resulting range
-        def range(value, dots)
-          Range.new(*value.split(dots))
-        end
-
-        ##
-        # Detects whether +value+ contains inclusive or exclusive range syntax.
-        #
-        # @param value [String] the raw filter param value
-        # @return [String,nil] "..." for an exclusive range, ".." for an inclusive range, or nil if +value+ is not
-        #                      a range
-        def inclusive_or_exclusive_range(value)
-          return "..." if value.include?("...")
-          return ".." if value.include?("..")
-
-          nil
-        end
+        extend Common::Range
       end
     end
   end

data/lib/toller/filters/mutators/integer.rb

@@ -8,51 +8,7 @@ module Toller
       ##
       # Integer filter mutator
       module Integer
-        module_function
-
-        ##
-        # Coerces a raw filter param into an integer value or range.
-        #
-        # @param value [String] the raw filter param value
-        # @return [String, Range] the original value, or a Range when the value contains range syntax (`..` or `...`)
-        def call(value)
-          return value unless range?(value)
-
-          range(value)
-        end
-
-        ##
-        # Checks whether +value+ contains range syntax.
-        #
-        # @param value [String] the raw filter param value
-        # @return [Boolean] true if +value+ contains `..` or `...`
-        def range?(value)
-          range_dots = inclusive_or_exclusive_range(value)
-
-          range_dots.present?
-        end
-
-        ##
-        # Builds a Range by splitting +value+ on its range dots.
-        #
-        # @param value [String] the raw range string, e.g. "1..10"
-        # @return [Range] the resulting range
-        def range(value)
-          Range.new(*value.split(inclusive_or_exclusive_range(value)))
-        end
-
-        ##
-        # Detects whether +value+ contains inclusive or exclusive range syntax.
-        #
-        # @param value [String] the raw filter param value
-        # @return [String,nil] "..." for an exclusive range, ".." for an inclusive range, or nil if +value+ is not
-        #                      a range
-        def inclusive_or_exclusive_range(value)
-          return "..." if value.include?("...")
-          return ".." if value.include?("..")
-
-          nil
-        end
+        extend Common::Range
       end
     end
   end

data/lib/toller/filters/mutators/time.rb

@@ -8,43 +8,7 @@ module Toller
       ##
       # Time filter mutator
       module Time
-        module_function
-
-        ##
-        # Coerces a raw filter param into a time value or range.
-        #
-        # @param value [String] the raw filter param value
-        # @return [String,Range] the original value, or a Range when the value contains range syntax (`..` or `...`)
-        def call(value)
-          range_dots = inclusive_or_exclusive_range(value)
-
-          return value if range_dots.blank?
-
-          range(value, range_dots)
-        end
-
-        ##
-        # Builds a Range by splitting +value+ on the given range dots.
-        #
-        # @param value [String] the raw range string, e.g. "09:00..17:00"
-        # @param dots [String] the range separator, either ".." or "..."
-        # @return [Range] the resulting range
-        def range(value, dots)
-          Range.new(*value.split(dots))
-        end
-
-        ##
-        # Detects whether +value+ contains inclusive or exclusive range syntax.
-        #
-        # @param value [String] the raw filter param value
-        # @return [String,nil] "..." for an exclusive range, ".." for an inclusive range, or nil if +value+ is not
-        #                      a range
-        def inclusive_or_exclusive_range(value)
-          return "..." if value.include?("...")
-          return ".." if value.include?("..")
-
-          nil
-        end
+        extend Common::Range
       end
     end
   end

data/lib/toller/filters/scope_handler.rb

@@ -9,13 +9,21 @@ module Toller
       ##
       # Applies a named scope to +collection+ for a `type: :scope` filter.
       #
+      # If the resolved scope doesn't exist on the collection's model, the
+      # filter is logged and skipped instead of raising a NoMethodError.
+      #
       # @param collection [ActiveRecord::Relation] the collection to filter
       # @param value [Object] the filter param value to pass to the scope
       # @param properties [Hash] the filter's properties, used to resolve `:scope_name` (falling back to `:field`)
-      # @return [ActiveRecord::Relation] the scoped collection
+      # @return [ActiveRecord::Relation] the scoped collection, or +collection+ unchanged if the scope is unknown
       def call(collection, value, properties)
         scoped_name = properties[:scope_name] || properties[:field]
 
+        unless ScopeResolver.own_class_method?(collection.klass, scoped_name)
+          Rails.logger.warn("[Toller] Skipping filter: #{collection.klass} has no scope `#{scoped_name}`")
+          return collection
+        end
+
         collection.public_send(scoped_name, value)
       end
     end

data/lib/toller/retriever.rb

@@ -50,9 +50,9 @@ module Toller
     def filter
       active_retrievals.reduce(collection) do |items, retrieval|
         param_value = if retrieval.is_a?(Filter)
-                        filter_params.fetch(retrieval.parameter, nil)
+                        filter_params.fetch(downcased_parameter(retrieval), nil)
                       else
-                        sort_params.include?("-#{retrieval.parameter}") ? :desc : :asc
+                        sort_params.include?("-#{downcased_parameter(retrieval)}") ? :desc : :asc
                       end
 
         retrieval.apply!(items, param_value)
@@ -75,7 +75,7 @@ module Toller
     def filtering_activated?(retrieval)
       return true if filter_params.blank? && retrieval.default
 
-      filter_params.fetch(retrieval.parameter, nil).present?
+      filter_params.fetch(downcased_parameter(retrieval), nil).present?
     end
 
     ##
@@ -84,9 +84,19 @@ module Toller
     def sorting_activated?(retrieval)
       return true if sort_params.blank? && retrieval.default
 
-      string_parameter = retrieval.parameter.to_s
+      string_parameter = downcased_parameter(retrieval)
 
       sort_params.include?(string_parameter) || sort_params.include?("-#{string_parameter}")
     end
+
+    ##
+    # `filter_params`/`sort_params` are downcased at the request level, so `retrieval.parameter`
+    # (declared as-is by `filter_on`/`sort_on`) must be downcased the same way before comparison.
+    #
+    # @param retrieval [Toller::Filter,Toller::Sort] the filter/sort to check
+    # @return [String] +retrieval.parameter+ downcased
+    def downcased_parameter(retrieval)
+      retrieval.parameter.to_s.downcase
+    end
   end
 end

data/lib/toller/scope_resolver.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Toller
+  ##
+  # Shared lookup used by the `type: :scope` filter/sort handlers to confirm a resolved
+  # `scope_name`/`field` is actually declared on the model (a real `scope`, or a plain
+  # `def self.foo`), rather than a method inherited from ActiveRecord itself. Without this,
+  # a typo'd `scope_name:` that happens to collide with a built-in ActiveRecord class method
+  # (`delete_all`, `where`, `sum`, etc.) would silently `public_send` it with the raw request
+  # value instead of being treated as an unresolvable scope.
+  module ScopeResolver
+    module_function
+
+    ##
+    # @param klass [Class] the ActiveRecord model class to check
+    # @param name [Symbol,String] the method name to look for
+    # @return [Boolean] whether +name+ is defined by +klass+ or one of its own ancestors,
+    #                   rather than inherited from ActiveRecord::Base itself
+    def own_class_method?(klass, name)
+      klass.singleton_class.ancestors
+           .take_while { |mod| mod != ActiveRecord::Base.singleton_class }
+           .any? { |mod| mod.public_method_defined?(name.to_sym, false) }
+    end
+  end
+end

data/lib/toller/sort.rb

@@ -21,7 +21,10 @@ module Toller
     # @option options [Boolean] :default whether this sort applies automatically when no sort params were sent
     # @option options [Symbol] :scope_name for type: :scope, the model scope to call; defaults to +parameter+
     # @return [Toller::Sort] a new instance of Sort
+    # @raise [ArgumentError] if +type+ isn't one of {Toller::VALID_TYPES}
     def initialize(parameter, type, options)
+      validate_type!(parameter, type)
+
       @parameter = parameter
       @type = type
       @properties = options.reverse_merge(
@@ -42,7 +45,7 @@ module Toller
       if type == :scope
         Sorts::ScopeHandler.new.call(collection, direction, properties)
       else
-        Sorts::OrderHandler.new.call(collection, direction, properties)
+        Sorts::ColumnHandler.new.call(collection, type, direction, properties)
       end
     end
 
@@ -51,5 +54,19 @@ module Toller
     def default
       properties[:default]
     end
+
+    private
+
+    ##
+    # @param parameter [Symbol] the public sort param name, used in the error message
+    # @param type [Symbol] the sort type to validate
+    # @return [nil]
+    # @raise [ArgumentError] if +type+ isn't one of {Toller::VALID_TYPES}
+    def validate_type!(parameter, type)
+      return if Toller::VALID_TYPES.include?(type)
+
+      raise ArgumentError, "Toller: unknown type `#{type.inspect}` for sort `#{parameter}` " \
+                           "(expected one of #{Toller::VALID_TYPES.join(', ')})"
+    end
   end
 end

data/lib/toller/sorts/column_handler.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Toller
+  # :nodoc:
+  module Sorts
+    ##
+    # Column handler for filter
+    class ColumnHandler
+      ##
+      # Applies a plain `order` clause to +collection+ for a non-scope sort.
+      #
+      # If +field+ isn't a real column on the collection's model, or the column's actual type
+      # doesn't match the declared `type:`, the sort is logged and skipped instead of raising
+      # once the relation is evaluated.
+      #
+      # @param collection [ActiveRecord::Relation] the collection to sort
+      # @param type [Symbol] the sort type (e.g. :string, :integer, :boolean)
+      # @param direction [Symbol] the sort direction, :asc or :desc
+      # @param properties [Hash] the sort's properties, used to resolve `:field`
+      # @return [ActiveRecord::Relation] the sorted collection, or +collection+ unchanged if `:field` is
+      #                                  unknown or its actual column type doesn't match `type`
+      def call(collection, type, direction, properties)
+        field_name = properties[:field]
+
+        return collection unless resolvable_column?(collection, field_name, type)
+
+        collection.order(field_name => direction)
+      end
+
+      private
+
+      ##
+      # Confirms +field_name+ is a real column on +collection+'s model whose actual type matches
+      # +type+, logging a warning and returning false otherwise.
+      #
+      # @param collection [ActiveRecord::Relation] the collection to sort
+      # @param field_name [Symbol] the column to look up
+      # @param type [Symbol] the sort's declared type
+      # @return [Boolean] whether +field_name+ exists and its actual column type matches +type+
+      def resolvable_column?(collection, field_name, type)
+        unless collection.klass.column_names.include?(field_name.to_s)
+          Rails.logger.warn("[Toller] Skipping sort: #{collection.klass} has no column `#{field_name}`")
+          return false
+        end
+
+        actual_type = collection.klass.columns_hash[field_name.to_s].type
+        return true if actual_type == type
+
+        Rails.logger.warn(
+          "[Toller] Skipping sort: #{collection.klass}##{field_name} is `#{actual_type}`, declared as `#{type}`"
+        )
+        false
+      end
+    end
+  end
+end

data/lib/toller/sorts/scope_handler.rb

@@ -9,13 +9,21 @@ module Toller
       ##
       # Applies a named scope to +collection+ for a `type: :scope` sort.
       #
+      # If the resolved scope doesn't exist on the collection's model, the
+      # sort is logged and skipped instead of raising a NoMethodError.
+      #
       # @param collection [ActiveRecord::Relation] the collection to sort
       # @param direction [Symbol] the sort direction, :asc or :desc, passed to the scope
       # @param properties [Hash] the sort's properties, used to resolve `:scope_name` (falling back to `:field`)
-      # @return [ActiveRecord::Relation] the scoped collection
+      # @return [ActiveRecord::Relation] the scoped collection, or +collection+ unchanged if the scope is unknown
       def call(collection, direction, properties)
         scoped_name = properties[:scope_name] || properties[:field]
 
+        unless ScopeResolver.own_class_method?(collection.klass, scoped_name)
+          Rails.logger.warn("[Toller] Skipping sort: #{collection.klass} has no scope `#{scoped_name}`")
+          return collection
+        end
+
         collection.public_send(scoped_name, direction)
       end
     end

data/lib/toller/version.rb

@@ -2,5 +2,5 @@
 
 module Toller
   # @return [String] the current gem version
-  VERSION = "1.0.0"
+  VERSION = "1.2.0"
 end

data/lib/toller.rb

@@ -1,16 +1,18 @@
 # frozen_string_literal: true
 
 require "toller/filter"
+require "toller/filters/column_handler"
 require "toller/filters/mutators/boolean"
+require "toller/filters/mutators/common/range"
 require "toller/filters/mutators/date"
 require "toller/filters/mutators/datetime"
 require "toller/filters/mutators/integer"
 require "toller/filters/mutators/time"
 require "toller/filters/scope_handler"
-require "toller/filters/where_handler"
 require "toller/retriever"
+require "toller/scope_resolver"
 require "toller/sort"
-require "toller/sorts/order_handler"
+require "toller/sorts/column_handler"
 require "toller/sorts/scope_handler"
 
 ##
@@ -20,6 +22,21 @@ require "toller/sorts/scope_handler"
 module Toller
   extend ActiveSupport::Concern
 
+  # @return [Array<Symbol>] the types `filter_on`/`sort_on` recognize for their `type:` option
+  VALID_TYPES = %i[string text integer boolean date datetime time scope].freeze
+
+  ##
+  # Coerces a raw string value into a boolean, using the same rule Toller's
+  # own `type: :boolean` filters use internally. Handy inside a model scope
+  # backing a `type: :scope` filter, which receives the raw param value
+  # unmutated.
+  #
+  # @param value [String] the raw value
+  # @return [Boolean] true if +value+ is one of "1", "t", "true", "y", "yes"; false otherwise
+  def self.truthy(value)
+    Filters::Mutators::Boolean.call(value)
+  end
+
   ##
   # Applies every active filter/sort for the current request to +collection+.
   #
@@ -65,15 +82,19 @@ module Toller
   end
 
   ##
+  # Filter params
+  #
   # @return [Hash] the current request's filter params, keyed by filter parameter name
   def filter_params
-    params.fetch(filter_param_key.to_sym, {})
+    params.fetch(filter_param_key.to_sym, {}).transform_keys { |key| key.to_s.strip.downcase }
   end
 
   ##
+  # Sort param split
+  #
   # @return [Array<String>] the current request's sort params, e.g. ['-published_at', 'title']
   def sort_params
-    params.fetch(sort_param_key.to_sym, "").split(",")
+    params.fetch(sort_param_key.to_sym, "").split(",").map { |param| param.strip.downcase }.reject(&:empty?)
   end
 
   ##

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: toller
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.2.0
 platform: ruby
 authors:
 - David Freerksen
@@ -37,16 +37,18 @@ files:
 - Rakefile
 - lib/toller.rb
 - lib/toller/filter.rb
+- lib/toller/filters/column_handler.rb
 - lib/toller/filters/mutators/boolean.rb
+- lib/toller/filters/mutators/common/range.rb
 - lib/toller/filters/mutators/date.rb
 - lib/toller/filters/mutators/datetime.rb
 - lib/toller/filters/mutators/integer.rb
 - lib/toller/filters/mutators/time.rb
 - lib/toller/filters/scope_handler.rb
-- lib/toller/filters/where_handler.rb
 - lib/toller/retriever.rb
+- lib/toller/scope_resolver.rb
 - lib/toller/sort.rb
-- lib/toller/sorts/order_handler.rb
+- lib/toller/sorts/column_handler.rb
 - lib/toller/sorts/scope_handler.rb
 - lib/toller/version.rb
 homepage: https://github.com/dfreerksen/toller

data/lib/toller/sorts/order_handler.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module Toller
-  # :nodoc:
-  module Sorts
-    ##
-    # Order handler for filter
-    class OrderHandler
-      ##
-      # Applies a plain `order` clause to +collection+ for a non-scope sort.
-      #
-      # @param collection [ActiveRecord::Relation] the collection to sort
-      # @param direction [Symbol] the sort direction, :asc or :desc
-      # @param properties [Hash] the sort's properties, used to resolve `:field`
-      # @return [ActiveRecord::Relation] the sorted collection
-      def call(collection, direction, properties)
-        field_name = properties[:field]
-
-        collection.order(field_name => direction)
-      end
-    end
-  end
-end