paraphrase 0.10.0 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7eee455eab9622de9d86136dfe8d1b5b766373e1
-  data.tar.gz: fbba2474e3febdd44f4937347cdf14888de70125
+  metadata.gz: a1edd35702f438a125a18ad4ad3dd8fc4933c10a
+  data.tar.gz: f31827e436da49e098499f602d0225428492f73c
 SHA512:
-  metadata.gz: 146a851d81c039939c2ba35688aaf55e01bc85bf2d3608a1d5441668aee600e37d46cc03aa8eb51b672e77de9fe1704829b239b3e3dd4f44222a3ad1cfc35711
-  data.tar.gz: d383c9f1d43cd46e979618feb616c34dcc1acd58fdb70b51c9438cf313aef93540f132422712b6f8f6e2ac240dbe259bb9cf65235cb02cb0c7c248beac681e5f
+  metadata.gz: 3901ba0d17fe8e7ec907c92bc51028f35385c2cd8c9d024c952e1a9d644e7685ed0e8d4f0578b146e952292fbe07364bdf3c3a71e52ac920ed3271626c6c8988
+  data.tar.gz: 2114539257bc4b5f2bfb3f55d85625530ec8aeb6d71959ec1ad3fc6a43ffb56ad9905827bd3fe35f22519439914bb33c7d05233893ab3af6159719965795fbf4

data/CHANGELOG.md

@@ -1,14 +1,40 @@
-## Next Release
-
-* Add convenience class-level API for pre-processing query params
-* Pre-process params and then scrub them from
-* Rename `Scope` to the more appropriate `Mapping`
+## 0.11.0 / 9-17-2014
+
+* Enable setting default values in param processors. The following will now
+  work:
+
+```ruby
+class PostQuery < Paraphrase::Query
+  map :sort, to: :sorted_by
+
+  param :sort do
+    params[:sort].presence || "newest"
+  end
+
+  scope :sorted_by do |sort_direction|
+    sort_direction == "newest" ? relation.order(created_at: :desc) : relation.order(:created_at)
+  end
+end
+```
+
+## 0.10.0 / 7-3-2014
+
+* Change `Paraphrase::Query.source` to be a regular class attribute, removing
+  the DSL method `source` for defining the source.
+* Add convenience class-level API for pre-processing query params.
+* Rename `Params` to `ParamsFilter`. Always define a `ParamsFilter` subclass
+  for each `Paraphrase::Query` subclass on inheritance.
+* Make params filtering consistent. Run custom method defiend on `ParamsFilter`
+  and then call `scrub` on the return value. Previously, `scrub` would not be
+  called if a custom method was defined.
+* Rename `Scope` to the more appropriate `Mapping`.
 * Mark `Mapping` and `ActiveModel` classes as private API
-* Add ability to define scopes in the `Query` subclass via `Paraphrase::Repository`
-  (see README)
-* Refactor `Query.source` to be a regular class attribute
-* Require `Paraphrase::Query` be initialized with an `ActiveRecord::Relation`
-  instance. Ensure this happens in `Paraphrase::Syntax`.
+* Add `Paraphrase::Repository` for defining model scopes in a
+  `Paraphrase::Query` subclass.  Scopes can be defined by re-opening the
+  `Repository` class available in any `Paraphrase::Query` subclass or using
+  `Query.scope` DSL. See README for more.
+* Require `Paraphrase::Query` be initialized with an instance of
+  `ActiveRecord::Relation`. Update `Paraphrase::Syntax`
 
 ## 0.9.0 / 5-2-2014
 

data/README.md

