collate 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 46caae4fc83f2556a1c2835b951dfb89dd57d557
+  data.tar.gz: 99278ff861ac8cfb50ba7cdcb1b6ca2940c311ea
+SHA512:
+  metadata.gz: 070f0611c0adea44f057b62f37d49d93fff18c04ef5681c7638b0491c178908dac17200f5b5966e9f1c10f1971291b7c59b37e4958d35acaa52e42d127531554
+  data.tar.gz: 5db48b737d9c51c0be11283d74e5e7108f3e1546012c54d8dc969e00e6ff899e60510f3f21e305a8c6ef7d0178d2211b7798c002856fc2f04683f10f3ecf0f5c

data/.gitignore

@@ -0,0 +1,12 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/log/
+/coverage/
+/*.gem

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Nicholas Page
+
+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,267 @@
+# Collate
+
+[![CircleCI](https://img.shields.io/circleci/project/github/trackingboard/collate.svg)](https://circleci.com/gh/trackingboard/collate)
+[![Coveralls](https://img.shields.io/coveralls/trackingboard/collate.svg)](https://coveralls.io/github/trackingboard/collate?branch=master)
+[![Gem](https://img.shields.io/gem/v/collate.svg)]()
+[![Gem](https://img.shields.io/gem/dt/collate.svg)]()
+
+## Installation
+
+```gem install collate```
+
+or with bundler in your Gemfile:
+
+```gem 'collate'```
+
+## Usage
+
+This gem currently only supports PostgreSQL.
+
+To use collate in a model, include several collation definitions. The first argument is the name of the database column to use in the query. The simplest example looks like this:
+
+```
+collate_on :name
+```
+
+This will add a filter to the model that will grab all records where the ```name``` column equals the parameter that is passed in.
+
+### Operators
+
+You can currently collate using multiple types of operators. To specify an operator to collate on, you can pass in the keyword argument ```operator```, like this:
+
+```
+collate_on :name, operator: :ilike
+```
+
+Translates to:
+
+```
+WHERE name ILIKE ?
+```
+
+Here are the currently available operators:
+
+| Operator | Behavior |
+|:------------------|:--------------------|
+| ```:eq```         | ```field = ?``` |
+| ```:ilike```      | ```field ILIKE ?``` |
+| ```:in```         | ```field IN (?)``` |
+| ```:le```         | ```field <= ?``` |
+| ```:ge```         | ```field >= ?``` |
+| ```:null```       | ```field IS NULL``` |
+| ```:contains```   | ```field @> ?``` |
+| ```:present?```   | ```field = ?``` |
+| ```:&```          | ```field & ?``` |
+
+### Field Transformations
+
+Field transformations are database functions applied to a field before the operator is used to compare it with the value. Field transformations are passed in as an array of tuples, where the first element in the tuple is the symbol for the transfomation, and the second element is the first argument to the database function.
+
+For example:
+
+```
+collate_on :name, field_transformations: [[:split, ' ']]
+```
+
+This would translate to this PostgreSQL query:
+
+```
+WHERE string_to_array(name, ' ') = ?
+```
+
+Here are the available field transformations:
+
+| Transformation | Behavior |
+|:-------------------------|:--------------------|
+| ```:date_difference``` | ```date_difference(arg1, field)``` |
+| ```:date_part```       | ```date_part(arg1, field)``` |
+| ```:array_agg```       | ```array_agg(field)``` |
+| ```:downcase```        | ```lower(field)``` |
+| ```:split```           | ```string_to_array(field, arg1)``` |
+| ```:array_length```    | ```array_length(field, arg1)``` |
+
+These transformations can also be chained together on the same filter. They are applied in the order they appear in the array that is passed in.
+
+For example:
+
+```
+collate_on :name, field_transformations: [[:split, ' '], [:array_length, 1]]
+```
+
+Translates to this PostgreSQL query:
+
+```
+WHERE array_length(string_to_array(name, ' '), 1) = ?
+```
+
+### Value Transformations
+
+Value transformations are functions applied to the user-supplied value before it is passed to the database query. They are passed in the same way as the field transmorations, as an array of tuples.
+
+For example:
+
+```
+collate_on :name, value_transformations: [[:join, ', ']]
+```
+
+Translates to the following code:
+
+```
+value = value.join(', ')
+ar_rel = ar_rel.where("name = ?", value)
+```
+
+Here are the available value transformations:
+
+| Transformation | Behavior |
+|:-------------------------|:--------------------|
+| ```:join```        | ```value = value.join(arg1)``` |
+| ```:downcase```    | ```value = value.downcase``` |
+| ```:string_part``` | ```value = "%#{value}%"``` |
+
+### Additional Arguments
+
+There are many other additional arguments you can initialize a filter with. Here is a list of all of them:
+
+#### Label
+--------------
+```
+collate_on :name, label: 'Character Name'
+```
+
+This argument will overwrite the default label for the filter, which is ```field.to_s.titleize```
+
+#### Not
+--------------
+```
+collate_on :name, not: true
+```
+
+This argument causes the entire query to be surrounded by a NOT(). The above, for example, translates to this PostgreSQL query:
+
+```
+WHERE NOT(name = ?)
+```
+
+#### Having
+--------------
+```
+collate_on :name, having: true
+```
+
+This argument tells the gem to use ```having``` instead of ```where``` in the ActiveRecord query. The above example then becomes:
+
+```
+HAVING name = ?
+```
+
+#### Joins
+--------------
+```
+collate_on 'genres.id', operator: :in, joins: [:genres, :movies => [:people]]
+```
+
+This argument tells the gem to use the ActiveRecord ```joins``` method with the value passed in. You can pass in an array of values, and it will evaluate each one in succession. The above code would then run this before any query is evaluated:
+
+```
+ar_rel = ar_rel.joins(:genres)
+ar_rel = ar_rel.joins(:movies => [:people])
+```
+
+#### Joins_prefix
+--------------
+```
+collate_on 'select_genres.id', operator: :in, joins: [:genres], joins_prefix: 'select_'
+```
+
+This argument will tell the gem to join in the relations specified in the ```joins``` argument, but to prefix all table names with the prefix specified. The above code would then translate to the following PostgreSQL query:
+
+```
+INNER JOIN genres AS select_genres ON ...
+```
+
+#### Component
+--------------
+```
+collate_on 'genres.id', operator: :in, component: {load_records: true}
+```
+
+This argument is used for rendering in the views. Currently the gem does not have helper methods for the views, but when those are added, that is how you would set the various options.
+
+### The View
+
+To know the ```params``` key to use for each filter, you need to look at the filter's ```param_key``` method value. The filters are organized in a hierarchal scheme in the class variable ```collate_filters``` for the model you included the DSL on.
+
+Here is a small example of a few filters:
+
+```
+class Person < ActiveRecord::Base
+	collate_on :name, operator: :ilike
+	collate_on :birthday, operator: :le, label: 'Birthday Before'
+end
+```
+
+And here is how ```Person.collate_filters``` would look like:
+
+```
+{
+	:main=> {
+		:label=>"Main",
+		:filters=> [
+			#<Collate::Filter
+			@base_model_table_name="people",
+			@component={:type=>"string"},
+			@field="people.name",
+			@field_transformations={},
+			@grouping=nil,
+			@html_id="1people_name",
+			@joins=nil,
+			@label="Name",
+			@operator=:ilike,
+			@value_transformations={}>
+			,
+			#<Collate::Filter
+			@base_model_table_name="people",
+			@component={:type=>"string"},
+			@field="people.birthday",
+			@field_transformations={},
+			@grouping=nil,
+			@html_id="1people_name",
+			@joins=nil,
+			@label="Birthday Before",
+			@operator=:le,
+			@value_transformations={}>
+		]
+	}
+}
+```
+
+In order to use this in a view, you could have some HAML like this:
+
+```
+= form_tag '', :method => :get do
+	- Person.collate_filters.each do |group_key, group|
+		- filters = group[:filters]
+		- filters.each do |filter|
+			- case filter.component[:type]
+			- when "string"
+	  			= filter.label
+	  			%br
+	  			= text_field_tag filter.param_key, params[filter.param_key], id: "#{filter.html_id}", style:'width:100%'
+
+```
+
+This will ensure that the keys that the inputs are submitted with match the parameter key that the gem is expecting for that specific filter.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/trackingboard/collate.
+
+1. Fork.
+2. Branch.
+3. Pull Request your feature branch or fix.
+4. 🍕
+
+## 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,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task :default => :test

data/circle.yml

@@ -0,0 +1,25 @@
+dependencies:
+  override:
+    - rvm --default use ruby-2.3.3
+    - gem install bundler
+    - bundle
+  cache_directories:
+    - "/opt/circleci/.rvm/gems/ruby-2.3.3"
+
+database:
+  override:
+    - psql -c 'create database collate_test;' -U postgres
+
+test:
+  override:
+    - RAILS_ENV=test bundle exec rake test
+
+deployment:
+  release:
+    tag: /^([0-9]+\.{0,1}){1,3}(\-([a-z0-9]+\.{0,1})+){0,1}(\+(build\.{0,1}){0,1}([a-z0-9]+\.{0,1}){0,}){0,1}$/
+    commands:
+      - gem build collate.gemspec
+      - chmod +x deploy.sh
+      - sh deploy.sh
+      - chmod 0600 ~/.gem/credentials
+      - gem push collate-${CIRCLE_TAG}.gem

data/collate.gemspec

@@ -0,0 +1,40 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'collate/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "collate"
+  spec.version       = Collate::VERSION
+  spec.authors       = ["Nicholas Page", "Colleen McGuckin"]
+  spec.email         = ["npage85@gmail.com", "colleenmcguckin@gmail.com"]
+
+  spec.summary       = %q{Facilitates the filtering of ActiveRecord models using simplified DSL.}
+  spec.description   = %q{Add some DSL to your model, then run a single method in your controller, and your model now accepts filtering through the parameters.}
+  spec.homepage      = "https://github.com/trackingboard/collate"
+  spec.license       = "MIT"
+
+  if spec.respond_to?(:metadata)
+    spec.metadata['allowed_push_host'] = 'https://rubygems.org'
+  else
+    raise "RubyGems 2.0 or newer is required to protect against " \
+      "public gem pushes."
+  end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features|app|coverage|config|log)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler",      "~> 1.14"
+  spec.add_development_dependency "rake",         "~> 10.0"
+  spec.add_development_dependency "rails",        "~> 4.2", ">= 4.2.6"
+  spec.add_development_dependency "pg",           "~> 0.18.4"
+  spec.add_development_dependency "minitest",     "~> 5.0"
+  spec.add_development_dependency "pry-rescue",   "~> 1.4", ">= 1.4.2"
+  spec.add_development_dependency "simplecov",    "~> 0.12.0"
+  spec.add_development_dependency "coveralls",    "~> 0.8.15"
+  spec.add_development_dependency "haml",         "~> 4.0", ">= 4.0.7"
+end

data/deploy.sh

@@ -0,0 +1,6 @@
+#!/bin/bash
+
+cat <<EOF > ~/.gem/credentials
+---
+:rubygems_api_key: $RUBYGEMS_API_KEY
+EOF

data/lib/collate.rb

@@ -0,0 +1,6 @@
+require "collate/version"
+require "collate/engine"
+
+module Collate
+
+end

data/lib/collate/active_record_extension.rb

@@ -0,0 +1,175 @@
+require_relative 'filter'
+
+module Collate
+  module ActiveRecordExtension
+
+    def collate_on field, opts={}
+      initialize_collate
+
+      self.collate_filters[self.default_group] ||= {filters: []}.merge(self.group_options)
+
+      self.collate_filters[self.default_group][:filters] << Collate::Filter.new(field, opts.merge({base_model_table_name: self.table_name}))
+    end
+
+    def collate_group name, **opts, &blk
+      initialize_collate
+
+      opts[:label] ||= name.to_s.titleize
+      self.group_options = opts
+      self.default_group = name
+      blk.call
+    end
+
+    def collate params
+      ar_rel = self.all
+
+      self.collate_filters.each do |group_key, group|
+        group[:filters].each do |filter|
+          if params[filter.param_key].present? || params["#{filter.param_key}[]"].present?
+            ar_rel = apply_filter(ar_rel, filter, params[filter.param_key] || params["#{filter.param_key}[]"])
+          end
+        end
+      end
+
+      ar_rel
+    end
+
+  private
+
+    def initialize_collate
+      if !self.method_defined? :collate_filters
+        class << self
+          attr_accessor :collate_filters, :default_group, :group_options
+        end
+      end
+      self.collate_filters ||= {}
+      self.default_group ||= :main
+      self.group_options ||= {}
+    end
+
+    def apply_filter ar_rel, filter, filter_value
+      if filter.joins
+        filter.joins.each do |join|
+          ar_rel = if filter.joins_prefix
+            prefix_index = 0
+            original_query = ar_rel.model.unscoped.joins(join).to_sql
+
+            previous_replacements = {}
+            new_query = original_query.split('INNER JOIN').drop(1).map do |chunk|
+              table_name = /([\"'])(?:\\\1|.)*?\1/.match(chunk)[0].gsub('"','')
+
+              if previous_replacements.has_key?("\"#{table_name}\"")
+                previous_replacements.delete("\"#{table_name}\"")
+                prefix_index += 1
+
+                check_alias_match = /(?<="#{table_name}" ")[^"]*(?=")/.match(chunk)
+                if check_alias_match
+                  chunk = chunk.partition(check_alias_match[0]).drop(1).join('').prepend('"').gsub(check_alias_match[0], "#{table_name}")
+                end
+              end
+
+              previous_replacements.each do |the_match, replacement|
+                chunk = chunk.gsub(the_match, replacement)
+              end
+
+              replaced = chunk.gsub("\"#{table_name}\"", "\"#{filter.joins_prefix[prefix_index]}#{table_name}\"")
+
+              previous_replacements["\"#{table_name}\""] = "\"#{filter.joins_prefix[prefix_index]}#{table_name}\""
+
+              "\"#{table_name}\" AS #{replaced}"
+            end.join(' INNER JOIN ').prepend('INNER JOIN ')
+
+            ar_rel.joins(new_query)
+          else
+            ar_rel.joins(join)
+          end
+        end
+      end
+
+      ar_rel = ar_rel.group(filter.grouping) if filter.grouping
+
+      field_query = filter.field
+
+      filter.field_transformations.each do |ft|
+        transformation = ft
+        transformation = ft[0] if !transformation.is_a? Symbol
+        field_query = case transformation
+        when :date_difference
+          "age(#{ft[1]}, #{field_query})"
+        when :date_part
+          "date_part('#{ft[1]}', #{field_query})"
+        when :array_agg
+          "array_agg(#{field_query})"
+        when :downcase
+          "lower(#{field_query})"
+        when :split
+          "string_to_array(#{field_query}, '#{ft[1]}')"
+        when :array_length
+          "array_length(#{field_query}, '#{ft[1]}')"
+        else
+          field_query
+        end
+      end
+
+      if filter.component[:load_records]
+        results = filter.component[:load_record_model].constantize.where("#{filter.component[:load_record_field]} IN (?)", filter_value)
+
+        filter.component[:values] = results.map{ |r| {id: r.id, text: r.name} }
+      end
+
+      if filter.component[:tags]
+        filter.component[:values] = filter_value.map { |v| {id: v, text: v} }
+      end
+
+      filter.value_transformations.each do |vt|
+        transformation = vt
+        transformation = vt[0] if !transformation.is_a? Symbol
+
+        filter_value = case transformation
+        when :join
+          "{#{filter_value.join(', ')}}"
+        when :downcase
+          filter_value.downcase
+        when :string_part
+          "%#{filter_value}%"
+        else
+          filter_value
+        end
+      end
+
+      ar_method = filter.having ? "having" : "where"
+
+      query_string = case filter.operator
+      when :eq
+        "#{field_query} = ?"
+      when :ilike
+        "#{field_query} ILIKE ?"
+      when :in
+        "#{field_query} IN (?)"
+      when :le
+        "#{field_query} <= ?"
+      when :ge
+        "#{field_query} >= ?"
+      when :null
+        "#{field_query} IS NULL"
+      when :contains
+        "#{field_query} @> ?"
+      when :present?
+        "#{field_query} = true"
+      when :&
+        "#{field_query} && ?"
+      else
+        ""
+      end
+
+      query_string = "NOT(#{query_string})" if filter.not
+
+      ar_rel = if query_string.include?('?')
+        ar_rel.send(ar_method, query_string, filter_value)
+      else
+        ar_rel.send(ar_method, query_string)
+      end
+    end
+
+  end
+end

data/lib/collate/engine.rb

@@ -0,0 +1,14 @@
+require_relative 'active_record_extension'
+require 'rails'
+
+module Collate
+  class Engine < ::Rails::Engine
+
+    isolate_namespace Collate
+
+    ActiveSupport.on_load :active_record do
+      extend Collate::ActiveRecordExtension
+    end
+
+  end
+end

data/lib/collate/filter.rb

@@ -0,0 +1,118 @@
+module Collate
+  class Filter
+    OPERATORS = [:eq, :ilike, :in, :le, :ge, :null, :contains, :present?, :&]
+
+    FIELD_TRANSFORMATIONS = [:date_difference, :date_part, :array_agg, :downcase, :split, :array_length]
+    AGGREGATE_TRANSFORMATIONS = [:array_agg]
+    VALUE_TRANSFORMATIONS = [:join, :downcase, :string_part]
+
+    attr_accessor :field, :operator, :base_model_table_name, :field_transformations, :label,
+                  :component, :joins, :value_transformations, :grouping, :html_id, :having,
+                  :joins_prefix, :not
+
+    def initialize(field, opt={})
+      opt.each do |field, value|
+        self.send("#{field}=", value)
+      end
+
+      self.component ||= {}
+
+      self.field = field
+      self.label ||= field.to_s.titleize
+      self.operator ||= if field.to_s.last(3) == '.id' || field.to_s.last(3) == '_id'
+        :in
+      elsif self.component[:type] == 'checkboxgroup'
+        :in
+      else
+        :eq
+      end
+      self.field = "#{base_model_table_name}.#{field}" if field.is_a? Symbol
+      self.field_transformations ||= {}
+      self.value_transformations ||= {}
+
+      self.html_id ||= param_key.gsub('{','').gsub('}','').gsub('.','_')
+
+      field_parts = self.field.to_s.partition('.')
+      table_name = field_parts[0]
+      field_selector = field_parts[2]
+
+      self.component = if self.operator == :in
+        self.component.reverse_merge({type: 'select', multiple: true, values: []})
+      elsif self.operator == :null || self.operator == :present?
+        self.component.reverse_merge({type: 'checkbox'})
+      elsif self.component[:tags]
+        self.component.reverse_merge({type: 'select', multiple: true})
+      else
+        self.component.reverse_merge({type: 'string'})
+      end
+
+      if self.component[:load_records]
+        model_name = if field_selector.last(3) == '_id'
+          field_selector.chomp(field_selector.last(3))
+        elsif self.field.to_s.last(3) == '.id'
+          table_name.singularize
+        else
+          table_name.singularize
+        end
+
+        self.component[:load_record_model] ||= model_name.titleize
+        self.component[:load_record_field] ||= "id"
+        self.component[:load_record_route] ||= "/#{model_name.pluralize}.json"
+      end
+
+      self.joins ||= if table_name != base_model_table_name
+        join_name = table_name.to_sym
+        base_model_table_name.singularize.titleize.constantize.reflect_on_all_associations.each do |assoc|
+
+          join_name = assoc.name if assoc.plural_name == table_name
+        end
+
+        [join_name.to_sym]
+      end
+      self.joins_prefix = [self.joins_prefix] if self.joins_prefix.is_a? String
+
+      if !opt.has_key?(:having) && (field_transformations.to_a.flatten & AGGREGATE_TRANSFORMATIONS).any?
+        self.having = true
+      end
+
+      if self.value_transformations.empty? && self.operator == :ilike
+        self.value_transformations = [:string_part]
+      end
+
+      self.grouping ||= if self.having
+        "#{base_model_table_name}.id"
+      end
+
+      if self.component[:values]
+        self.component[:values] = if self.component[:values].is_a?(Array) && self.component[:values].all? { |item| item.is_a? String }
+          self.component[:values].map { |s| {id: s, text: s.titleize} }
+        elsif self.component[:values].is_a?(Array) && self.component[:values].all? { |item| item.is_a? Symbol }
+          self.component[:values].map { |s| {id: s, text: s.to_s.titleize} }
+        elsif self.component[:values].respond_to?(:<) && self.component[:values] < ActiveRecord::Base
+          self.component[:values].table_exists? ? self.component[:values].all.map { |m| {id: m.id, text: m.name} } : []
+        else
+          self.component[:values]
+        end
+      elsif component[:tags]
+        self.component[:values] = []
+      end
+    end
+
+    def param_key
+      key = ""
+      field_transformations.each do |ft|
+        transformation = ft
+        transformation = ft[0] if !transformation.is_a? Symbol
+        key += FIELD_TRANSFORMATIONS.index(transformation).to_s
+      end
+      key += OPERATORS.index(operator).to_s
+      value_transformations.each do |vt|
+        transformation = vt
+        transformation = vt[0] if !transformation.is_a? Symbol
+        key += VALUE_TRANSFORMATIONS.index(transformation).to_s
+      end
+
+      "{#{key}}#{field}"
+    end
+  end
+end

data/lib/collate/version.rb

@@ -0,0 +1,3 @@
+module Collate
+  VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,205 @@
+--- !ruby/object:Gem::Specification
+name: collate
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Nicholas Page
+- Colleen McGuckin
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-02-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.2.6
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.2.6
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.18.4
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.18.4
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: pry-rescue
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.4.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.4.2
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.12.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.12.0
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.15
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.15
+- !ruby/object:Gem::Dependency
+  name: haml
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.0.7
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.0.7
+description: Add some DSL to your model, then run a single method in your controller,
+  and your model now accepts filtering through the parameters.
+email:
+- npage85@gmail.com
+- colleenmcguckin@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- circle.yml
+- collate.gemspec
+- deploy.sh
+- lib/collate.rb
+- lib/collate/active_record_extension.rb
+- lib/collate/engine.rb
+- lib/collate/filter.rb
+- lib/collate/version.rb
+homepage: https://github.com/trackingboard/collate
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.2
+signing_key: 
+specification_version: 4
+summary: Facilitates the filtering of ActiveRecord models using simplified DSL.
+test_files: []