paraphrase 0.5.0 → 0.6.0

data/Appraisals

@@ -1,17 +1,14 @@
 appraise '3.0' do
   gem 'activerecord', '3.0.15'
-  gem 'activemodel', '3.0.15'
   gem 'activesupport', '3.0.15'
 end
 
 appraise '3.1' do
   gem 'activerecord', '3.1.6'
-  gem 'activemodel', '3.1.6'
   gem 'activesupport', '3.1.6'
 end
 
 appraise '3.2' do
   gem 'activerecord', '3.2.6'
-  gem 'activemodel', '3.2.6'
   gem 'activesupport', '3.2.6'
 end

data/README.md

@@ -1,22 +1,18 @@
 # paraphrase
 
-paraphrase provides a way to map one or multiple request params to model
-scopes.
-
-paraphrase is geared towards building a query-based public API where you may
-want to require certain parameters to prevent consumers from scraping all your
-information or to mitigate large, performance-intensive database queries.
+Paraphrase provides a way to map request params to model scopes and apply those
+scopes based on what params are supplied.  It adds a `.paraphrase` method to
+your model classes and `ActiveRecord::Relation` instances that, after setting
+up your scope => key mappings, will apply scopes if the parameters mapped to a
+scope are present. You can also require and whitelist certain parameters to
+provide more flexibility on complex scopes.
 
 ## Installation
 
-Via a gemfile:
+Via a `Gemfile`:
 
-```ruby
-gem 'paraphrase'
 ```
-
-```
-$ bundle
+gem 'paraphrase'
 ```
 
 Or manually:
@@ -27,39 +23,35 @@ $ gem install paraphrase
 
 ## Usage
 
-### Setup
+Create a subclass of `Paraphrase::Query` or call `register_mapping` from within
+your model to setup mappings.
 
-`Paraphrase::Query` classes can be created in the following ways:
+```ruby
+# app/queries/post_query.rb
+class PostQuery < Paraphrase::Query
+  map :by_user, :to => :author
+end
 
-* Calling `register_mapping` in an `ActiveRecord::Base` subclass:
+# or
 
-```ruby
+# app/models/post.rb
 class Post < ActiveRecord::Base
+  belongs_to :user
+
   register_mapping do
     map :by_user, :to => :author
   end
 
-  def self.by_user(author_name)
-    joins(:user).where(:user => { :name => author_name })
+  def self.by_user(author)
+    where(:user => { :name => author })
   end
 end
 ```
 
-* Subclassing `Paraphrase::Query`:
-
-```ruby
-class PostQuery < Paraphrase::Query
-  # takes the constant or a symbol/string that can be classified
-  # into a constant name
-  paraphrases Post
-
-  map :by_user, :to => :author
-end
-```
-
-### Making a Query
-
-In your controller, call the relevant method based on your setup:
+In the controller, call `.paraphrase` on your model, passing in the hash
+containing the query params. This will filter out the registered parameters,
+calling the scopes whose inputs are supplied. If inputs for a scope are
+missing, it is skipped.
 
 ```ruby
 class PostsController < ApplicationController
@@ -67,45 +59,46 @@ class PostsController < ApplicationController
 
   def index
     @posts = Post.paraphrase(params)
-    # Or if you created a subclass
-    # @posts = PostQuery.new(params)
-
     respond_with(@posts)
   end
 end
 ```
 
-You can scope queries from an association, useful if you have nested resources:
+You can chain queries on an `ActiveRecord::Relation`. This avoids adding scopes
+that replicate the functionality of an association like
+`Post.for_user(user_id)` or allows you to build a default scope.
 
 ```ruby
 class PostsController < ApplicationController
   respond_to :html, :json
 
-  # GET /users/1/posts
+  # GET /users/:id/posts
   def index
     @user = User.find(params[:user_id])
 
-    # This will do a join on the users table, scoping posts to the current user
+    # This will scope the query to posts where `posts`.`user_id` = `users`.`id`
     @posts = @users.posts.paraphrase(params)
 
+    # Or you can build at a different point in a scope chain
+    # @posts = @user.posts.published.paraphrase(params)
+
     respond_with(@posts)
   end
 end
 ```
 
-### Configuring Mappings
+### Query Class DSL
 
-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.
+Scopes are mapped to param keys using the `map` class method provided by
+`Paraphrase::Query`.  You can specify one or more keys.
 
 ```ruby
-class Post < ActiveRecord::Base
-  register_mapping do
-    map :by_user, :to => [:first_name, :last_name]
-    map :published_on, :to => :pub_date
-  end
+class PostQuery < Paraphrase::Query
+  map :by_user, :to => [:first_name, :last_name]
+  map :published_on, :to => :pub_date
+end
 
+class Post < ActiveRecord::Base
   def self.by_user(first_name, last_name)
     joins(:user).where(:user => { :first_name => first_name, :last_name => last_name })
   end
@@ -116,29 +109,88 @@ class Post < ActiveRecord::Base
 end
 ```
 
-If a scope is required for a query to be considered valid, pass `:require =>
-true` or `:require => [:array, :of, :keys]` to the options. If any values are
-missing for the scope, an empty result set will be returned. If a key is an
-array of attributes, you can specify a subset of the key to be required. The
-rest of the attributes will be allowed to be nil.
+If a scope is required for a query to be considered valid, add `:require =>
+true` or `:require => [:array, :of, :keys]` in the options. If any values are
+missing, an empty result set will be returned. If the base key is an
+array, you can specify a subset of the key to be required. In this case, the rest of the
+attributes will be whitelisted.
 
 ```ruby
 class Post < ActiveRecord::Base
   register_mapping do
+    # requires :pub_date to be supplied
     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
+
+    # requires only :last_name to be passed in, :first_name can be nil
+    map :by_author, :to => [:first_name, :last_name], :require => :last_name
+  end
+
+  def self.by_author(first_name, last_name)
+    query = where(:user => { :last_name => last_name })
+
+    if first_name
+      query.where(:user => { :first_name => first_name })
+    end
+
+    query
   end
 end
 
-Post.paraphrase.results # => []
+Post.paraphrase({}).results # => []
 ```
 
-Alternatively, a scope can be whitelisted allowing nil values to be passed to the scope.
+Alternatively, a scope or a subset of its keys can be whitelisted allowing nil
+values to be passed to the scope. This is intended for scopes that alter their
+behavior conditionally on a parameter being present. You should whitelist
+inputs if you still want other scopes to be applied as requiring them will halt
+execution of scopes and return an empty result set.
 
 ```ruby
 class Post < ActiveRecord::Base
   register_mapping do
