paraphrase 0.4.0 → 0.5.0

data/CHANGELOG

@@ -1,3 +1,10 @@
+0.5.0 / 8-7-2012
+
+* Cleanup ScopeMapping class
+* Add ability to query from an existing ActiveRecord::Relation instance
+(typically an association).
+* Update syntax for generating mappings.
+
 0.4.0 / 7-6-2012
 
 * Setup Query#params to be HashWithIndifferentAccess.

data/README.md

@@ -36,7 +36,7 @@ $ gem install paraphrase
 ```ruby
 class Post < ActiveRecord::Base
   register_mapping do
-    scope :by_user, :key => :author
+    map :by_user, :to => :author
   end
 
   def self.by_user(author_name)
@@ -53,7 +53,7 @@ class PostQuery < Paraphrase::Query
   # into a constant name
   paraphrases Post
 
-  scope :by_user, :key => :author
+  map :by_user, :to => :author
 end
 ```
 
@@ -75,17 +75,35 @@ class PostsController < ApplicationController
 end
 ```
 
-### Configuring Scopes
+You can scope queries from an association, useful if you have nested resources:
 
-In any of these contexts, the `:key` option of the `:scope` method registers
+```ruby
+class PostsController < ApplicationController
+  respond_to :html, :json
+
+  # GET /users/1/posts
+  def index
+    @user = User.find(params[:user_id])
+
+    # This will do a join on the users table, scoping posts to the current user
+    @posts = @users.posts.paraphrase(params)
+
+    respond_with(@posts)
+  end
+end
+```
+
+### Configuring Mappings
+
+In any of these contexts, the `:to` option of the `:map` method registers
 attribute(s) to extract from the params supplied and what method to pass them
 to. An array of keys can be supplied to pass multiple arguments to a scope.
 
 ```ruby
 class Post < ActiveRecord::Base
   register_mapping do
-    scope :by_user, :key => [:first_name, :last_name]
-    scope :published_on, :key => :pub_date
+    map :by_user, :to => [:first_name, :last_name]
+    map :published_on, :to => :pub_date
   end
 
   def self.by_user(first_name, last_name)
@@ -107,8 +125,8 @@ rest of the attributes will be allowed to be nil.
 ```ruby
 class Post < ActiveRecord::Base
   register_mapping do
-    scope :published_on, :key => :pub_date, :require => true
-    scope :by_author, :key => [:first_name, :last_name], :require => :last_name # requires :last_name, whitelists :first_name
+    map :published_on, :to => :pub_date, :require => true
+    map :by_author, :to => [:first_name, :last_name], :require => :last_name # requires :last_name, whitelists :first_name
   end
 end
 
@@ -120,15 +138,7 @@ Alternatively, a scope can be whitelisted allowing nil values to be passed to th
 ```ruby
 class Post < ActiveRecord::Base
   register_mapping do
-    scope :by_author, :key => [:first_name, :last_name], :allow_nil => :first_name # :first_name does not need to be specified
+    map :by_author, :to => [:first_name, :last_name], :allow_nil => :first_name # :first_name does not need to be specified
   end
 end
 ```
-
-## Plans / Thoughts for the Future
-
-* Support nested hashes in params.
-
-```ruby
-scope :by_author, :key => { :author => [:first_name, :last_name] }
-```

data/gemfiles/3.0.gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: /Users/edd_d/src/paraphrase
   specs:
-    paraphrase (0.3.2)
+    paraphrase (0.4.0)
       activemodel (~> 3.0)
       activerecord (~> 3.0)
       activesupport (~> 3.0)

data/gemfiles/3.1.gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: /Users/edd_d/src/paraphrase
   specs:
-    paraphrase (0.3.2)
+    paraphrase (0.4.0)
       activemodel (~> 3.0)
       activerecord (~> 3.0)
       activesupport (~> 3.0)

data/gemfiles/3.2.gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: /Users/edd_d/src/paraphrase
   specs:
-    paraphrase (0.3.2)
+    paraphrase (0.4.0)
       activemodel (~> 3.0)
       activerecord (~> 3.0)
       activesupport (~> 3.0)

data/lib/paraphrase/query.rb

@@ -8,32 +8,28 @@ module Paraphrase
   class Query
     extend ActiveModel::Naming
 
-    # @!attribute [r] scopes
-    #   @return [Array<ScopeMapping>] scopes for query
+    # @!attribute [r] mappings
+    #   @return [Array<ScopeMapping>] mappings for query
     #
     # @!attribute [r] source
     #   @return [ActiveRecord::Relation] source to apply scopes to
-    class_attribute :scopes, :source, :instance_writer => false
-
+    class_attribute :mappings, :source, :instance_writer => false
 
     # Delegate enumerable methods to results
     delegate :collect, :map, :each, :select, :to_a, :to_ary, :to => :results
 
-
     # @!attribute [r] errors
     #   @return [ActiveModel::Errors] errors from determining results
     #
     # @!attribute [r] params
-    #   @return [HashWithIndifferentAccess] filters parameters based on keys defined in scopes
+    #   @return [HashWithIndifferentAccess] filters parameters based on keys defined in mappings
     attr_reader :errors, :params
 
-
-    # Set `scopes` on inheritance to ensure they're unique per subclass
+    # Set `mappings` on inheritance to ensure they're unique per subclass
     def self.inherited(klass)
-      klass.scopes = []
+      klass.mappings = []
     end
 
-
     # Specify the ActiveRecord model to use as the source for queries
     #
     # @param [String, Symbol, ActiveRecord::Base] klass name of the class to
@@ -46,24 +42,25 @@ module Paraphrase
       self.source = klass
     end
 
-
-    # Add a {ScopeMapping} instance to {@@scopes .scopes}
+    # Add a {ScopeMapping} instance to {@@mappings .mappings}
     #
     # @see ScopeMapping#initialize
-    def self.scope(name, options)
-      if scopes.map(&:method_name).include?(name)
+    def self.map(name, options)
+      if mappings.map(&:method_name).include?(name)
         raise DuplicateScopeError, "scope :#{name} has already been added"
       end
 
-      scopes << ScopeMapping.new(name, options)
+      mappings << ScopeMapping.new(name, options)
     end
 
-
     # Filters out parameters irrelevant to the query
     #
     # @param [Hash] params query parameters
-    def initialize(params = {})
-      keys = scopes.map(&:param_keys).flatten.map(&:to_s)
+    def initialize(params = {}, relation = nil)
+      keys = mappings.map(&:keys).flatten.map(&:to_s)
+
+      @relation = relation || source.scoped
+
       @params = HashWithIndifferentAccess.new(params)
       @params.select! { |key, value| keys.include?(key) }
       @params.freeze
@@ -71,22 +68,20 @@ module Paraphrase
       @errors = ActiveModel::Errors.new(self)
     end
 
-
-    # Loops through {#scopes} and apply scope methods to {#source}. If values
+    # Loops through {#mappings} and apply scope methods to {#source}. If values
     # are missing for a required key, an empty array is returned.
     #
     # @return [ActiveRecord::Relation, Array]
     def results
       return @results if @results
 
-      results = scopes.inject(source.scoped) do |query, scope|
+      results = mappings.inject(@relation) do |query, scope|
         scope.chain(self, @params, query)
       end
 
       @results = @errors.any? ? [] : results
     end
 
-
     def respond_to?(name)
       super || results.respond_to?(name)
     end

data/lib/paraphrase/rails.rb

@@ -4,7 +4,8 @@ module Paraphrase
   class Railtie < Rails::Railtie
     initializer 'paraphrase.extend_active_record' do
       ActiveSupport.on_load :active_record do
-        extend Paraphrase::Syntax
+        extend Paraphrase::Syntax::Base
+        ActiveRecord::Relation.send(:include, Paraphrase::Syntax::Relation)
       end
     end
   end

data/lib/paraphrase/scope_mapping.rb

@@ -1,6 +1,6 @@
 module Paraphrase
   class ScopeMapping
-    # @!attribute [r] param_keys
+    # @!attribute [r] keys
     #   @return [Array<Symbol>] param keys to extract
     #
     # @!attribute [r] method_name
@@ -12,10 +12,9 @@ module Paraphrase
     # @!attribute [r] required_keys
     #   @return [Array] keys required for query
     #
-    # @!attribute [r] whitelisted_keys
+    # @!attribute [r] whitelist_keys
     #   @return [Array] keys allowed to be nil
-    attr_reader :param_keys, :method_name, :options, :required_keys, :whitelisted_keys
-
+    attr_reader :keys, :method_name, :options, :required, :whitelist
 
     # @param [Symbol] name name of the scope
     # @param [Hash] options options to configure {ScopeMapping ScopeMapping} instance
@@ -23,35 +22,20 @@ module Paraphrase
     # @option options [true] :require lists scope as required
     def initialize(name, options)
       @method_name = name
-      @param_keys = Array(options.delete(:key))
+      @keys = Array(options.delete(:to))
 
-      @required_keys = register_keys(options[:require])
-      @whitelisted_keys = register_keys(options[:allow_nil])
+      @required = register_keys(options[:require])
+      @whitelist = register_keys(options[:allow_nil])
 
-      if @whitelisted_keys.empty? && !@required_keys.empty?
-        @whitelisted_keys = @param_keys - @required_keys
+      if @whitelist.empty? && !@required.empty?
+        @whitelist = @keys - @required
       end
 
       @options = options.freeze
     end
 
-
-    # True if scope is required for query
-    # @param [Symbol, String] key param key being checked
-    def required?(key)
-      required_keys.include?(key)
-    end
-
-
-    # True if nil param values can be passed to scope
-    # @see #required?
-    def whitelisted?(key)
-      whitelisted_keys.include?(key)
-    end
-
-
     # Sends {#method_name} to `chain`, extracting arguments from `params`.  If
-    # values are missing for any {#param_keys}, return the `chain` unmodified.
+    # values are missing for any {#keys}, return the `chain` unmodified.
     # If {#required? required}, errors are added to the {Query} instance as
     # well.
     #
@@ -60,11 +44,11 @@ module Paraphrase
     # @param [ActiveRecord::Relation, ActiveRecord::Base] chain current model scope
     # @return [ActiveRecord::Relation]
     def chain(query, params, chain)
-      inputs = param_keys.map do |key|
+      inputs = keys.map do |key|
         input = params[key]
 
-        if input.nil? && ( required?(key) || !whitelisted?(key) )
-          query.errors.add(key, 'is required') if required?(key)
+        if input.nil? && ( required.include?(key) || !whitelist.include?(key) )
+          query.errors.add(key, 'is required') if required.include?(key)
           break []
         end
 
@@ -77,7 +61,7 @@ module Paraphrase
     private
 
     def register_keys(option)
-      option == true ? Array(param_keys) : Array(option)
+      option == true ? Array(keys) : Array(option)
     end
   end
 end

data/lib/paraphrase/syntax.rb

@@ -1,29 +1,63 @@
 module Paraphrase
   module Syntax
+    module Base
+      def self.extended(klass)
+        klass.instance_eval do
+          class_attribute :paraphraser, :instance_writer => false, :instance_reader => false
+        end
+      end
 
-    def self.extended(klass)
-      klass.instance_eval do
-        class_attribute :paraphraser, :instance_writer => false, :instance_reader => false
+      # Register a {Query} class mapped to `self`. If the mapping has already
+      # been registered, calling again will clear existing scopes and evaluate
+      # the block.
+      #
+      # @param [Proc] &block block to define scope mappings
+      def register_mapping(&block)
+        klass = Class.new(Query, &block)
+        klass.source = self
+        self.paraphraser = klass
       end
-    end
 
-    # Register a {Query} class mapped to `self`. If the mapping has already
-    # been registered, calling again will clear existing scopes and evaluate
-    # the block.
-    #
-    # @param [Proc] &block block to define scope mappings
-    def register_mapping(&block)
-      klass = Class.new(Query, &block)
-      klass.source = self
-      self.paraphraser = klass
+      # Instantiate the {Query} class that is mapped to `self`.
+      #
+      # @param [Hash] params query parameters
+      def paraphrase(params)
+        self.paraphraser.new(params)
+      end
     end
 
-
-    # Instantiate the {Query} class that is mapped to `self`.
-    #
-    # @param [Hash] params query parameters
-    def paraphrase(params)
-      self.paraphraser.new(params)
+    module Relation
+      # Creates a paraphrase {Query query}, supplying `self` as the base for the
+      # query. Intended for scoping a query from an association:
+      #
+      # Given the following models:
+      #
+      # ```ruby
+      # class User < ActiveRecord::Base
+      #   has_many :posts
+      # end
+      #
+      # class Post < ActiveRecord::Base
+      #   belongs_to :user
+      #
+      #   register_mapping
+      #     map :title_like, :to => :title
+      #   end
+      # end
+      # ```
+      #
+      # It is possible to do the following:
+      #
+      # ```ruby
+      # user.posts.paraphrase({ :title => 'Game of Thrones Finale' }).to_sql
+      # # => SELECT `posts`.* FROM `posts` INNER JOIN `users` ON `users`.`post_id` = `posts`.`id` WHERE `posts`.`title LIKE "%Game of Thrones Finale%";
+      # ```
+      #
+      # @param [Hash] params query params
+      # @return [Paraphrase::Query]
+      def paraphrase(params)
+        klass.paraphraser.new(params, self)
+      end
     end
   end
 end

