queryable 1.0.1 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d01fa7b43b3b44643d009f15e6438ef3fd4a665f
-  data.tar.gz: 75164b6c8f28fb3db7e6b182a3f18bf50aa386f8
+  metadata.gz: 28570cfafe1680583b92ea618a85cbca197f5c4b
+  data.tar.gz: 981e0042933205c1bf4c10daa8db4dcecec540f0
 SHA512:
-  metadata.gz: 994927851ef85e8a225f3cb8c21cac6eb21d9d97ac336ca7992d0b4594d8aafab58130e3d60e590b044f331fd7214b99b14fa00b5d56995b3bf0594d001c1b67
-  data.tar.gz: 4f0c6d2d977f9d5ba763c414f2fe434da06c089a8ca628e6358fba8899396fbd3c6a3fd0bfb80a597e44117a163b0e9870a417f6eb1ec5aef22080f76e8a77ea
+  metadata.gz: ecfd3bb32c31a300bd768cbf82d5f42628e1012259de2df4c174d68ad2ba368d2db4a0666dfb482ff7a94391dedbef9c6e658c3fba19a62c14ee2ff9fd2119ae
+  data.tar.gz: 318dea62093ecd3e8defe4e3b87bbf0b0a5169980164d5597e1ed51bfe06193a731d577bcf05a029b96fecd3939c518ac910e970e0606258ea44c31627831d91

data/README.md