@@ -3,125 +3,102 @@
 [![Code Climate](https://codeclimate.com/github/ecbypi/paraphrase.png)](https://codeclimate.com/github/ecbypi/paraphrase)
 [![Build Status](https://travis-ci.org/ecbypi/paraphrase.png?branch=master)](https://travis-ci.org/ecbypi/paraphrase)
 
-Paraphrase provides a way to map query params to model scopes and
-only apply scopes when the mapped query params are present.
+`paraphrase` provides a way to map query params to model scopes and only apply
+scopes when the mapped query params are present, removing all the conditional
+checks you might perform in your controller to determine if a scope needs to be
+applied.
 
-## Installation
+With `paraphrase`, you can also de-clutter your model by removing
+context-specific scopes into the query builder.
 
-Via a `Gemfile`:
+Take the following example:
 
-```
-gem 'paraphrase'
-```
+```ruby
+class PostsController < ActiveRecord::Base
+  def index
+    @posts = Post.all
 
-Or manually:
+    names = params[:names]
 
-```
-$ gem install paraphrase
-```
-
-## Usage
+    if names && names.delete_if { |name| name.blank? }.present?
+      @posts = @posts.published_by(names)
+    end
 
-Subclass `Paraphrase::Query` and use `map` to define what query params should
-be applied to which scopes.
+    start_date = Time.zone.parse(params[:start_date])
+    end_date = Time.zone.parse(params[:end_date])
 
-```ruby
-# app/queries/post_query.rb
-class PostQuery < Paraphrase::Query
-  map :author, to: :by_user
-  map :start_date, :end_date, to: :published_within
+    if start_date && end_date
+      @posts = @posts.published_within(start_date, end_date)
+    end
+  end
 end
-```
 
-By default, the `ActiveRecord` class is introspected from the demodulized class
-name of the `Paraphrase::Query` sublcass.  If the name of the query class is
-not `<model>Query`, the source can be manually specified by passing a string or
-symbol to the `source` method.
+class Post < ActiveRecord::Base
+  def self.published_by(names)
+    joins(:user).where(users: { name: names })
+  end
 
-```ruby
-# app/queries/admin_post_query.rb
-class AdminPostQuery < Paraphrase::Query
-  # This needs the source specific since it will look for an `AdminPost` model.
-  self.source = :Post
+  def self.published_within(start_date, end_date)
+    where(published_at: start_date..end_date)
+  end
 end
 ```
 
-To build the query, call `.paraphrase` on your model.  Only scopes whose keys are all
-provided will be applied.
-
-```ruby
-# Based on the example `PostQuery` above, this will only apply `Post.by_user`
-# and skip `Post.published_within` since `:end_date` is missing.
-Post.paraphrase(author: 'Jim')
-```
+As the number of options for the query grows, the `index` method will continue
+to accrue with conditional checks and the model will become bloated with that
+are might only used in the controller.
 
-All unregistered keys are filered out of the params that are passed to `.paraphrase`.
+By using paraphrase, the controller and model can be simplified to:
 
 ```ruby
-class PostsController < ApplicationController
-  respond_to :html, :json
-
+class PostsController < ActiveRecord::Base
   def index
-    # Will filter out keys such as `:action` and `:controller`
     @posts = Post.paraphrase(params)
-    respond_with(@posts)
   end
 end
-```
 
-`Paraphrase::Query` will recursively determine if the value of the query
-param is empty. If the value is an array containing empty strings, the empty
-strings will be removed before being passed to the scope. If the array is empty
-after removing empty strings, the scope will not be called since an empty array
-is considered a blank value.
+class PostQuery < Paraphrase::Query
+  map :names, to: :published_by
+  map :start_date, :end_date, to: :published_within
 
-```ruby
-class UserQuery < Paraphrase::Query
-  map :names, to: :with_name
-end
+  param :start_date do
+    Time.zone.parse(params[:start_date]) rescue nil
+  end
 
-class User < ActiveRecord::Base
-  def self.with_name(names)
-    where(name: names)
+  param :end_date do
+    Time.zone.parse(params[:end_date]) rescue nil
   end
-end
 
-User.paraphrase(names: ['', 'Jim']).to_sql
-# => SELECT "users".* FROM "users" WHERE "users"."name" IN ['Jim']
+  scope :published_by do |user_names|
+    relation.joins(:user).where(users: { name: user_names })
+  end
+end
 
-User.paraphrase(names: ['', '']).to_sql
-# => SELECT "users".* FROM "users"
+class Post < ActiveRecord::Base
+  def self.published_within(start_date, end_date)
+    where(published_at: start_date..end_date)
+  end
+end
 ```
 
-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 allow you to build a default scope.
-
-```ruby
-class PostsController < ApplicationController
-  respond_to :html, :json
+## Installation
 
-  # GET /users/:id/posts
-  def index
-    @user = User.find(params[:user_id])
+Via a `Gemfile`:
 
-    # This will scope the query to posts where `posts`.`user_id` = `users`.`id`
-    @posts = @users.posts.paraphrase(params[:q])
+```
+gem 'paraphrase'
+```
 
-    # Or you can build at a different point in a scope chain
-    # @posts = @user.posts.published.paraphrase(params[:q])
-    #
-    # Order is independent too
-    # @posts = @user.posts.paraphrase(params[:q]).published
+Or manually:
 
-    respond_with(@posts)
-  end
-end
+```
+$ gem install paraphrase
 ```
 
-### Query Class DSL
+## Usage
 
 Scopes are mapped to param keys using `map`.  You can specify one or more keys.
+The scope will only be called if all the keys are present.
 
 ```ruby
 class PostQuery < Paraphrase::Query
@@ -138,35 +115,84 @@ class Post < ActiveRecord::Base
     where(published_on: pub_date)
   end
 end
+
+Post.paraphrase(first_name: 'Jon', last_name: 'Richards', pub_date: '2010-10-01')
+  # => SELECT "posts".* FROM "posts"i
+  #    WHERE "posts"."first_name" = 'Jon'
+  #      AND "posts.last_name" = 'Richards'
+  #      AND "posts.published_on" = '2010-10-01'
+
+Post.paraphrase(first_name: 'Jon', pub_date: '2010-10-01')
+  # => SELECT "posts".* FROM "posts" WHERE "posts.published_on" = '2010-10-01'
 ```
 
+### Changing the Model Class Used
+
+By default, the `ActiveRecord` class is determined from the `demodulize`'d name
+of the `Paraphrase::Query` sublcass.  For instance, `DeliveryQuery` will use the
+`Delivery` model by default.
+
+If the name of the query class does not match this convention, the source can be
+specified by setting the `source` class atribute.
+
+```ruby
+# app/queries/admin_post_query.rb
+class AdminPostQuery < Paraphrase::Query
+  self.source = :Post
+end
+```
+
+### Whitelisting Query Params
+
 If multiple query params are mapped to a scope, but only a subset are required,
-use the `:whitelist` option to allow them to be blank. The `:whitelist`
-option can be set to `true`, an individual key or an array of keys.
+use the `:whitelist` option to allow them to be blank. The `:whitelist` option
+can be set to `true` to whitelist all keys, an individual key or an array of
+keys.
 
 ```ruby
 class PostQuery < Paraphrase::Query
-  # requires only :last_name to be passed in, :first_name can be nil
   map :first_name, :last_name, to: :by_author, whitelist: :last_name
+  map :pub_date, to: :pub_date
 end
 
 class Post < ActiveRecord::Base
+  # `last_name` will be `nil` if not supplied.
   def self.by_author(first_name, last_name)
-    query = where(user: { first_name: first_name })
+    query = where(users: { first_name: first_name })
 
+    # Only filter by `:last_name` if supplied
     if last_name
-      query = query.where(user: { last_name: last_name })
+      query = query.where(users: { last_name: last_name })
     end
 
     query
   end
 end
 
-Post.paraphrase(first_name: 'John').to_sql
-  # => SELECT "posts".* FROM "posts" WHERE "posts"."first_name" = 'John'
+Post.paraphrase(first_name: 'Jon', pub_date: '2010-10-01')
+  # => SELECT "posts".* FROM "posts"i
+  #    WHERE "posts"."first_name" = 'Jon'
+  #      AND "posts.published_on" = '2010-10-01'
+```
+
+Whitelisting is also useful for query params that are optional and have a
+default, implied value such as with sorting:
+
+```ruby
+class PostQuery < Paraphrase::Query
+  map :sort, to: :sorted_by, whitelist: true
+end
 
-Post.paraphrase(first_name: 'John', last_name: 'Smith').to_sql
-  # => SELECT "posts".* FROM "posts" WHERE "posts"."first_name" = 'John' AND "posts"."last_name" = 'Smith'
+class Post < ActiveRecord::Base
+  def self.sorted_by(sort_direction)
+    case sort_direction
+    when nil, 'newest'
+      order(created_at: :desc)
+    else
+      order(:created_at)
+    end
+  end
+end
 ```
 
 ### Boolean Scopes
@@ -194,21 +220,50 @@ Post.paraphrase(published: '1').to_sql
   # => SELECT "posts".* FROM "posts" WHERE "posts"."published" = 't'
 ```
 
-### Pre-processing Query Params
+### Filtering `blank` Values
+
+By default, `paraphrase` will recursively determine if the value of a query
+param is `blank?`. This is meant to deal with form submissions, since blank
+values are submitted even if the input is not filled in.
+
+For example, if the value is an array containing empty strings, the empty
+strings will be removed before being passed to the scope. If the array is empty
+after removing empty strings, the scope will not be called since an empty array
+is considered a blank value.
+
+```ruby
+class UserQuery < Paraphrase::Query
+  map :names, to: :with_name
+end
+
+class User < ActiveRecord::Base
+  def self.with_name(names)
+    where(name: names)
+  end
+end
+
+User.paraphrase(names: ['', 'Jim']).to_sql
+# => SELECT "users".* FROM "users" WHERE "users"."name" IN ['Jim']
+
+User.paraphrase(names: ['', '']).to_sql
+# => SELECT "users".* FROM "users"
+```
+
+### Pre-processing Values
 
-To pre-process a query param, such as an ISO formatted date, you can either use
-the `param` class method or re-open the `ParamsFilter` class that is defined
-when inheriting from `Paraphrase::Query`. Using the `param` class method
-defines the equivalent method on the `ParamsFilter` class.
+To pre-process a query param, such as an ISO formatted date, you can use the
+`param` class method or re-open the `ParamsFilter` class that is defined when
+inheriting from `Paraphrase::Query`. Using the `param` class method defines the
+equivalent method on the `ParamsFilter` class.
 
-In the method, you have access to the `params` attribute that represents the
-original, unprocessed params.
+In the method, you have access to `params` that represents the original,
+unprocessed params.
 
 ```ruby
 class PostQuery < Paraphrase::Query
   map :start_date, :end_date, to: :published_within
 
-  class ParamsFilter
+  class ParamsFilter < Paraphrase::ParamsFilter
     def start_date
       Time.zone.parse(params[:start_date]) rescue nil
     end
@@ -225,24 +280,30 @@ class Post < ActiveRecord::Base
   end
 end
 
+Post.parahrase(start_date: '2011-03-21', end_date: '2013-03-25').to_sql
+  # => SELECT "posts".* FROM "posts"
+       WHERE "posts"."published_at" BETWEEN '2011-03-21' AND '2013-03-25'
+
+# The typo in the `start_date` query param causes `Time.zone.parse` to fail so
+# the pre-procssed `start_date` is `nil`. Since not all params are present, the
+# scope is not run.
 Post.parahrase(start_date: '201-03-21', end_date: '2013-03-25').to_sql
   # => SELECT "posts".* FROM "posts"
 ```
 
 In the above example, if either `:start_date` or `:end_date` are incorrectly
-formatted, the `pubished_within` scope will not be applied because the values
-are will be `nil`.
+formatted, the `pubished_within` scope will not be applied since
+`Time.zone.parse` will fail and return `nil`.
 
-### Define scopes on the `Query` class
+### Define scopes in the `Query` class
 
-If your model is cluttered with scopes that aren't general-purpose, and only
-used by your query class, you can define them in the query class. You can
-define scopes by re-opening the `Repository` class defined on inheritance from
-`Paraphrase::Query`. There is also the `scope` class method that serves as a
-proxy for defining methods on the `Repository` class.
+Scopes can be defined in the `Query` class using the `scope` keyword or
+re-opening the `Repository` class defined in the `Query` subclass. This helps to
+avoid cluttering the model class with scopes that are only used by the query
+class.
 
-In the method, you have to call the scope on the `relation` property of the
-`Repository` instance.
+When defining scopes this way, any `ActiveRecord::Relation` methods should be
+called on the `relation` property of the `Repository` instance.
 
 ```ruby
 class PostQuery < Paraphrase::Query
@@ -254,18 +315,17 @@ class PostQuery < Paraphrase::Query
     relation.joins(:user).where(users: { name: authors })
   end
 
-  # OR
-  # class Repository
-  #   def by_users(authors)
-  #     relation.joins(:user).where(users: { name: authors })
-  #   end
-  # end
+  class Repository < Paraphrase::Repository
+    def titled(post_title)
+      relation.where(title: post_title)
+    end
+  end
 end
 
 class Post < ActiveRecord::Base
 end
 
-Post.paraphrase(authors: ['Robert', 'Susie']).to_sql
+Post.paraphrase(authors: ['Robert', 'Susie'], title: 'Sunshine').to_sql
 # => SELECT "posts".* FROM "posts"
 #    INNER JOIN "users" ON "users"."id" = "posts"."user_id"
 #    WHERE "users"."name" IN ('Robert', 'Susie')

data/gemfiles/3.1.gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: ../
   specs:
-    paraphrase (0.10.0)
+    paraphrase (0.11.0)
       activemodel (>= 3.1, < 4.2)
       activerecord (>= 3.1, < 4.2)
       activesupport (>= 3.1, < 4.2)

data/gemfiles/3.2.gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: ../
   specs:
-    paraphrase (0.10.0)
+    paraphrase (0.11.0)
       activemodel (>= 3.1, < 4.2)
       activerecord (>= 3.1, < 4.2)
       activesupport (>= 3.1, < 4.2)

data/gemfiles/4.0.gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: ../
   specs:
-    paraphrase (0.10.0)
+    paraphrase (0.11.0)
       activemodel (>= 3.1, < 4.2)
       activerecord (>= 3.1, < 4.2)
       activesupport (>= 3.1, < 4.2)

data/gemfiles/4.1.gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: ../
   specs:
-    paraphrase (0.10.0)
+    paraphrase (0.11.0)
       activemodel (>= 3.1, < 4.2)
       activerecord (>= 3.1, < 4.2)
       activesupport (>= 3.1, < 4.2)

data/lib/paraphrase/mapping.rb

@@ -1,4 +1,3 @@
-require 'active_support/core_ext/object/blank'
 require 'active_support/core_ext/array/wrap'
 
 module Paraphrase

data/lib/paraphrase/params_filter.rb

@@ -1,17 +1,29 @@
+require 'active_support/core_ext/object/blank'
+require 'active_support/hash_with_indifferent_access'
+
 module Paraphrase
+  # {ParamsFilter} is responsible for processing the query params the {Query}
+  # object was initialized with.
+  #
+  # In the following order, it:
+  #
+  # 1. Removes all keys not mapped to a model scope
+  # 2. Pre-processes the query param if a pre-processor is defined
+  # 3. Recursively removes blank values from the value
+  # 4. Removes the param if the pre-processed, scrubbed value is `blank?`
+  #
+  # Each {Query} subclass has its own {ParamsFilter} subclass defined on
+  # inheritance that can be customized to pre-process query params. The class
+  # can be re-opened inside the {Query} class definition or by calling the
+  # {Query.param param} class method.
   class ParamsFilter
     attr_reader :params, :result
 
     def initialize(unfiltered_params, keys)
       @params = unfiltered_params.with_indifferent_access.slice(*keys)
 
-      @result = @params.inject(HashWithIndifferentAccess.new) do |result, (key, value)|
-        value = @params[key]
-
-        if respond_to?(key)
-          value = send(key)
-        end
-
+      @result = keys.inject(HashWithIndifferentAccess.new) do |result, key|
+        value = respond_to?(key) ? send(key) : @params[key]
         value = scrub(value)
 
         if value.present?

data/lib/paraphrase/query.rb

@@ -15,19 +15,16 @@ module Paraphrase
     include ActiveModel
     # @!attribute [r] mappings
     #   @return [Array<Paraphrase::Mapping>] mappings for query
-    # @!attribute [r] source
-    #   @return [Symbol, String] name of the class to use as the source for the
-    #   query
     class_attribute :mappings, instance_writer: false
     class_attribute :source, instance_writer: false, instance_reader: false
     class_attribute :params_filter, instance_writer: false
     class_attribute :repository, instance_writer: false
 
     # @!attribute [r] params
-    #   @return [HashWithIndifferentAccess] filtered parameters based on keys defined in `mappings`
-    #
+    #   @return [HashWithIndifferentAccess] filtered parameters based on keys
+    #     defined in `mappings`
     # @!attribute [r] result
-    #   @return [ActiveRecord::Relation]
+    #   @return [ActiveRecord::Relation] resulting {ActiveRecord::Relation} instance from queries
     attr_reader :params, :result
 
     # Set `mappings` on inheritance to ensure they're unique per subclass
@@ -42,15 +39,15 @@ module Paraphrase
       klass.const_set(:Repository, klass.repository)
     end
 
-    # Keys being mapped to scopes
+    # Keys mapped to scopes
     #
     # @return [Array<Symbol>]
     def self.keys
       mappings.flat_map(&:keys)
     end
 
-    # Add a {Mapping} instance to {Query#mappings}. Defines a reader for each
-    # key to read from {Query#params}.
+    # Add a {Mapping} instance to {Query#mappings}. Defines a reader
+    # for each key to read from {Query#params}.
     #
     # @overload map(*keys, options)
     #   Maps a key to a scope
@@ -78,7 +75,7 @@ module Paraphrase
     # param
     #
     # @param [Symbol] query_param query param to process
-    # @param [Proc] block block to process the query param
+    # @param [Proc] block block to process the specified `query_param`
     def self.param(query_param, &block)
       params_filter.class_eval do
         define_method(query_param, &block)
@@ -86,6 +83,9 @@ module Paraphrase
     end
 
     # Define a scope on `Repository`
+    #
+    # @param [Symbol] scope_name name of the scope specified in {Query.map}
+    # @param [Proc] block body of the scope to be defined
     def self.scope(scope_name, &block)
       repository.class_eval do
         define_method(scope_name, &block)
@@ -95,8 +95,8 @@ module Paraphrase
     # Filters out parameters irrelevant to the query and sets the base scope
     # for to begin the chain.
     #
-    # @param [Hash] params query parameters
-    # @param [ActiveRecord::Relation] relation object to apply methods to
+    # @param [Hash] query_params query parameters
+    # @param [ActiveRecord::Relation] relation relation object to apply methods to
     def initialize(query_params, relation = nil)
       @params = filter_params(query_params || {})
 

data/lib/paraphrase/repository.rb

@@ -1,4 +1,10 @@
 module Paraphrase
+  # {Repository} is were query-specific scopes are defined. They can be defined
+  # by re-opening the class inside the {Query} class definition or by using the
+  # {Query.scope scope} class method on {Query}. Both methods are equivalent.
+  #
+  # Inside scopes defined on a {Repository}, the method has access to
+  # {Query#params} as `params`.
   class Repository
     attr_reader :relation, :mapping, :params
 

data/lib/paraphrase/version.rb

@@ -1,3 +1,3 @@
 module Paraphrase
-  VERSION = "0.10.0"
+  VERSION = "0.11.0"
 end

data/spec/paraphrase/query_spec.rb

@@ -8,6 +8,7 @@ module Paraphrase
       map :is_published, to: :published
       map :authors, to: :by_users
       map :start_date, :end_date, to: :published_between
+      map :sort, to: :sort_by
 
       class ParamsFilter
         def start_date
@@ -17,7 +18,7 @@ module Paraphrase
 
       class Repository
         def published_between(start_date, end_date)
-          where(published_at: start_date..end_date)
+          relation.where(published_at: start_date..end_date)
         end
       end
 
@@ -25,9 +26,17 @@ module Paraphrase
         Time.parse(params[:end_date]) rescue nil
       end
 
+      param :sort do
+        params[:sort].presence || "newest"
+      end
+
       scope :by_users do |authors|
         relation.joins(:user).where(users: { name: authors })
       end
+
+      scope :sort_by do |sort_direction|
+        sort_direction == "newest" ? relation.order("created_at DESC") : relation
+      end
     end
 
     describe ".map" do
@@ -86,21 +95,32 @@ module Paraphrase
         expect(query.params[:authors]).to eq ['kevin']
         expect(query.params).not_to have_key :title
       end
+
+      it "can have default values defined" do
+        query = PostQuery.new(Hash.new)
+
+        expect(query.sort).to eq "newest"
+      end
     end
 
     it 'skips scopes if query params are missing' do
-      expect(Post).not_to receive(:published_between)
-      expect(Post).not_to receive(:titled)
-      expect(Post).not_to receive(:by_users)
-      expect(Post).to receive(:published)
-
-      PostQuery.new(
+      post = Post.create!(
+        published_at: Time.local(2009, 10, 30),
+        title: 'bar',
+        user: User.create!,
+        published: true
+      )
+      params = {
         start_date: Time.local(2010, 10, 30),
         end_date: 'foo',
         is_published: '1',
         authors: [],
         title: ['', {}]
-      )
+      }
+
+      query = PostQuery.new(params)
+
+      expect(query.result).to eq [post]
     end
 
     it 'supports defining scopes in the query class' do

data/spec/spec_helper.rb

@@ -30,6 +30,7 @@ ActiveRecord::Schema.define do
     t.boolean :published
     t.datetime :published_at
     t.references :user
+    t.timestamps
   end
 
   create_table :accounts, force: true do |t|

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: paraphrase
 version: !ruby/object:Gem::Version
-  version: 0.10.0
+  version: 0.11.0
 platform: ruby
 authors:
 - Eduardo Gutierrez
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-03 00:00:00.000000000 Z
+date: 2014-09-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -276,7 +276,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.0
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Map query params to model scopes