data/lib/paraphrase/version.rb

@@ -1,3 +1,3 @@
 module Paraphrase
-  VERSION = "0.4.0"
+  VERSION = "0.5.0"
 end

data/paraphrase.gemspec

@@ -5,10 +5,12 @@ require File.expand_path('../lib/paraphrase/version', __FILE__)
 Gem::Specification.new do |gem|
   gem.name          = "paraphrase"
   gem.version       = Paraphrase::VERSION
-  gem.summary       = %q{Map param keys to class scopes}
+  gem.summary       = %q{Map params to model scopes}
   gem.description   = %q{
-                        Build customizable classes to determine which scope
-                        methods to call based on supplied parameters.
+                        Map query parameters to model scopes, pairing one or
+                        more keys to a scope. Parameters can be required, or
+                        whitelisted providing fine tuned control over how
+                        scopes are run.
                       }
   gem.license       = "MIT"
   gem.authors       = ["Eduardo Gutierrez"]
@@ -27,8 +29,8 @@ Gem::Specification.new do |gem|
   gem.add_development_dependency 'bundler', '~> 1.0'
   gem.add_development_dependency 'yard', '~> 0.7'
   gem.add_development_dependency 'rspec', '~> 2.10'
-  gem.add_development_dependency 'redcarpet'
-  gem.add_development_dependency 'rake'
-  gem.add_development_dependency 'sqlite3'
-  gem.add_development_dependency 'appraisal'
+  gem.add_development_dependency 'redcarpet', '~> 2.1.1'
+  gem.add_development_dependency 'rake', '~> 0.9.2'
+  gem.add_development_dependency 'sqlite3',  '~> 1.3.6'
+  gem.add_development_dependency 'appraisal', '0.4'
 end