@@ -3,6 +3,7 @@ Queryable
 [![Gem Version](https://badge.fury.io/rb/queryable.svg)](http://badge.fury.io/rb/queryable)
 [![Build Status](https://travis-ci.org/ElMassimo/queryable.svg)](https://travis-ci.org/ElMassimo/queryable)
 [![Coverage Status](https://coveralls.io/repos/ElMassimo/queryable/badge.png)](https://coveralls.io/r/ElMassimo/queryable)
+[![Inline docs](http://inch-ci.org/github/ElMassimo/queryable.svg)](http://inch-ci.org/github/ElMassimo/queryable)
 <!-- [![Code Climate](https://codeclimate.com/github/ElMassimo/queryable.png)](https://codeclimate.com/github/ElMassimo/queryable) -->
 
 Queryable is a mixin that allows you to easily define query objects with chainable scopes.

data/lib/queryable.rb

@@ -9,19 +9,19 @@
 #     include Queryable
 #     scope(:too_damn_high) { where(:level.gt => 9000) }
 #   end
-#
+#'
 module Queryable
 
   # Internal: Adds class methods, a query accessor, and method delegation.
   def self.included(base)
-    base.extend ClassMethods
     base.extend Forwardable
+    base.extend ClassMethods
     base.class_eval do
-
       # Public: Gets/Sets the internal query.
       attr_accessor :query
 
-      def_delegators :query, *delegated_methods
+      # Internal: Delegates Array and Criteria methods to the internal query.
+      delegate *Queryable.default_delegated_methods
     end
   end
 
@@ -32,47 +32,15 @@ module Queryable
     @query = query.all
   end
 
-  # Public: Convenience setter for the internal query that returns self. The
-  # query is set to the value returned by the block. Useful when you need to
-  # access the context of the Queryable in addition to the query.
-  #
-  # block - A block that returns the new value of the internal query.
-  #
-  # Yields the internal query, which can be used to build upon.
-  #  def search(query)
-  #
-  # Examples
-  #
-  #   # Accessing a constant in the Queryable object context.
-  #   LATEST_COUNT = 10
-  #   def latest
-  #     define_query {|query| query.limit(LATEST_COUNT) }
-  #   end
-  #
-  #   # We use it because the last method we chain does not return self.
-  #   def recent_by_name
-  #     define_query { recent.order(:name) }
-  #   end
-  #
-  #   # Extracted from a scope for clarity.
-  #   def search(field_values)
-  #     define_query do |users|
-  #       field_values.inject(users) { |users, (field, value)|
-  #         users.where(field => /#{value}/i)
-  #       }
-  #     end
-  #   end
-  #
-  # Returns the Queryable object itself (self).
-  def define_query
-    @query = yield(query)
-    self
-  end
-
   # Internal: Contains the Queryable class methods.
   module ClassMethods
-    # Public: Defines a new method that executes the passed proc or block in
-    # the context of the internal query object, and returns self.
+
+    # Public: Delegates the specified methods to the internal query.
+    def delegate(*methods)
+      methods.last.is_a?(Hash) ? super : def_delegators(:query, *methods)
+    end
+
+    # Public: Defines a new scope method, or makes an existing method chainable.
     #
     # name - Name of the scope to define for this Queryable.
     #
@@ -94,22 +62,59 @@ module Queryable
     #     where(_type: "#{brand}ExtremelyFastRacingCar")
     #   end
     #
+    #   scope def search(field_values)
+    #     field_values.inject(query) { |query, (field, value)|
+    #       query.where(field => /#{value}/i)
+    #     }
+    #   end
+    #
     # Returns nothing.
     def scope(name, proc=nil, &block)
+      if method_defined?(name)
+        scope_method(name)
+      else
+        define_scope(name, proc || block)
+      end
+    end
+
+    private
+
+    # Internal: Defines a new method that executes the passed proc or block in
+    # the context of the internal query object, and returns self.
+    def define_scope(name, proc)
       define_method(name) do |*args|
-        @query = query.instance_exec *args, &(proc || block)
+        @query = query.instance_exec *args, &proc
         self
       end
     end
 
-    # Internal: Methods to be delegated to the internal query. Method
-    # can be safely overriden to add or remove methods to delegate.
-    #
-    # Returns an Array with the name of the methods to delegate.
-    def 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]
+    # Public: Makes an existing method chainable by intercepting the call, and
+    # storing the result as the internal query, and returning self.
+    def scope_method(name)
+      prepend Module.new.tap { |s| s.module_eval Queryable.scope_method(name) }
     end
   end
+
+  # Internal: Generates the scope interceptor method.
+  #
+  # name - Name of the method to convert to a scope.
+  #
+  # Returns a String with the code of the scope method.
+  def self.scope_method(name)
+    <<-SCOPE
+      def #{name}(*args)
+        @query = super
+        self
+      end
+    SCOPE
+  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]
+  end
 end

data/lib/queryable/default_query.rb

@@ -0,0 +1,40 @@
+# Public: Provides default initialization for query objects, most objects are
+# mapped to a collection or table, the default query takes all of them.
+module Queryable
+  module DefaultQuery
+
+    # Internal: Adds class methods, and default initialization.
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    def initialize(query=self.class.default_query)
+      super
+    end
+
+    module ClassMethods
+
+      # Public: Sets the default table or collection for this query object.
+      #
+      # collection - A model or static query.
+      def queryable(collection)
+        @queryable_class = collection
+      end
+
+      # Internal: Default query for the object, can be overriden by subclasses.
+      #
+      # Returns a criteriable or chainable query of some sort.
+      def default_query
+        queryable_class.all
+      end
+
+      # Internal: The default table or collection for this query object.
+      # Provides a default based on a convention of the query object name.
+      def queryable_class
+        @queryable_class ||= if superclass.respond_to?(:queryable_class)
+          superclass.queryable_class || Object.const_get(name.gsub('sQuery', ''))
+        end
+      end
+    end
+  end
+end

data/lib/queryable/default_scope.rb

@@ -0,0 +1,53 @@
+# Public: Allows to define default scopes in query objects, and inherit them in
+# query object subclasses.
+module Queryable
+  module DefaultScope
+
+    # Internal: Adds class methods, and default initialization.
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    def initialize(*args)
+      super
+      apply_default_scopes
+    end
+
+    private
+
+    # Internal: Applies all the default scopes to this query object.
+    def apply_default_scopes
+      self.class.default_scopes.each { |scope| apply_default_scope(scope) }
+    end
+
+    # Internal: Applies a default scope to this query object.
+    #
+    # scope - A method name Symbol, or a Proc.
+    #
+    def apply_default_scope(scope)
+      scope.is_a?(Proc) ? instance_exec(&scope) : send(scope)
+    end
+
+    module ClassMethods
+
+      # Public: Allows a class to set a default scope. Default scopes are
+      # chainable with inheritance, so a subclass also picks up the default
+      # scopes of the parent class.
+      #
+      # scope - A method name Symbol, or a Proc.
+      def default_scope(scope)
+        @default_scope = scope
+      end
+
+      # Internal: Returns the default scopes of the parent query objects.
+      def parent_scopes
+        superclass.respond_to?(:default_scopes) ? superclass.default_scopes : []
+      end
+
+      # Internal: Returns the default scopes that should be applied.
+      def default_scopes
+        @default_scopes ||= (parent_scopes + [@default_scope]).compact
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: queryable
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 2.0.0
 platform: ruby
 authors:
 - Máximo Mussini
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-12 00:00:00.000000000 Z
+date: 2014-08-12 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,6 +21,8 @@ extra_rdoc_files:
 files:
 - README.md
 - lib/queryable.rb
+- lib/queryable/default_query.rb
+- lib/queryable/default_scope.rb
 homepage: https://github.com/ElMassimo/queryable
 licenses:
 - MIT
@@ -47,4 +49,3 @@ signing_key:
 specification_version: 4
 summary: Keep your scopes and queries flexible by using Ruby
 test_files: []
-has_rdoc: