mongodoc 0.2.2 → 0.2.4

data/lib/mongodoc/document.rb

@@ -3,7 +3,7 @@ require 'mongodoc/query'
 require 'mongodoc/attributes'
 require 'mongodoc/criteria'
 require 'mongodoc/finders'
-require 'mongodoc/named_scope'
+require 'mongodoc/scope'
 require 'mongodoc/validations/macros'
 
 module MongoDoc
@@ -17,8 +17,9 @@ module MongoDoc
       klass.class_eval do
         include Attributes
         extend ClassMethods
+        extend Criteria
         extend Finders
-        extend NamedScope
+        extend Scope
         include ::Validatable
         extend Validations::Macros
 

data/lib/mongodoc/finders.rb

@@ -1,29 +1,49 @@
+require 'mongodoc/criteria'
+
 module MongoDoc
   module Finders
-    [:all, :count, :first, :last].each do |name|
+    def self.extended(base)
+      base.extend(Criteria) unless base === Criteria
+    end
+
+    %w(count first last).each do |name|
       module_eval <<-RUBY
+        # #{name.humanize} for this +Document+ class
+        #
+        # <tt>Person.#{name}</tt>
         def #{name}
-          Criteria.new(self).#{name}
+          criteria.#{name}
         end
       RUBY
     end
 
-    def criteria
-      Criteria.new(self)
-    end
-
+    # Find a +Document+ based on id (+String+ or +Mongo::ObjectID+)
+    #
+    # <tt>Person.find('1')</tt>
+    # <tt>Person.find(obj_id_1, obj_id_2)</tt>
     def find(*args)
-      query = args.extract_options!
-      which = args.first
-      Criteria.translate(self, query).send(which)
+      criteria.id(*args)
+    end
+    #
+    # Find all +Document+s in the collections
+    #
+    # <tt>Person.find_all</tt>
+    def find_all
+      criteria
     end
 
+    # Find a +Document+ based on id (+String+ or +Mongo::ObjectID+)
+    # or conditions
+    #
+    # <tt>Person.find_one('1')</tt>
+    # <tt>Person.find_one(:where => {:age.gt > 25})</tt>
     def find_one(conditions_or_id)
       if Hash === conditions_or_id
-        Criteria.translate(self, conditions_or_id).one
+        Mongoid::Criteria.translate(self, conditions_or_id).one
       else
-        Criteria.translate(self, conditions_or_id)
+        Mongoid::Criteria.translate(self, conditions_or_id)
       end
     end
+
   end
 end

data/lib/mongodoc/matchers.rb

@@ -0,0 +1,35 @@
+require "mongoid/matchers/default"
+require "mongoid/matchers/all"
+require "mongoid/matchers/exists"
+require "mongoid/matchers/gt"
+require "mongoid/matchers/gte"
+require "mongoid/matchers/in"
+require "mongoid/matchers/lt"
+require "mongoid/matchers/lte"
+require "mongoid/matchers/ne"
+require "mongoid/matchers/nin"
+require "mongoid/matchers/size"
+
+module MongoDoc #:nodoc:
+  module Matchers
+    # Determines if this document has the attributes to match the supplied
+    # MongoDB selector. Used for matching on embedded associations.
+    def matches?(selector)
+      selector.each_pair do |key, value|
+        return false unless matcher(key, value).matches?(value)
+      end
+      true
+    end
+
+    protected
+    # Get the matcher for the supplied key and value. Will determine the class
+    # name from the key.
+    def matcher(key, value)
+      if value.is_a?(Hash)
+        name = "Mongoid::Matchers::#{value.keys.first.gsub("$", "").camelize}"
+        return name.constantize.new(send(key))
+      end
+      Mongoid::Matchers::Default.new(send(key))
+    end
+  end
+end

data/lib/mongodoc/scope.rb

@@ -0,0 +1,64 @@
+# Based on ActiveRecord::NamedScope
+module MongoDoc
+  module Scope
+    def scopes
+      read_inheritable_attribute(:scopes) || write_inheritable_attribute(:scopes, {})
+    end
+
+    def scope(name, *args, &block)
+      options = args.extract_options!
+      raise ArgumentError if args.size != 1
+      criteria = args.first
+      name = name.to_sym
+      scopes[name] = lambda do |parent_scope, *args|
+        CriteriaProxy.new(parent_scope, Mongoid::Criteria === criteria ? criteria : criteria.call(*args), options, &block)
+      end
+      (class << self; self; end).class_eval <<-EOT
+        def #{name}(*args)
+          scopes[:#{name}].call(self, *args)
+        end
+      EOT
+    end
+
+    class CriteriaProxy
+      attr_accessor :criteria, :klass, :parent_scope
+
+      delegate :scopes, :to => :parent_scope
+
+      def initialize(parent_scope, criteria, options, &block)
+        [options.delete(:extend)].flatten.each { |extension| extend extension } if options.include?(:extend)
+        extend Module.new(&block) if block_given?
+        if CriteriaProxy === parent_scope
+          chained = Mongoid::Criteria.new(klass)
+          chained.merge(parent_scope)
+          chained.merge(criteria)
+          self.criteria = chained
+          self.klass = criteria.klass
+        else
+          self.criteria = criteria
+          self.klass = parent_scope
+        end
+
+        self.parent_scope = parent_scope
+      end
+
+      def respond_to?(method, include_private = false)
+        return true if scopes.include?(method)
+        criteria.respond_to?(method, include_private)
+      end
+
+      private
+
+      def method_missing(method, *args, &block)
+        if scopes.include?(method)
+          scopes[method].call(self, *args)
+        else
+          chained = Mongoid::Criteria.new(klass)
+          chained.merge(criteria)
+          chained.send(method, *args, &block)
+        end
+      end
+    end
+  end
+end
+

data/lib/mongoid/contexts/paging.rb

@@ -0,0 +1,42 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Contexts #:nodoc:
+    module Paging
+      # Paginates the documents.
+      #
+      # Example:
+      #
+      # <tt>context.paginate</tt>
+      #
+      # Returns:
+      #
+      # A collection of documents paginated.
+      def paginate
+        @collection ||= execute(true)
+        WillPaginate::Collection.create(page, per_page, count) do |pager|
+          pager.replace(@collection.to_a)
+        end
+      end
+
+      # Either returns the page option and removes it from the options, or
+      # returns a default value of 1.
+      #
+      # Returns:
+      #
+      # An +Integer+ page number.
+      def page
+        skips, limits = options[:skip], options[:limit]
+        (skips && limits) ? (skips + limits) / limits : 1
+      end
+
+      # Get the number of results per page or the default of 20.
+      #
+      # Returns:
+      #
+      # The +Integer+ number of documents in each page.
+      def per_page
+        (options[:limit] || 20).to_i
+      end
+    end
+  end
+end

data/lib/mongoid/criteria.rb

@@ -0,0 +1,264 @@
+# encoding: utf-8
+require "mongoid/criterion/complex"
+require "mongoid/criterion/exclusion"
+require "mongoid/criterion/inclusion"
+require "mongoid/criterion/optional"
+
+module Mongoid #:nodoc:
+  # The +Criteria+ class is the core object needed in Mongoid to retrieve
+  # objects from the database. It is a DSL that essentially sets up the
+  # selector and options arguments that get passed on to a <tt>Mongo::Collection</tt>
+  # in the Ruby driver. Each method on the +Criteria+ returns self to they
+  # can be chained in order to create a readable criterion to be executed
+  # against the database.
+  #
+  # Example setup:
+  #
+  # <tt>criteria = Criteria.new</tt>
+  #
+  # <tt>criteria.only(:field).where(:field => "value").skip(20).limit(20)</tt>
+  #
+  # <tt>criteria.execute</tt>
+  class Criteria
+    include Criterion::Exclusion
+    include Criterion::Inclusion
+    include Criterion::Optional
+    include Enumerable
+
+    attr_reader :collection, :ids, :klass, :options, :selector
+
+    attr_accessor :documents
+
+    delegate \
+      :aggregate,
+      :count,
+      :execute,
+      :first,
+      :group,
+      :id_criteria,
+      :last,
+      :max,
+      :min,
+      :one,
+      :page,
+      :paginate,
+      :per_page,
+      :sum, :to => :context
+
+    # Concatinate the criteria with another enumerable. If the other is a
+    # +Criteria+ then it needs to get the collection from it.
+    def +(other)
+      entries + comparable(other)
+    end
+
+    # Returns the difference between the criteria and another enumerable. If
+    # the other is a +Criteria+ then it needs to get the collection from it.
+    def -(other)
+      entries - comparable(other)
+    end
+
+    # Returns true if the supplied +Enumerable+ or +Criteria+ is equal to the results
+    # of this +Criteria+ or the criteria itself.
+    #
+    # This will force a database load when called if an enumerable is passed.
+    #
+    # Options:
+    #
+    # other: The other +Enumerable+ or +Criteria+ to compare to.
+    def ==(other)
+      case other
+      when Criteria
+        self.selector == other.selector && self.options == other.options
+      when Enumerable
+        return (execute.entries == other)
+      else
+        return false
+      end
+    end
+
+    # Returns true if the criteria is empty.
+    #
+    # Example:
+    #
+    # <tt>criteria.blank?</tt>
+    def blank?
+      count < 1
+    end
+
+    alias :empty? :blank?
+
+    # Return or create the context in which this criteria should be executed.
+    #
+    # This will return an Enumerable context if the class is embedded,
+    # otherwise it will return a Mongo context for root classes.
+    def context
+      @context ||= Contexts.context_for(self)
+    end
+
+    # Iterate over each +Document+ in the results. This can take an optional
+    # block to pass to each argument in the results.
+    #
+    # Example:
+    #
+    # <tt>criteria.each { |doc| p doc }</tt>
+    def each(&block)
+      return caching(&block) if cached?
+      if block_given?
+        execute.each { |doc| yield doc }
+      end
+      self
+    end
+
+    # Merges the supplied argument hash into a single criteria
+    #
+    # Options:
+    #
+    # criteria_conditions: Hash of criteria keys, and parameter values
+    #
+    # Example:
+    #
+    # <tt>criteria.fuse(:where => { :field => "value"}, :limit => 20)</tt>
+    #
+    # Returns <tt>self</tt>
+    def fuse(criteria_conditions = {})
+      criteria_conditions.inject(self) do |criteria, (key, value)|
+        criteria.send(key, value)
+      end
+    end
+
+    # Create the new +Criteria+ object. This will initialize the selector
+    # and options hashes, as well as the type of criteria.
+    #
+    # Options:
+    #
+    # type: One of :all, :first:, or :last
+    # klass: The class to execute on.
+    def initialize(klass)
+      @selector, @options, @klass, @documents = {}, {}, klass, []
+    end
+
+    # Merges another object into this +Criteria+. The other object may be a
+    # +Criteria+ or a +Hash+. This is used to combine multiple scopes together,
+    # where a chained scope situation may be desired.
+    #
+    # Options:
+    #
+    # other: The +Criteria+ or +Hash+ to merge with.
+    #
+    # Example:
+    #
+    # <tt>criteria.merge({ :conditions => { :title => "Sir" } })</tt>
+    def merge(other)
+      @selector.update(other.selector)
+      @options.update(other.options)
+      @documents = other.documents
+    end
+
+    # Used for chaining +Criteria+ scopes together in the for of class methods
+    # on the +Document+ the criteria is for.
+    #
+    # Options:
+    #
+    # name: The name of the class method on the +Document+ to chain.
+    # args: The arguments passed to the method.
+    #
+    # Returns: <tt>Criteria</tt>
+    def method_missing(name, *args)
+      if @klass.respond_to?(name)
+        new_scope = @klass.send(name, *args)
+        new_scope.merge(self)
+        return new_scope
+      else
+        return entries.send(name, *args)
+      end
+    end
+
+    alias :to_ary :to_a
+
+    # Returns the selector and options as a +Hash+ that would be passed to a
+    # scope for use with named scopes.
+    def scoped
+      { :where => @selector }.merge(@options)
+    end
+
+    # Translate the supplied arguments into a +Criteria+ object.
+    #
+    # If the passed in args is a single +String+, then it will
+    # construct an id +Criteria+ from it.
+    #
+    # If the passed in args are a type and a hash, then it will construct
+    # the +Criteria+ with the proper selector, options, and type.
+    #
+    # Options:
+    #
+    # args: either a +String+ or a +Symbol+, +Hash combination.
+    #
+    # Example:
+    #
+    # <tt>Criteria.translate(Person, "4ab2bc4b8ad548971900005c")</tt>
+    # <tt>Criteria.translate(Person, :conditions => { :field => "value"}, :limit => 20)</tt>
+    def self.translate(*args)
+      klass = args[0]
+      params = args[1] || {}
+      unless params.is_a?(Hash)
+        return new(klass).id_criteria(params)
+      end
+      conditions = params.delete(:conditions) || {}
+      if conditions.include?(:id)
+        conditions[:_id] = conditions[:id]
+        conditions.delete(:id)
+      end
+      return new(klass).where(conditions).extras(params)
+    end
+
+    protected
+
+    # Iterate over each +Document+ in the results and cache the collection.
+    def caching(&block)
+      @collection ||= execute
+      if block_given?
+        docs = []
+        @collection.each do |doc|
+          docs << doc
+          yield doc
+        end
+        @collection = docs
+      end
+      self
+    end
+
+    # Filters the unused options out of the options +Hash+. Currently this
+    # takes into account the "page" and "per_page" options that would be passed
+    # in if using will_paginate.
+    #
+    # Example:
+    #
+    # Given a criteria with a selector of { :page => 1, :per_page => 40 }
+    #
+    # <tt>criteria.filter_options</tt> # selector: { :skip => 0, :limit => 40 }
+    def filter_options
+      page_num = @options.delete(:page)
+      per_page_num = @options.delete(:per_page)
+      if (page_num || per_page_num)
+        @options[:limit] = limits = (per_page_num || 20).to_i
+        @options[:skip] = (page_num || 1).to_i * limits - limits
+      end
+    end
+
+    # Return the entries of the other criteria or the object. Used for
+    # comparing criteria or an enumerable.
+    def comparable(other)
+      other.is_a?(Criteria) ? other.entries : other
+    end
+
+    # Update the selector setting the operator on the value for each key in the
+    # supplied attributes +Hash+.
+    #
+    # Example:
+    #
+    # <tt>criteria.update_selector({ :field => "value" }, "$in")</tt>
+    def update_selector(attributes, operator)
+      attributes.each { |key, value| @selector[key] = { operator => value } }; self
+    end
+  end
+end