data/spec/paraphrase/query_spec.rb

@@ -3,6 +3,9 @@ require 'spec_helper'
 module Paraphrase
   describe Query do
 
+    class AccountSearch < Query
+    end
+
     describe ".paraphrases" do
       it "stores the class being queried" do
         AccountSearch.paraphrases :account
@@ -11,23 +14,23 @@ module Paraphrase
     end
 
     describe ".scope" do
-      it "adds information to Query.scopes" do
+      it "adds information to Query.mappings" do
         AccountSearch.instance_eval do
-          scope :name_like, :key => :name
+          map :name_like, :to => :name
         end
 
-        AccountSearch.scopes.should_not be_empty
+        AccountSearch.mappings.should_not be_empty
       end
 
       it "raises an error if a scope is added twice" do
-        expect { AccountSearch.instance_eval { scope :name_like, :key => :name } }.to raise_error Paraphrase::DuplicateScopeError
+        expect { AccountSearch.instance_eval { map :name_like, :to => :name } }.to raise_error Paraphrase::DuplicateScopeError
       end
     end
 
     describe "#initialize" do
       let(:query) { AccountSearch.new(:name => 'Tyrion Lannister', :nickname => 'Half Man') }
 
-      it "filters out params not specified in scopes" do
+      it "filters out params not specified in mappings" do
         query.params.should_not have_key :nickname
         query.params.should have_key :name
       end