-    map :by_author, :to => [:first_name, :last_name], :allow_nil => :first_name # :first_name does not need to be specified
+    # :first_name can be nil, :last_name is still required to apply the scope
+    map :by_author, :to => [:first_name, :last_name], :whitelist => :first_name
   end
 end
 ```
+
+### Boolean Scopes
+
+Some scopes take the form of a switch, filtering records based on a boolean
+column. It doesn't make sense for these methods to take any arguments and
+requirng them to would couple them to `Paraphrase::Query` classes in a
+complicated way.
+
+Paraphrase will detect if the method specified takes no arguments.  If not, it
+will call the method without any arguments, assuming the inputs are present and
+valid.
+
+```ruby
+class Post < ActiveRecord::Base
+  register_mapping do
+    map :published, :to => :published
+  end
+
+  # If the params supplied include a non-nil value for :published,
+  # this method will be called.
+  def self.published
+    where('published_at IS NOT NULL')
+  end
+end
+```
+
+### ActiveSupport::Notifications
+
+You can subscribe to notifications when the query is built.
+
+```ruby
+ActiveSupport::Notifications.subscribe('query.paraphrase') do |name, start, end, id, payload|
+  # ...
+end
+```
+
+`payload` contains:
+
+* `:params`: the params filtered
+* `:source_name`: name of the class being queried
+* `:source`: `ActiveRecord::Relation` being used as the base for the query

data/gemfiles/3.0.gemfile.lock

@@ -1,8 +1,7 @@
 PATH
   remote: /Users/edd_d/src/paraphrase
   specs:
-    paraphrase (0.4.0)
-      activemodel (~> 3.0)
+    paraphrase (0.6.0)
       activerecord (~> 3.0)
       activesupport (~> 3.0)
 
@@ -47,11 +46,11 @@ DEPENDENCIES
   activemodel (= 3.0.15)
   activerecord (= 3.0.15)
   activesupport (= 3.0.15)
-  appraisal
+  appraisal (~> 0.4)
   bundler (~> 1.0)
   paraphrase!
-  rake
-  redcarpet
+  rake (~> 0.9.2)
+  redcarpet (~> 2.1.1)
   rspec (~> 2.10)
-  sqlite3
+  sqlite3 (~> 1.3.6)
   yard (~> 0.7)

data/gemfiles/3.1.gemfile.lock

@@ -1,8 +1,7 @@
 PATH
   remote: /Users/edd_d/src/paraphrase
   specs:
-    paraphrase (0.4.0)
-      activemodel (~> 3.0)
+    paraphrase (0.6.0)
       activerecord (~> 3.0)
       activesupport (~> 3.0)
 
@@ -49,11 +48,11 @@ DEPENDENCIES
   activemodel (= 3.1.6)
   activerecord (= 3.1.6)
   activesupport (= 3.1.6)
-  appraisal
+  appraisal (~> 0.4)
   bundler (~> 1.0)
   paraphrase!
-  rake
-  redcarpet
+  rake (~> 0.9.2)
+  redcarpet (~> 2.1.1)
   rspec (~> 2.10)
-  sqlite3
+  sqlite3 (~> 1.3.6)
   yard (~> 0.7)

data/gemfiles/3.2.gemfile.lock

@@ -1,8 +1,7 @@
 PATH
   remote: /Users/edd_d/src/paraphrase
   specs:
-    paraphrase (0.4.0)
-      activemodel (~> 3.0)
+    paraphrase (0.6.0)
       activerecord (~> 3.0)
       activesupport (~> 3.0)
 
@@ -49,11 +48,11 @@ DEPENDENCIES
   activemodel (= 3.2.6)
   activerecord (= 3.2.6)
   activesupport (= 3.2.6)
-  appraisal
+  appraisal (~> 0.4)
   bundler (~> 1.0)
   paraphrase!
-  rake
-  redcarpet
+  rake (~> 0.9.2)
+  redcarpet (~> 2.1.1)
   rspec (~> 2.10)
-  sqlite3
+  sqlite3 (~> 1.3.6)
   yard (~> 0.7)

data/lib/paraphrase/query.rb

@@ -2,46 +2,28 @@ require 'active_support/core_ext/class/attribute'
 require 'active_support/core_ext/module/delegation'
 require 'active_support/core_ext/string/inflections'
 require 'active_support/hash_with_indifferent_access'
-require 'active_model/naming'
 
 module Paraphrase
   class Query
-    extend ActiveModel::Naming
-
     # @!attribute [r] mappings
     #   @return [Array<ScopeMapping>] mappings for query
-    #
-    # @!attribute [r] source
-    #   @return [ActiveRecord::Relation] source to apply scopes to
-    class_attribute :mappings, :source, :instance_writer => false
+    class_attribute :mappings, :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 mappings
-    attr_reader :errors, :params
+    #
+    # @!attribute [r] source
+    #   @return [ActiveRecord::Relation]
+    attr_reader :params, :source
 
     # Set `mappings` on inheritance to ensure they're unique per subclass
     def self.inherited(klass)
       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
-    #   use or the class itself
-    def self.paraphrases(klass)
-      if !klass.is_a?(Class)
-        klass = Object.const_get(klass.to_s.classify)
-      end
-
-      self.source = klass
-    end
-
     # Add a {ScopeMapping} instance to {@@mappings .mappings}
     #
     # @see ScopeMapping#initialize
@@ -53,19 +35,20 @@ module Paraphrase
       mappings << ScopeMapping.new(name, options)
     end
 
-    # Filters out parameters irrelevant to the query
+    # Filters out parameters irrelevant to the query and sets the base scope
+    # for to begin the chain.
     #
     # @param [Hash] params query parameters
-    def initialize(params = {}, relation = nil)
+    # @param [ActiveRecord::Base, ActiveRecord::Relation] source object to
+    #   apply methods to
+    def initialize(params, class_or_relation)
       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
 
-      @errors = ActiveModel::Errors.new(self)
+      @source = class_or_relation.scoped
     end
 
     # Loops through {#mappings} and apply scope methods to {#source}. If values
@@ -75,11 +58,14 @@ module Paraphrase
     def results
       return @results if @results
 
-      results = mappings.inject(@relation) do |query, scope|
-        scope.chain(self, @params, query)
-      end
+      ActiveSupport::Notifications.instrument('query.paraphrase', :params => params, :source_name => source.name, :source => source) do
+        @results = mappings.inject(source) do |query, scope|
+          query = scope.chain(params, query)
 
-      @results = @errors.any? ? [] : results
+          break [] if query.nil?
+          query
+        end
+      end
     end
 
     def respond_to?(name)

data/lib/paraphrase/scope_mapping.rb

@@ -4,34 +4,36 @@ module Paraphrase
     #   @return [Array<Symbol>] param keys to extract
     #
     # @!attribute [r] method_name
-    #   @return [Symbol] scope method name
+    #   @return [Symbol] scope name
     #
-    # @!attribute [r] options
-    #   @return [Hash] configuration options
-    #
-    # @!attribute [r] required_keys
+    # @!attribute [r] required
     #   @return [Array] keys required for query
     #
-    # @!attribute [r] whitelist_keys
+    # @!attribute [r] whitelist
     #   @return [Array] keys allowed to be nil
-    attr_reader :keys, :method_name, :options, :required, :whitelist
+    attr_reader :keys, :method_name, :required, :whitelist
 
     # @param [Symbol] name name of the scope
     # @param [Hash] options options to configure {ScopeMapping ScopeMapping} instance
-    # @option options [Symbol, Array<Symbol>] :key param key(s) to extract values from
-    # @option options [true] :require lists scope as required
+    # @option options [Symbol, Array<Symbol>] :to param key(s) to extract values from
+    # @option options [true, Symbol, Array<Symbol>] :require lists all or a
+    #   subset of param keys as required
+    # @option options [true, Symbol, Array<Symbol>] :whitelist lists all or a
+    #   subset of param keys as whitelisted
     def initialize(name, options)
       @method_name = name
       @keys = Array(options.delete(:to))
 
       @required = register_keys(options[:require])
-      @whitelist = register_keys(options[:allow_nil])
+      @whitelist = register_keys(options[:whitelist])
 
       if @whitelist.empty? && !@required.empty?
         @whitelist = @keys - @required
       end
 
-      @options = options.freeze
+      if (whitelist & required).any?
+        raise ArgumentError, "cannot whitelist and require the same keys"
+      end
     end
 
     # Sends {#method_name} to `chain`, extracting arguments from `params`.  If
@@ -39,23 +41,30 @@ module Paraphrase
     # If {#required? required}, errors are added to the {Query} instance as
     # well.
     #
-    # @param [Query] query {Query} instance applying the scope
     # @param [Hash] params hash of query parameters
-    # @param [ActiveRecord::Relation, ActiveRecord::Base] chain current model scope
+    # @param [ActiveRecord::Relation, ActiveRecord::Base] relation scope chain
     # @return [ActiveRecord::Relation]
-    def chain(query, params, chain)
+    def chain(params, relation)
+      scope = relation.klass.method(method_name)
+
       inputs = keys.map do |key|
         input = params[key]
 
-        if input.nil? && ( required.include?(key) || !whitelist.include?(key) )
-          query.errors.add(key, 'is required') if required.include?(key)
-          break []
+        if input.nil?
+          break    if required.include?(key)
+          break [] if !whitelist.include?(key)
         end
 
         input
       end
 
-      inputs.empty? ? chain : chain.send(method_name, *inputs)
+      if inputs.nil?
+        return
+      elsif inputs.empty?
+        return relation
+      end
+
+      scope.arity == 0 ? scope.call : scope.call(*inputs)
     end
 
     private

data/lib/paraphrase/syntax.rb

@@ -3,26 +3,31 @@ module Paraphrase
     module Base
       def self.extended(klass)
         klass.instance_eval do
-          class_attribute :paraphraser, :instance_writer => false, :instance_reader => false
+          class_attribute :_paraphraser, :instance_writer => false, :instance_reader => false
         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.
+      # Create a {Query} subclass from a block using the `Query` DSL to map
+      # scopes to param keys
       #
-      # @param [Proc] &block block to define scope mappings
+      # @param [Proc] &block block to to define scope mappings
       def register_mapping(&block)
-        klass = Class.new(Query, &block)
-        klass.source = self
-        self.paraphraser = klass
+        self._paraphraser = Class.new(Query, &block)
+      end
+
+      # Attempts to find paraphrase class based on class name.  Override if
+      # using a different naming convention.
+      def paraphraser
+        self._paraphraser || "#{self.name}Query".constantize
+      rescue
+        nil
       end
 
       # Instantiate the {Query} class that is mapped to `self`.
       #
       # @param [Hash] params query parameters
       def paraphrase(params)
-        self.paraphraser.new(params)
+        self.paraphraser.new(params, self)
       end
     end
 
@@ -53,7 +58,7 @@ module Paraphrase
       # # => 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
+      # @param [Hash] params query parameters
       # @return [Paraphrase::Query]
       def paraphrase(params)
         klass.paraphraser.new(params, self)

data/lib/paraphrase/version.rb

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

data/paraphrase.gemspec

@@ -24,7 +24,6 @@ Gem::Specification.new do |gem|
 
   gem.add_dependency 'activerecord', '~> 3.0'
   gem.add_dependency 'activesupport', '~> 3.0'
-  gem.add_dependency 'activemodel', '~> 3.0'
 
   gem.add_development_dependency 'bundler', '~> 1.0'
   gem.add_development_dependency 'yard', '~> 0.7'
@@ -32,5 +31,5 @@ Gem::Specification.new do |gem|
   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'
+  gem.add_development_dependency 'appraisal', '~> 0.4'
 end

data/spec/paraphrase/query_spec.rb

@@ -2,34 +2,22 @@ require 'spec_helper'
 
 module Paraphrase
   describe Query do
+    subject { AccountQuery }
+    let(:query) { Account.paraphrase(:name => 'Tyrion Lannister', :nickname => 'Half Man') }
 
-    class AccountSearch < Query
-    end
-
-    describe ".paraphrases" do
-      it "stores the class being queried" do
-        AccountSearch.paraphrases :account
-        AccountSearch.source.should eq Account
-      end
-    end
-
-    describe ".scope" do
+    describe ".map" do
       it "adds information to Query.mappings" do
-        AccountSearch.instance_eval do
-          map :name_like, :to => :name
-        end
+        subject.map :name_like, :to => :name
 
-        AccountSearch.mappings.should_not be_empty
+        subject.mappings.should_not be_empty
       end
 
       it "raises an error if a scope is added twice" do
-        expect { AccountSearch.instance_eval { map :name_like, :to => :name } }.to raise_error Paraphrase::DuplicateScopeError
+        expect { subject.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') }
-
+    describe "on initialization" do
       it "filters out params not specified in mappings" do
         query.params.should_not have_key :nickname
         query.params.should have_key :name
@@ -38,38 +26,24 @@ 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
-          map :title_like, :to => :title, :require => true
-        end
+        subject.map :title_like, :to => :title, :require => true
       end
 
       it "loops through scope methods and applies them to source" do
         Account.should_receive(:title_like).and_return(Account.scoped)
         Account.should_receive(:name_like).and_return(Account.scoped)
 
-        query = AccountSearch.new(:name => 'Jon Snow', :title => 'Wall Watcher')
+        query = Account.paraphrase(:name => 'Jon Snow', :title => 'Wall Watcher')
         query.results
       end
 
-      it "returns empty array if errors were added" do
-        query = AccountSearch.new
+      it "returns empty array if inputs were missing and required" do
+        query = Account.paraphrase({})
         query.results.should eq []
-        query.errors.should_not be_empty
       end
     end
   end

data/spec/paraphrase/scope_mapping_spec.rb

@@ -4,41 +4,30 @@ module Paraphrase
   describe ScopeMapping do
     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'))
-      query
-    end
+    let(:query) { Account.scoped }
 
     describe "#chain" do
       it "applies scope method to query object with values from params hash" do
         Account.should_receive(:name_like).with('Jon Snow')
-        mapping.chain(query, { :name => 'Jon Snow' }, Account)
+        mapping.chain({ :name => 'Jon Snow' }, query)
       end
 
       it "does nothing if values are missing" do
         Account.should_not_receive(:name_like).with('Jon Snow')
-        mapping.chain(query, {}, Account)
-      end
-
-      it "adds errors to query object if missing and required" do
-        required_mapping = ScopeMapping.new(:name_like, :to => :name, :require => true)
-
-        query.errors.should_receive(:add)
-        required_mapping.chain(query, {}, Account)
+        mapping.chain({}, query)
       end
 
       it "passes through nil values if scope has been whitelisted" do
-        mapping = ScopeMapping.new(:name_like, :to => :name, :allow_nil => true)
+        mapping = ScopeMapping.new(:name_like, :to => :name, :whitelist => true)
 
         Account.should_receive(:name_like).with(nil)
-        mapping.chain(query, {}, Account)
+        mapping.chain({}, query)
       end
     end
 
     it "can require a subset of a compound key" do
       Account.should_receive(:name_like).with(nil, 'Lannister')
-      compound_mapping.chain(query, { :last_name => 'Lannister' }, Account)
+      compound_mapping.chain({ :last_name => 'Lannister' }, query)
     end
 
     it "whitelists the the non-required keys of a compound key" do

data/spec/paraphrase/syntax_spec.rb

@@ -1,11 +1,13 @@
 require 'spec_helper'
 
 module Paraphrase
-  describe Syntax do
-    describe ".register_mapping" do
-      it "creates new sublcass of Query" do
-        Account.register_mapping {}
-        Account.paraphraser.should_not be_nil
+  module Syntax
+    describe Base do
+      describe "#register_mapping" do
+        it "creates new sublcass of Query" do
+          Account.register_mapping {}
+          Account._paraphraser.should_not be_nil
+        end
       end
     end
   end

data/spec/support/database.rb

@@ -28,7 +28,14 @@ class Account < ActiveRecord::Base
   extend Paraphrase::Syntax::Base
   belongs_to :user
 
+  def self.title_like(*args)
+    scoped
+  end
+
   def self.name_like(*args)
     scoped
   end
 end
+
+class AccountQuery < Paraphrase::Query
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: paraphrase
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-08-08 00:00:00.000000000 Z
+date: 2012-08-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -43,22 +43,6 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: '3.0'
-- !ruby/object:Gem::Dependency
-  name: activemodel
-  requirement: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: '3.0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -160,7 +144,7 @@ dependencies:
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - '='
+    - - ~>
       - !ruby/object:Gem::Version
         version: '0.4'
   type: :development
@@ -168,7 +152,7 @@ dependencies:
   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