queryable 2.1.1 → 3.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 47991b347fa04e683c64a77a520c71e01891b471
-  data.tar.gz: 5cd9cece435510a6c432fc82230333c62d7f3b36
+  metadata.gz: c03af4447c57550543e85fbf72d5d6a8611b6480
+  data.tar.gz: 91599f3cac8467d3916886075567896a52082ccc
 SHA512:
-  metadata.gz: a647c943402b09005f4d58b14013f7e366eea865e6e86b2050bc04a5b7f26dd552874e1e2ea27ff6e22f9f0ded5d2f58a070f2e089f5abff396e27fdd9a4d233
-  data.tar.gz: d47b1fc13ac6a04a158f91714d85d5e6674b6e29b827d87f5a75b461c32a171086ce7d52d5c9c4a92160596038c5b4e1303edad562261e87e69252602fcb4d26
+  metadata.gz: 021e3386328437dc3bf6eb22f060cfa5f05bb1d8652436a44f9fb6e457ad1f27f88e1961c132cecbc91f2f7af5be4c280755f1757d51846d4f0faeb274a68b65
+  data.tar.gz: d2471a7f808b810a0a82cd7370e645a2de2b738f13f11f4cd8b8f17d4ab7e9065101ed1023740cc22228a6f7268e3811f040c097ec93f1917bdac9fbe4dcbf65

data/README.md

@@ -44,8 +44,26 @@ CustomerQuery.new(shop.customers).miller_fans
 By default most Array methods are delegated to the internal query. It's possible
 to delegate extra methods to the query by calling `delegate`.
 ```ruby
-def CustomersQuery
-  delegate :update_all, :destroy_all
+class CustomersQuery
+  include Queryable
+
+  delegate :update_all, :destroy_all, :exists?
+end
+```
+
+### Delegate and Chain
+
+Sometimes you want to delegate a method to the internal query, but continue
+working with the query object like if you were calling scopes.
+
+You can achieve that using `delegate_and_chain`, which will delegate the method
+call, assign the return value as the internal query, and return the query object.
+
+```ruby
+class CustomersQuery
+  include Queryable
+
+  delegate_and_chain :where, :order_by
 end
 ```
 
@@ -55,7 +73,24 @@ end
 * You can inherit, mixin, and chain queries in a very natural way.
 * Increased testability, pretty close to being ORM/ODM agnostic.
 