@@ -35,12 +38,23 @@ module Paraphrase
       it "sets up params with indifferent access" do
         query.params.should have_key 'name'
       end
+
+      it "accepts an ActiveRecord::Relation to use as the base scope" do
+        user = User.create!
+        associated_account = Account.create!(:user => user)
+        lonely_account = Account.create!
+
+        results = AccountSearch.new({ :name => 'Tyrion Lannister'}, user.accounts).results
+
+        results.should include associated_account
+        results.should_not include lonely_account
+      end
     end
 
     describe "#results" do
       before :all do
         AccountSearch.instance_eval do
-          scope :title_like, :key => :title, :require => true
+          map :title_like, :to => :title, :require => true
         end
       end
 

data/spec/paraphrase/scope_mapping_spec.rb

@@ -2,8 +2,8 @@ require 'spec_helper'
 
 module Paraphrase
   describe ScopeMapping do
-    let(:mapping) { ScopeMapping.new(:name_like, :key => :name) }
-    let(:compound_mapping) { ScopeMapping.new(:name_like, :key => [:first_name, :last_name], :require => :last_name) }
+    let(:mapping) { ScopeMapping.new(:name_like, :to => :name) }
+    let(:compound_mapping) { ScopeMapping.new(:name_like, :to => [:first_name, :last_name], :require => :last_name) }
     let(:query) do
       query = double('query')
       query.stub(:errors).and_return(double('errors'))
@@ -22,14 +22,14 @@ module Paraphrase
       end
 
       it "adds errors to query object if missing and required" do
-        required_mapping = ScopeMapping.new(:name_like, :key => :name, :require => true)
+        required_mapping = ScopeMapping.new(:name_like, :to => :name, :require => true)
 
         query.errors.should_receive(:add)
         required_mapping.chain(query, {}, Account)
       end
 
       it "passes through nil values if scope has been whitelisted" do
-        mapping = ScopeMapping.new(:name_like, :key => :name, :allow_nil => true)
+        mapping = ScopeMapping.new(:name_like, :to => :name, :allow_nil => true)
 
         Account.should_receive(:name_like).with(nil)
         mapping.chain(query, {}, Account)
@@ -42,7 +42,7 @@ module Paraphrase
     end
 
     it "whitelists the the non-required keys of a compound key" do
-      compound_mapping.whitelisted?(:first_name).should be_true
+      compound_mapping.whitelist.include?(:first_name).should be_true
     end
   end
 end

data/spec/paraphrase/syntax_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 module Paraphrase
   describe Syntax do
     describe ".register_mapping" do
-      it "forwards to Paraphrase.register" do
+      it "creates new sublcass of Query" do
         Account.register_mapping {}
         Account.paraphraser.should_not be_nil
       end

data/spec/spec_helper.rb

@@ -1,23 +1,3 @@
 require 'rspec'
 require 'paraphrase'
-require 'active_record'
-
-ActiveRecord::Base.establish_connection(
-  :adapter => 'sqlite3',
-  :database => ':memory:'
-)
-
-ActiveRecord::Base.silence do
-  ActiveRecord::Migration.verbose = false
-
-  ActiveRecord::Schema.define do
-    create_table(:accounts, :force => true) {}
-  end
-end
-
-class Account < ActiveRecord::Base
-  extend Paraphrase::Syntax
-end
-
-class AccountSearch < Paraphrase::Query
-end
+require 'support/database'

