brita 0.9.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f5bb6a00b2f18b8868b43eb4b22803ed179bc63c
+  data.tar.gz: ff737c18910108bc92517f19f0b7a3fdc14aa0e7
+SHA512:
+  metadata.gz: fc412bdc2c69093bf76631f2498949c60a7d377640bdbc06bba4d6ae91f77ce97029c9a892aa295361ddd999badc6c63dfff1ebfd69f54e35b0552a4d1c70f10
+  data.tar.gz: 30830b49f18d75cac7d2249fb9a09e671c4caa1b38ecf3f1a73e3b7514cc2f7049b4ebf77e7f240b147a6ea1d5206f60aa49a9fef4ef29190bbbb78874d8cb5f

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,194 @@
+# Brita
+
+[![Build Status](https://travis-ci.org/procore/brita.svg?branch=master)](https://travis-ci.org/procore/brita)
+
+A tool to build your own filters!
+
+## Developer Usage
+Include Brita in your controllers, and define some filters.
+
+```ruby
+class PostsController < ApplicationController
+  include Brita
+
+  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`.
+
+Brita 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 brita your param was.
+
+### Filter Types
+Every filter must have a type, so that Brita 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 Brita
+
+  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 Brita
+
+  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 Brita
+
+  filter_on :post_id, type: :int, internal_name: :id
+
+end
+```
+
+### Sort Types
+Every sort must have a type, so that Brita 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 Brita
+
+  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 'brita'
+```
+
+And then execute:
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+```bash
+$ gem install brita
+```
+
+## Contributing
+Contribution directions go here.
+
+## License
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

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", __FILE__)
+load "rails/tasks/engine.rake"
+
+require "rdoc/task"
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = "rdoc"
+  rdoc.title    = "Brita"
+  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/brita.rb

@@ -0,0 +1,78 @@
+require "brita/filter"
+require "brita/filter_validator"
+require "brita/filtrator"
+require "brita/sort"
+require "brita/subset_comparator"
+require "brita/type_validator"
+require "brita/parameter"
+require "brita/scope_handler"
+require "brita/where_handler"
+require "brita/validators/valid_int_validator"
+
+module Brita
+  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/brita/filter.rb

@@ -0,0 +1,94 @@
+module Brita
+  # 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(_)
+      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 ||= Brita::TypeValidator.new(param, type)
+    end
+
+    def type
+      parameter.type
+    end
+
+    def param
+      parameter.param
+    end
+
+    private
+
+    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 parameterize(value)
+      if supports_ranges? && value.to_s.include?("...")
+        Range.new(*value.split("..."))
+      elsif type == :boolean
+        if Rails.version.starts_with?("5")
+          ActiveRecord::Type::Boolean.new.cast(value)
+        else
+          ActiveRecord::Type::Boolean.new.type_cast_from_user(value)
+        end
+      else
+        value
+      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/brita/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 Brita
+  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/brita/filtrator.rb

@@ -0,0 +1,53 @@
+module Brita
+  # 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/brita/parameter.rb

@@ -0,0 +1,24 @@
+module Brita
+  # 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 supports_ranges?
+      ![:string, :text, :scope].include?(type)
+    end
+
+    def handler
+      if type == :scope
+        ScopeHandler.new(self)
+      else
+        WhereHandler.new(self)
+      end
+    end
+  end
+end

data/lib/brita/scope_handler.rb

@@ -0,0 +1,25 @@
+module Brita
+  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/brita/sort.rb

@@ -0,0 +1,106 @@
+module Brita
+  # 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 Brita::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/brita/subset_comparator.rb

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

data/lib/brita/type_validator.rb

@@ -0,0 +1,48 @@
+module Brita
+  # TypeValidator validates that the incoming param is of the specified type
+  class TypeValidator
+    RANGE_PATTERN = { format: { with: /\A.+(?:[^.]\.\.\.[^.]).+\z/, message: "must be a range" } }.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
+        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/brita/validators/valid_int_validator.rb

@@ -0,0 +1,20 @@
+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)
+    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/brita/version.rb

@@ -0,0 +1,3 @@
+module Brita
+  VERSION = "0.9.3".freeze
+end

data/lib/brita/where_handler.rb

@@ -0,0 +1,11 @@
+module Brita
+  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 :brita do
+#   # Task goes here
+# end

metadata

@@ -0,0 +1,130 @@
+--- !ruby/object:Gem::Specification
+name: brita
+version: !ruby/object:Gem::Version
+  version: 0.9.3
+platform: ruby
+authors:
+- Procore Technologies
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-01-26 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: 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/brita.rb
+- lib/brita/filter.rb
+- lib/brita/filter_validator.rb
+- lib/brita/filtrator.rb
+- lib/brita/parameter.rb
+- lib/brita/scope_handler.rb
+- lib/brita/sort.rb
+- lib/brita/subset_comparator.rb
+- lib/brita/type_validator.rb
+- lib/brita/validators/valid_int_validator.rb
+- lib/brita/version.rb
+- lib/brita/where_handler.rb
+- lib/tasks/filterable_tasks.rake
+homepage: https://github.com/procore/brita
+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.13
+signing_key: 
+specification_version: 4
+summary: Summary of Brita.
+test_files: []