-## Optional Modules
+## Basic Usage
+
+If you are using Mongoid or ActiveRecord, you might want to try the
+`Queryable::Mongoid` and `Queryable::ActiveRecord` modules that already take
+care of delegating and chaining most of the methods in the underlying queries.
+
+```ruby
+class CustomersQuery
+  include Queryable::Mongoid
+end
+
+CustomersQuery.new.where(:amount_purchased.gt => 2).active.asc(:logged_in_at)
+```
+
+This modules also include all the optional modules. If you would like to opt-out
+of the other modules you can follow the approach in the [Notes](https://github.com/ElMassimo/queryable#notes) section.
+
+## Advanced Usage
 There are three opt-in modules that can help you when creating query objects.
 These modules would need to be manually required during app initialization or
 wherever necessary (in Rails, config/initializers).

data/lib/queryable.rb

@@ -38,8 +38,21 @@ module Queryable
 
     # Public: Delegates the specified methods to the internal query.
     def delegate(*methods)
-      to = methods.last.is_a?(Hash) && methods.pop[:to] || :queryable
-      def_delegators(to == :class ? 'self.class' : to, *methods)
+      def_delegators extract_delegation_target(methods), *methods
+    end
+
+    # Public: Delegates the specified methods to the internal query, assigns the
+    # return value, and returns self.
+    def delegate_and_chain(*methods)
+      to = extract_delegation_target(methods)
+      class_eval methods.map { |name| Queryable.chained_method(name, to) }.join
+    end
+
+    # Internal: Extracts the :to option of the arguments, uses the internal
+    # query object as the target if no option is provided.
+    def extract_delegation_target(args)
+      to = args.last.is_a?(Hash) && args.pop[:to] || :queryable
+      to == :class ? 'self.class' : to
     end
 
     # Public: Defines a new method that executes the passed proc or block in
@@ -74,12 +87,23 @@ module Queryable
     end
   end
 
+  # Internal: Generates a method that delegates the call to the an internal
+  # object, assigns the return value, and returns self.
+  #
+  # Returns a String with the code of the method.
+  def self.chained_method(name, accessor)
+    <<-CHAIN
+      def #{name}(*args, &block)
+        @queryable = #{accessor}.__send__(:#{name}, *args, &block)
+        self
+      end
+    CHAIN
+  end
+
   # Internal: Default methods to be delegated to the internal query.
   #
   # Returns an Array with the name of the methods to delegate.
   def self.default_delegated_methods
-    Array.instance_methods - Object.instance_methods +
-    [:all, :where, :distinct, :group, :having, :includes, :joins, :limit, :offset, :order, :reverse_order] +
-    [:==, :as_json, :cache_key, :decorate]
+    Array.instance_methods - Object.instance_methods + [:all, :==, :as_json, :decorate]
   end
 end

data/lib/queryable/active_record.rb

@@ -0,0 +1,30 @@
+require 'queryable/chainable'
+require 'queryable/default_query'
+require 'queryable/default_scope'
+
+# Public: Provides default configuration for query objects that decorate a
+# ActiveRecord::Relation object, delegating the most used methods.
+module Queryable
+  module ActiveRecord
+
+    DELEGATED_METHODS = [
+      :average, :maximum, :minimum, :sum, :exists?, :find_by, :build, :create,
+      :pluck, :entries, :new, :explain
+    ]
+
+    CHAINABLE_METHODS = [
+      :where, :bind, :create_with, :distinct, :eager_load, :extending, :from,
+      :group, :having, :includes, :joins, :limit, :lock, :none, :offset, :order,
+      :preload, :readonly, :references, :reorder, :reverse_order, :select,
+      :uniq, :not, :unscoped, :unscope, :only
+    ]
+
+    # Internal: Adds class methods, and default initialization.
+    def self.included(base)
+      base.send(:include, Chainable, DefaultQuery, DefaultScope, ::Queryable)
+
+      base.delegate *DELEGATED_METHODS
+      base.delegate_and_chain *CHAINABLE_METHODS
+    end
+  end
+end

data/lib/queryable/mongoid.rb

@@ -0,0 +1,30 @@
+require 'queryable/chainable'
+require 'queryable/default_query'
+require 'queryable/default_scope'
+
+# Public: Provides default configuration for query objects that decorate a
+# Mongoid::Criteria object, delegating the most used methods in Criteria.
+module Queryable
+  module Mongoid
+
+    DELEGATED_METHODS = [
+      :avg, :max, :min, :sum, :exists?, :set, :pull, :push, :add_to_set,
+      :find_by, :build, :create, :destroy, :destroy_all, :update, :update_all,
+      :delete, :pluck, :distinct, :selector, :rename, :entries, :new, :explain
+    ]
+
+    CHAINABLE_METHODS = [
+      :where, :ne, :nin, :gt, :gte, :in, :lt, :lte, :between, :and, :or, :not,
+      :intersect, :override, :union, :exists, :elem_match, :with_size,
+      :none, :unscoped, :includes, :order_by, :asc, :desc, :skip, :limit
+    ]
+
+    # Internal: Adds class methods, and default initialization.
+    def self.included(base)
+      base.send(:include, Chainable, DefaultQuery, DefaultScope, ::Queryable)
+
+      base.delegate *DELEGATED_METHODS
+      base.delegate_and_chain *CHAINABLE_METHODS
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: queryable
 version: !ruby/object:Gem::Version
-  version: 2.1.1
+  version: 3.0.2
 platform: ruby
 authors:
 - Máximo Mussini
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-03 00:00:00.000000000 Z
+date: 2014-11-14 00:00:00.000000000 Z
 dependencies: []
 description: Queryable is a module that encapsulates query building so you don't have
   to tuck scopes inside your models.
@@ -21,9 +21,11 @@ extra_rdoc_files:
 files:
 - README.md
 - lib/queryable.rb
+- lib/queryable/active_record.rb
 - lib/queryable/chainable.rb
 - lib/queryable/default_query.rb
 - lib/queryable/default_scope.rb
+- lib/queryable/mongoid.rb
 homepage: https://github.com/ElMassimo/queryable
 licenses:
 - MIT