data/spec/support/database.rb

@@ -0,0 +1,34 @@
+require 'active_record'
+
+ActiveRecord::Relation.send(:include, Paraphrase::Syntax::Relation)
+
+ActiveRecord::Base.establish_connection(
+  :adapter => 'sqlite3',
+  :database => ':memory:'
+)
+
+ActiveRecord::Base.silence do
+  ActiveRecord::Migration.verbose = false
+
+  ActiveRecord::Schema.define do
+    create_table :users, :force => true do
+    end
+
+    create_table :accounts, :force => true do |t|
+      t.references :user
+    end
+  end
+end
+
+class User < ActiveRecord::Base
+  has_many :accounts
+end
+
+class Account < ActiveRecord::Base
+  extend Paraphrase::Syntax::Base
+  belongs_to :user
+
+  def self.name_like(*args)
+    scoped
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: paraphrase
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-07-07 00:00:00.000000000 Z
+date: 2012-08-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
-  requirement: &70360247937200 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,10 +21,15 @@ dependencies:
         version: '3.0'
   type: :runtime
   prerelease: false
-  version_requirements: *70360247937200
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: activesupport
-  requirement: &70360247936360 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -32,10 +37,15 @@ dependencies:
         version: '3.0'
   type: :runtime
   prerelease: false
-  version_requirements: *70360247936360
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: activemodel
-  requirement: &70360247934800 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -43,10 +53,15 @@ dependencies:
         version: '3.0'
   type: :runtime
   prerelease: false
-  version_requirements: *70360247934800
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: bundler
-  requirement: &70360247926020 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -54,10 +69,15 @@ dependencies:
         version: '1.0'
   type: :development
   prerelease: false
-  version_requirements: *70360247926020
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: yard
-  requirement: &70360247925260 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -65,10 +85,15 @@ dependencies:
         version: '0.7'
   type: :development
   prerelease: false
-  version_requirements: *70360247925260
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.7'
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70360247924500 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -76,54 +101,80 @@ dependencies:
         version: '2.10'
   type: :development
   prerelease: false
-  version_requirements: *70360247924500
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.10'
 - !ruby/object:Gem::Dependency
   name: redcarpet
-  requirement: &70360247923780 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 2.1.1
   type: :development
   prerelease: false
-  version_requirements: *70360247923780
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.1.1
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &70360247922620 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.9.2
   type: :development
   prerelease: false
-  version_requirements: *70360247922620
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.2
 - !ruby/object:Gem::Dependency
   name: sqlite3
-  requirement: &70360247921580 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.3.6
   type: :development
   prerelease: false
-  version_requirements: *70360247921580
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.3.6
 - !ruby/object:Gem::Dependency
   name: appraisal
-  requirement: &70360247921160 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - '='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.4'
   type: :development
   prerelease: false
-  version_requirements: *70360247921160
-description: ! "\n                        Build customizable classes to determine
-  which scope\n                        methods to call based on supplied parameters.\n
-  \                     "
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: '0.4'
+description: ! "\n                        Map query parameters to model scopes, pairing
+  one or\n                        more keys to a scope. Parameters can be required,
+  or\n                        whitelisted providing fine tuned control over how\n
+  \                       scopes are run.\n                      "
 email: edd_d@mit.edu
 executables: []
 extensions: []
@@ -156,6 +207,7 @@ files:
 - spec/paraphrase/scope_mapping_spec.rb
 - spec/paraphrase/syntax_spec.rb
 - spec/spec_helper.rb
+- spec/support/database.rb
 homepage: https://github.com/ecbypi/paraphrase
 licenses:
 - MIT
@@ -177,13 +229,14 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.11
+rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
-summary: Map param keys to class scopes
+summary: Map params to model scopes
 test_files:
 - spec/paraphrase/query_spec.rb
 - spec/paraphrase/scope_mapping_spec.rb
 - spec/paraphrase/syntax_spec.rb
 - spec/spec_helper.rb
+- spec/support/database.rb
 has_rdoc: