procore-sift 0.12.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: edabe4ead843ee8dd551b70d2408899b88dca98d
+  data.tar.gz: bbc128cae2da284235591505bfb60a4f7fcc3e93
+SHA512:
+  metadata.gz: 5b699d7819a4ab9e29cedc03ccc26fa113e5603abff8c7e700421ecf2eca79bdd25b65c726898ef5e9018b57ca68e1ca4dfb10b7d13589dd71854e6b90d4391f
+  data.tar.gz: c5bec1b452aa2bf55192602c0316d367d044c32224b8c77d0db41eb6e2508a4725c325d024711e0e39f66d52a83548ffcab74823d781126555f4bcf45ba098b9

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2016 Adam Hess
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,261 @@
+# Sift
+
+[![Build Status](https://travis-ci.org/procore/sift.svg?branch=master)](https://travis-ci.org/procore/sift)
+
+A tool to build your own filters and sorts with Rails and Active Record!
+
+## Developer Usage
+Include Sift in your controllers, and define some filters.
+
+```ruby
+class PostsController < ApplicationController
+  include Sift
+
+  filter_on :title, type: :string
+
+  def index
+    render json: filtrate(Post.all)
+  end
+end
+```
+
+This will allow users to pass `?filters[title]=foo` and get the `Post`s with the title `foo`.
+
+Sift will also handle rendering errors using the standard rails errors structure. You can add this to your controller by adding,
+
+```ruby
+before_action :render_filter_errors, unless: :filters_valid?
+
+def render_filter_errors
+  render json: { errors: filter_errors } and return
+end
+```
+
+to your controller.
+
+These errors are based on the type that you told sift your param was.
+
+### Filter Types
+Every filter must have a type, so that Sift knows what to do with it. The current valid filter types are:
+* int - Filter on an integer column
+* decimal - Filter on a decimal column
+* boolean - Filter on a boolean column
+* string - Filter on a string column
+* text - Filter on a text column
+* date - Filter on a date column
+* time - Filter on a time column
+* datetime - Filter on a datetime column
+* scope - Filter on an ActiveRecord scope
+
+### Filter on Scopes
+Just as your filter values are used to scope queries on a column, values you
+pass to a scope filter will be used as arguments to that scope. For example:
+
+```ruby
+class Post < ActiveRecord::Base
+  scope :with_body, ->(text) { where(body: text) }
+end
+
+class PostsController < ApplicationController
+  include Sift
+
+  filter_on :with_body, type: :scope
+
+  def index
+    render json: filtrate(Post.all)
+  end
+end
+```
+
+Passing `?filters[with_body]=my_text` will call the `with_body` scope with
+`my_text` as the argument.
+
+Scopes that accept no arguments are currently not supported.
+
+#### Accessing Params with Filter Scopes
+
+Filters with `type: :scope` have access to the params hash by passing in the desired keys to the `scope_params`. The keys passed in will be returned as a hash with their associated values, and should always appear as the last argument in your scope.
+
+```ruby
+class Post < ActiveRecord::Base
+  scope :user_posts_on_date, ->(date, options) {
+    where(user_id: options[:user_id], blog_id: options[:blog_id], date: date)
+  }
+end
+
+class UsersController < ApplicationController
+  include Sift
+
+  filter_on :user_posts_on_date, type: :scope, scope_params: [:user_id, :blog_id]
+
+  def show
+    render json: filtrate(Post.all)
+  end
+end
+```
+Passing `?filters[user_posts_on_date]=10/12/20` will call the `user_posts_on_date` scope with
+`10/12/20` as the the first argument, and will grab the `user_id` and `blog_id` out of the params and pass them as a hash, as the second argument.
+
+### Renaming Filter Params
+
+A filter param can have a different field name than the column or scope. Use `internal_name` with the correct name of the column or scope.
+
+```ruby
+class PostsController < ApplicationController
+  include Sift
+
+  filter_on :post_id, type: :int, internal_name: :id
+
+end
+```
+
+### Filter on Ranges
+Some parameter types support ranges. Ranges are expected to be a string with the bounding values separated by `...`
+
+For example `?filters[price]=3...50` would return records with a price between 3 and 50.
+
+The following types support ranges
+* int
+* decimal
+* boolean
+* date
+* time
+* datetime
+
+### Filter on JSON Array
+`int` type filters support sending the values as an array in the URL Query parameters. For example `?filters[id]=[1,2]`. This is a way to keep payloads smaller for GET requests. When URI encoded this will become `filters%5Bid%5D=%5B1,2%5D` which is much smaller the standard format of `filters%5Bid%5D%5B%5D=1&&filters%5Bid%5D%5B%5D=2`.
+
+On the server side, the params will be received as:
+```ruby
+# JSON array encoded result
+"filters"=>{"id"=>"[1,2]"}
+
+# standard array format
+"filters"=>{"id"=>["1", "2"]}
+```
+
+Note that this feature cannot currently be wrapped in an array and should not be used in combination with sending array parameters individually.
+ * `?filters[id][]=[1,2]` => invalid
+ * `?filters[id][]=[1,2]&filters[id][]=3` => invalid
+ * `?filters[id]=[1,2]&filters[id]=3` => valid but only 3 is passed through to the server
+ * `?filters[id]=[1,2]` => valid
+
+#### A note on encoding for JSON Array feature
+JSON arrays contain the reserved characters "`,`" and "`[`" and "`]`". When encoding a JSON array in the URL there are two different ways to handle the encoding. Both ways are supported by Rails.
+For example, lets look at the following filter with a JSON array `?filters[id]=[1,2]`:
+ * `?filters%5Bid%5D=%5B1,2%5D`
+ * `?filters%5Bid%5D%3D%5B1%2C2%5D`
+
+In both cases Rails will correctly decode to the expected result of
+```ruby
+{ "filters" => { "id" => "[1,2]" } }
+```
+
+### Sort Types
+Every sort must have a type, so that Sift knows what to do with it. The current valid sort types are:
+* int - Sort on an integer column
+* decimal - Sort on a decimal column
+* string - Sort on a string column
+* text - Sort on a text column
+* date - Sort on a date column
+* time - Sort on a time column
+* datetime - Sort on a datetime column
+* scope - Sort on an ActiveRecord scope
+
+### Sort on Scopes
+Just as your sort values are used to scope queries on a column, values you
+pass to a scope sort will be used as arguments to that scope. For example:
+
+```ruby
+class Post < ActiveRecord::Base
+  scope :order_on_body_no_params, -> { order(body: :asc) }
+  scope :order_on_body, ->(direction) { order(body: direction) }
+  scope :order_on_body_then_id, ->(body_direction, id_direction) { order(body: body_direction).order(id: id_direction) }
+end
+
+class PostsController < ApplicationController
+  include Sift
+
+  sort_on :order_by_body_ascending, internal_name: :order_on_body_no_params, type: :scope
+  sort_on :order_by_body, internal_name: :order_on_body, type: :scope, scope_params: [:direction]
+  sort_on :order_by_body_then_id, internal_name: :order_on_body_then_id, type: :scope, scope_params: [:direction, :asc]
+
+
+  def index
+    render json: filtrate(Post.all)
+  end
+end
+```
+
+`scope_params` takes an order-specific array of the scope's arguments. Passing in the param :direction allows the consumer to choose which direction to sort in (ex. `-order_by_body` will sort `:desc` while `order_by_body` will sort `:asc`)
+
+Passing `?sort=-order_by_body` will call the `order_on_body` scope with
+`:desc` as the argument. The direction is the only argument that the consumer has control over.
+Passing `?sort=-order_by_body_then_id` will call the `order_on_body_then_id` scope where the `body_direction` is `:desc`, and the `id_direction` is `:asc`. Note: in this example the user has no control over id_direction. To demonstrate:
+Passing `?sort=order_by_body_then_id` will call the `order_on_body_then_id` scope where the `body_direction` this time is `:asc`, but the `id_direction` remains `:asc`.
+
+Scopes that accept no arguments are currently supported, but you should note that the user has no say in which direction it will sort on.
+
+`scope_params` can also accept symbols that are keys in the `params` hash. The value will be fetched and passed on as an argument to the scope.
+
+
+## Consumer Usage
+
+Filter:
+`?filters[<field_name>]=<value>`
+
+Filters are translated to Active Record `where`s and are chained together. The order they are applied is not guarenteed.
+
+Sort:
+`?sort=-published_at,position`
+
+Sort is translated to Active Record `order` The sorts are applied in the order they are passed by the client.
+the `-` symbol means to sort in `desc` order. By default, keys are sorted in `asc` order.
+
+## Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'procore-sift'
+```
+
+And then execute:
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+```bash
+$ gem install procore-sift
+```
+
+## Without Rails
+
+We have some future plans to remove the rails dependency so that other frameworks such as Sinatra could leverage this gem.
+
+## Contributing
+
+Running tests:
+```bash
+$ bundle exec rake test
+```
+
+## License
+
+The gem is available as open source under the terms of the [MIT
+License](http://opensource.org/licenses/MIT).
+
+## About Procore
+
+<img
+  src="https://www.procore.com/images/procore_logo.png"
+  alt="Procore Logo"
+  width="250px"
+/>
+
+The Procore Gem is maintained by Procore Technologies.
+
+Procore - building the software that builds the world.
+
+Learn more about the #1 most widely used construction management software at
+[procore.com](https://www.procore.com/)

data/Rakefile

@@ -0,0 +1,37 @@
+begin
+  require "bundler/setup"
+rescue LoadError
+  puts "You must `gem install bundler` and `bundle install` to run rake tasks"
+end
+
+require "bundler/gem_tasks"
+
+APP_RAKEFILE = File.expand_path("test/dummy/Rakefile", __dir__)
+load "rails/tasks/engine.rake"
+
+require "rdoc/task"
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = "rdoc"
+  rdoc.title    = "Sift"
+  rdoc.options << "--line-numbers"
+  rdoc.rdoc_files.include("README.md")
+  rdoc.rdoc_files.include("lib/**/*.rb")
+end
+
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "lib"
+  t.libs << "test"
+  t.pattern = "test/**/*_test.rb"
+  t.verbose = false
+end
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new(:rubocop) do |t|
+  t.options = ["--display-cop-names"]
+end
+
+task default: [:rubocop, :test]

data/lib/procore-sift.rb

@@ -0,0 +1,80 @@
+require "sift/filter"
+require "sift/filter_validator"
+require "sift/filtrator"
+require "sift/sort"
+require "sift/subset_comparator"
+require "sift/type_validator"
+require "sift/parameter"
+require "sift/value_parser"
+require "sift/scope_handler"
+require "sift/where_handler"
+require "sift/validators/valid_int_validator"
+require "sift/validators/valid_date_range_validator"
+
+module Sift
+  extend ActiveSupport::Concern
+
+  def filtrate(collection)
+    Filtrator.filter(collection, params, filters)
+  end
+
+  def filter_params
+    params.fetch(:filters, {})
+  end
+
+  def sort_params
+    params.fetch(:sort, "").split(",") if filters.any? { |filter| filter.is_a?(Sort) }
+  end
+
+  def filters_valid?
+    filter_validator.valid?
+  end
+
+  def filter_errors
+    filter_validator.errors.messages
+  end
+
+  private
+
+  def filter_validator
+    @_filter_validator ||= FilterValidator.build(
+      filters: filters,
+      sort_fields: self.class.sort_fields,
+      filter_params: filter_params,
+      sort_params: sort_params,
+    )
+  end
+
+  def filters
+    self.class.filters
+  end
+
+  def sorts_exist?
+    filters.any? { |filter| filter.is_a?(Sort) }
+  end
+
+  class_methods do
+    def filter_on(parameter, type:, internal_name: parameter, default: nil, validate: nil, scope_params: [])
+      filters << Filter.new(parameter, type, internal_name, default, validate, scope_params)
+    end
+
+    def filters
+      @_filters ||= []
+    end
+
+    # TODO: this is only used in tests, can I kill it?
+    def reset_filters
+      @_filters = []
+    end
+
+    def sort_fields
+      @_sort_fields ||= []
+    end
+
+    def sort_on(parameter, type:, internal_name: parameter, scope_params: [])
+      filters << Sort.new(parameter, type, internal_name, scope_params)
+      sort_fields << parameter.to_s
+      sort_fields << "-#{parameter}"
+    end
+  end
+end

data/lib/sift/filter.rb

@@ -0,0 +1,84 @@
+module Sift
+  # Filter describes the way a parameter maps to a database column
+  # and the type information helpful for validating input.
+  class Filter
+    attr_reader :parameter, :default, :custom_validate, :scope_params
+
+    def initialize(param, type, internal_name, default, custom_validate = nil, scope_params = [])
+      @parameter = Parameter.new(param, type, internal_name)
+      @default = default
+      @custom_validate = custom_validate
+      @scope_params = scope_params
+      raise ArgumentError, "scope_params must be an array of symbols" unless valid_scope_params?(scope_params)
+      raise "unknown filter type: #{type}" unless type_validator.valid_type?
+    end
+
+    def validation(_sort)
+      type_validator.validate
+    end
+
+    # rubocop:disable Lint/UnusedMethodArgument
+    def apply!(collection, value:, active_sorts_hash:, params: {})
+      if not_processable?(value)
+        collection
+      elsif should_apply_default?(value)
+        default.call(collection)
+      else
+        handler.call(collection, parameterize(value), params, scope_params)
+      end
+    end
+    # rubocop:enable Lint/UnusedMethodArgument
+
+    def always_active?
+      false
+    end
+
+    def validation_field
+      parameter.param
+    end
+
+    def type_validator
+      @type_validator ||= Sift::TypeValidator.new(param, type)
+    end
+
+    def type
+      parameter.type
+    end
+
+    def param
+      parameter.param
+    end
+
+    private
+
+    def parameterize(value)
+      ValueParser.new(value: value, type: parameter.type, options: parameter.parse_options).parse
+    end
+
+    def not_processable?(value)
+      value.nil? && default.nil?
+    end
+
+    def should_apply_default?(value)
+      value.nil? && !default.nil?
+    end
+
+    def mapped_scope_params(params)
+      scope_params.each_with_object({}) do |scope_param, hash|
+        hash[scope_param] = params.fetch(scope_param)
+      end
+    end
+
+    def valid_scope_params?(scope_params)
+      scope_params.is_a?(Array) && scope_params.all? { |symbol| symbol.is_a?(Symbol) }
+    end
+
+    def handler
+      parameter.handler
+    end
+
+    def supports_ranges?
+      parameter.supports_ranges?
+    end
+  end
+end

data/lib/sift/filter_validator.rb

@@ -0,0 +1,67 @@
+# Here be dragons:
+# there are two forms of metaprogramming in this file
+# instance variables are being dynamically set based on the param name
+# and we are class evaling `validates` to create dynamic validations
+# based on the filters being validated.
+module Sift
+  class FilterValidator
+    include ActiveModel::Validations
+
+    def self.build(filters:, sort_fields:, filter_params:, sort_params:)
+      unique_validations_filters = filters.uniq(&:validation_field)
+
+      klass = Class.new(self) do
+        def self.model_name
+          ActiveModel::Name.new(self, nil, "temp")
+        end
+
+        attr_accessor(*unique_validations_filters.map(&:validation_field))
+
+        unique_validations_filters.each do |filter|
+          if has_custom_validation?(filter, filter_params)
+            validate filter.custom_validate
+          elsif has_validation?(filter, filter_params, sort_fields)
+            validates filter.validation_field.to_sym, filter.validation(sort_fields)
+          end
+        end
+      end
+
+      klass.new(filters, filter_params: filter_params, sort_params: sort_params)
+    end
+
+    def self.has_custom_validation?(filter, filter_params)
+      filter_params[filter.validation_field] && filter.custom_validate
+    end
+
+    def self.has_validation?(filter, filter_params, sort_fields)
+      (filter_params[filter.validation_field] && filter.validation(sort_fields)) || filter.validation_field == :sort
+    end
+
+    def initialize(filters, filter_params:, sort_params:)
+      @filter_params = filter_params
+      @sort_params = sort_params
+
+      filters.each do |filter|
+        instance_variable_set("@#{filter.validation_field}", to_type(filter))
+      end
+    end
+
+    private
+
+    attr_reader(:filter_params, :sort_params)
+
+    def to_type(filter)
+      if filter.type == :boolean
+        if Rails.version.starts_with?("5")
+          ActiveRecord::Type::Boolean.new.cast(filter_params[filter.param])
+        else
+          ActiveRecord::Type::Boolean.new.type_cast_from_user(filter_params[filter.param])
+        end
+      elsif filter.validation_field == :sort
+        sort_params
+      else
+        filter_params[filter.param]
+      end
+    end
+  end
+end

data/lib/sift/filtrator.rb

@@ -0,0 +1,53 @@
+module Sift
+  # Filtrator takes a collection, params and a set of filters
+  # and applies them to create a new active record collection
+  # with those filters applied.
+  class Filtrator
+    attr_reader :collection, :params, :filters, :sort
+
+    def self.filter(collection, params, filters, sort = [])
+      new(collection, params, sort, filters).filter
+    end
+
+    def initialize(collection, params, _sort, filters = [])
+      @collection = collection
+      @params = params
+      @filters = filters
+      @sort = params.fetch(:sort, "").split(",") if filters.any? { |filter| filter.is_a?(Sort) }
+    end
+
+    def filter
+      active_filters.reduce(collection) do |col, filter|
+        apply(col, filter)
+      end
+    end
+
+    private
+
+    def apply(collection, filter)
+      filter.apply!(collection, value: filter_params[filter.param], active_sorts_hash: active_sorts_hash, params: params)
+    end
+
+    def filter_params
+      params.fetch(:filters, {})
+    end
+
+    def active_sorts_hash
+      active_sorts_hash = {}
+      Array(sort).each do |s|
+        if s.starts_with?("-")
+          active_sorts_hash[s[1..-1].to_sym] = :desc
+        else
+          active_sorts_hash[s.to_sym] = :asc
+        end
+      end
+      active_sorts_hash
+    end
+
+    def active_filters
+      filters.select do |filter|
+        filter_params[filter.param].present? || filter.default || filter.always_active?
+      end
+    end
+  end
+end

data/lib/sift/parameter.rb

@@ -0,0 +1,42 @@
+module Sift
+  # Value Object that wraps some handling of filter params
+  class Parameter
+    attr_reader :param, :type, :internal_name
+
+    def initialize(param, type, internal_name = param)
+      @param = param
+      @type = type
+      @internal_name = internal_name
+    end
+
+    def parse_options
+      {
+        supports_boolean: supports_boolean?,
+        supports_ranges: supports_ranges?,
+        supports_json: supports_json?
+      }
+    end
+
+    def handler
+      if type == :scope
+        ScopeHandler.new(self)
+      else
+        WhereHandler.new(self)
+      end
+    end
+
+    private
+
+    def supports_ranges?
+      ![:string, :text, :scope].include?(type)
+    end
+
+    def supports_json?
+      type == :int
+    end
+
+    def supports_boolean?
+      type == :boolean
+    end
+  end
+end

data/lib/sift/scope_handler.rb

@@ -0,0 +1,25 @@
+module Sift
+  class ScopeHandler
+    def initialize(param)
+      @param = param
+    end
+
+    def call(collection, value, params, scope_params)
+      collection.public_send(@param.internal_name, *scope_parameters(value, params, scope_params))
+    end
+
+    def scope_parameters(value, params, scope_params)
+      if scope_params.empty?
+        [value]
+      else
+        [value, mapped_scope_params(params, scope_params)]
+      end
+    end
+
+    def mapped_scope_params(params, scope_params)
+      scope_params.each_with_object({}) do |scope_param, hash|
+        hash[scope_param] = params.fetch(scope_param)
+      end
+    end
+  end
+end

data/lib/sift/sort.rb

@@ -0,0 +1,106 @@
+module Sift
+  # Sort provides the same interface as a filter,
+  # but instead of applying a `where` to the collection
+  # it applies an `order`.
+  class Sort
+    attr_reader :parameter, :scope_params
+
+    WHITELIST_TYPES = [:int,
+                       :decimal,
+                       :string,
+                       :text,
+                       :date,
+                       :time,
+                       :datetime,
+                       :scope].freeze
+
+    def initialize(param, type, internal_name = param, scope_params = [])
+      raise "unknown filter type: #{type}" unless WHITELIST_TYPES.include?(type)
+      raise "scope params must be an array" unless scope_params.is_a?(Array)
+      @parameter = Parameter.new(param, type, internal_name)
+      @scope_params = scope_params
+    end
+
+    def default
+      # TODO: we can support defaults here later
+      false
+    end
+
+    # rubocop:disable Lint/UnusedMethodArgument
+    # rubocop:disable Metrics/PerceivedComplexity
+    def apply!(collection, value:, active_sorts_hash:, params: {})
+      if type == :scope
+        if active_sorts_hash.keys.include?(param)
+          collection.public_send(internal_name, *mapped_scope_params(active_sorts_hash[param], params))
+        elsif default.present?
+          # Stubbed because currently Sift::Sort does not respect default
+          # default.call(collection)
+          collection
+        else
+          collection
+        end
+      elsif type == :string || type == :text
+        if active_sorts_hash.keys.include?(param)
+          collection.order("LOWER(#{internal_name}) #{individual_sort_hash(active_sorts_hash)[internal_name]}")
+        else
+          collection
+        end
+      else
+        collection.order(individual_sort_hash(active_sorts_hash))
+      end
+    end
+    # rubocop:enable Metrics/PerceivedComplexity
+    # rubocop:enable Lint/UnusedMethodArgument
+
+    def always_active?
+      true
+    end
+
+    def validation_field
+      :sort
+    end
+
+    def validation(sort)
+      {
+        inclusion: { in: SubsetComparator.new(sort) },
+        allow_nil: true
+      }
+    end
+
+    def type
+      parameter.type
+    end
+
+    def param
+      parameter.param
+    end
+
+    private
+
+    def mapped_scope_params(direction, params)
+      scope_params.map do |scope_param|
+        if scope_param == :direction
+          direction
+        elsif scope_param.is_a?(Proc)
+          scope_param.call
+        elsif params.include?(scope_param)
+          params[scope_param]
+        else
+          scope_param
+        end
+      end
+    end
+
+    def individual_sort_hash(active_sorts_hash)
+      if active_sorts_hash.include?(param)
+        { internal_name => active_sorts_hash[param] }
+      else
+        {}
+      end
+    end
+
+    def internal_name
+      parameter.internal_name
+    end
+  end
+end

data/lib/sift/subset_comparator.rb

@@ -0,0 +1,11 @@
+module Sift
+  class SubsetComparator
+    def initialize(array)
+      @array = array
+    end
+
+    def include?(other)
+      @array.to_set >= other.to_set
+    end
+  end
+end

data/lib/sift/type_validator.rb

@@ -0,0 +1,48 @@
+module Sift
+  # TypeValidator validates that the incoming param is of the specified type
+  class TypeValidator
+    DATETIME_RANGE_PATTERN = { format: { with: /\A.+(?:[^.]\.\.\.[^.]).+\z/, message: "must be a range" }, valid_date_range: true }.freeze
+    DECIMAL_PATTERN = { numericality: true, allow_nil: true }.freeze
+    BOOLEAN_PATTERN = { inclusion: { in: [true, false] }, allow_nil: true }.freeze
+
+    WHITELIST_TYPES = [:int,
+                       :decimal,
+                       :boolean,
+                       :string,
+                       :text,
+                       :date,
+                       :time,
+                       :datetime,
+                       :scope].freeze
+
+    def initialize(param, type)
+      @param = param
+      @type = type
+    end
+
+    attr_reader :param, :type
+
+    def validate
+      case type
+      when :datetime, :date, :time
+        DATETIME_RANGE_PATTERN
+      when :int
+        valid_int?
+      when :decimal
+        DECIMAL_PATTERN
+      when :boolean
+        BOOLEAN_PATTERN
+      end
+    end
+
+    def valid_type?
+      WHITELIST_TYPES.include?(type)
+    end
+
+    private
+
+    def valid_int?
+      { valid_int: true }
+    end
+  end
+end

data/lib/sift/validators/valid_date_range_validator.rb

@@ -0,0 +1,20 @@
+class ValidDateRangeValidator < ActiveModel::EachValidator
+  def validate_each(record, attribute, value)
+    record.errors.add attribute, "is invalid" unless valid_date_range?(value)
+  end
+
+  private
+
+  def valid_date_range?(date_range)
+    from_date_string, end_date_string = date_range.to_s.split("...")
+    return true unless end_date_string # validated by other validator
+
+    [from_date_string, end_date_string].all? { |date| valid_date?(date) }
+  end
+
+  def valid_date?(date)
+    !!DateTime.parse(date.to_s)
+  rescue ArgumentError
+    false
+  end
+end

data/lib/sift/validators/valid_int_validator.rb

@@ -0,0 +1,24 @@
+class ValidIntValidator < ActiveModel::EachValidator
+  def validate_each(record, attribute, value)
+    record.errors.add attribute, (options[:message] || "must be integer, array of integers, or range") unless
+      valid_int?(value)
+  end
+
+  private
+
+  def valid_int?(value)
+    integer_array?(value) || integer_or_range?(value)
+  end
+
+  def integer_array?(value)
+    if value.is_a?(String)
+      value = Sift::ValueParser.new(value: value).array_from_json
+    end
+
+    value.is_a?(Array) && value.any? && value.all? { |v| integer_or_range?(v) }
+  end
+
+  def integer_or_range?(value)
+    !!(/\A\d+(...\d+)?\z/ =~ value.to_s)
+  end
+end

data/lib/sift/value_parser.rb

@@ -0,0 +1,86 @@
+module Sift
+  class ValueParser
+    def initialize(value:, type: nil, options: {})
+      @value = value
+      @supports_boolean = options.fetch(:supports_boolean, false)
+      @supports_ranges = options.fetch(:supports_ranges, false)
+      @supports_json = options.fetch(:supports_json, false)
+      @value = normalized_value(value, type)
+    end
+
+    def parse
+      @_result ||=
+        if parse_as_range?
+          range_value
+        elsif parse_as_boolean?
+          boolean_value
+        elsif parse_as_json?
+          array_from_json
+        else
+          value
+        end
+    end
+
+    def array_from_json
+      result = JSON.parse(value)
+      if result.is_a?(Array)
+        result
+      else
+        value
+      end
+    rescue JSON::ParserError
+      value
+    end
+
+    private
+
+    attr_reader :value, :type, :supports_boolean, :supports_json, :supports_ranges
+
+    def parse_as_range?(raw_value=value)
+      supports_ranges && raw_value.to_s.include?("...")
+    end
+
+    def range_value
+      Range.new(*value.split("..."))
+    end
+
+    def parse_as_json?
+      supports_json && value.is_a?(String)
+    end
+
+    def parse_as_boolean?
+      supports_boolean
+    end
+
+    def boolean_value
+      if Rails.version.starts_with?("5")
+        ActiveRecord::Type::Boolean.new.cast(value)
+      else
+        ActiveRecord::Type::Boolean.new.type_cast_from_user(value)
+      end
+    end
+
+    def normalized_value(raw_value, type)
+      if type == :datetime && parse_as_range?(raw_value)
+        normalized_date_range(raw_value)
+      else
+        raw_value
+      end
+    end
+
+    def normalized_date_range(raw_value)
+      from_date_string, end_date_string = raw_value.split("...")
+      return unless end_date_string
+
+      parsed_dates = [from_date_string, end_date_string].map do |date_string|
+        begin
+          DateTime.parse(date_string.to_s)
+        rescue StandardError
+          date_string
+        end
+      end
+
+      parsed_dates.join("...")
+    end
+  end
+end

data/lib/sift/version.rb

@@ -0,0 +1,3 @@
+module Sift
+  VERSION = "0.12.0".freeze
+end

data/lib/sift/where_handler.rb

@@ -0,0 +1,11 @@
+module Sift
+  class WhereHandler
+    def initialize(param)
+      @param = param
+    end
+
+    def call(collection, value, _params, _scope_params)
+      collection.where(@param.internal_name => value)
+    end
+  end
+end

data/lib/tasks/filterable_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :sift do
+#   # Task goes here
+# end

metadata

@@ -0,0 +1,146 @@
+--- !ruby/object:Gem::Specification
+name: procore-sift
+version: !ruby/object:Gem::Version
+  version: 0.12.0
+platform: ruby
+authors:
+- Procore Technologies
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-06-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: 4.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: 4.2.0
+- !ruby/object:Gem::Dependency
+  name: pry
+  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: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.1'
+- !ruby/object:Gem::Dependency
+  name: rake
+  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: rubocop
+  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: sqlite3
+  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'
+description: Easily write arbitrary filters
+email:
+- dev@procore.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- lib/procore-sift.rb
+- lib/sift/filter.rb
+- lib/sift/filter_validator.rb
+- lib/sift/filtrator.rb
+- lib/sift/parameter.rb
+- lib/sift/scope_handler.rb
+- lib/sift/sort.rb
+- lib/sift/subset_comparator.rb
+- lib/sift/type_validator.rb
+- lib/sift/validators/valid_date_range_validator.rb
+- lib/sift/validators/valid_int_validator.rb
+- lib/sift/value_parser.rb
+- lib/sift/version.rb
+- lib/sift/where_handler.rb
+- lib/tasks/filterable_tasks.rake
+homepage: https://github.com/procore/sift
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.14
+signing_key: 
+specification_version: 4
+summary: Summary of Sift.
+test_files: []