mongoid 1.0.6 → 1.1.0

data/lib/mongoid/contexts/mongo.rb

@@ -0,0 +1,228 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Contexts #:nodoc:
+    class Mongo
+      include Paging
+      attr_reader :selector, :options, :klass
+
+      AGGREGATE_REDUCE = "function(obj, prev) { prev.count++; }"
+      # Aggregate the context. This will take the internally built selector and options
+      # and pass them on to the Ruby driver's +group()+ method on the collection. The
+      # collection itself will be retrieved from the class provided, and once the
+      # query has returned it will provided a grouping of keys with counts.
+      #
+      # Example:
+      #
+      # <tt>context.aggregate</tt>
+      #
+      # Returns:
+      #
+      # A +Hash+ with field values as keys, counts as values
+      def aggregate
+        @klass.collection.group(@options[:fields], @selector, { :count => 0 }, AGGREGATE_REDUCE, true)
+      end
+
+      # Get the count of matching documents in the database for the context.
+      #
+      # Example:
+      #
+      # <tt>context.count</tt>
+      #
+      # Returns:
+      #
+      # An +Integer+ count of documents.
+      def count
+        @count ||= @klass.collection.find(@selector, process_options).count
+      end
+
+      GROUP_REDUCE = "function(obj, prev) { prev.group.push(obj); }"
+      # Groups the context. This will take the internally built selector and options
+      # and pass them on to the Ruby driver's +group()+ method on the collection. The
+      # collection itself will be retrieved from the class provided, and once the
+      # query has returned it will provided a grouping of keys with objects.
+      #
+      # Example:
+      #
+      # <tt>context.group</tt>
+      #
+      # Returns:
+      #
+      # A +Hash+ with field values as keys, arrays of documents as values.
+      def group
+        @klass.collection.group(
+          @options[:fields],
+          @selector,
+          { :group => [] },
+          GROUP_REDUCE,
+          true
+        ).collect do |docs|
+          docs["group"] = docs["group"].collect do |attrs|
+            instantiate(attrs)
+          end
+          docs
+        end
+      end
+
+      # Execute the context. This will take the selector and options
+      # and pass them on to the Ruby driver's +find()+ method on the collection. The
+      # collection itself will be retrieved from the class provided, and once the
+      # query has returned new documents of the type of class provided will be instantiated.
+      #
+      # Example:
+      #
+      # <tt>mongo.execute</tt>
+      #
+      # Returns:
+      #
+      # An +Array+ of documents
+      def execute
+        attributes = @klass.collection.find(@selector, process_options)
+        if attributes
+          @count = attributes.count
+          attributes.collect { |doc| instantiate(doc) }
+        else
+          []
+        end
+      end
+
+      # Create the new mongo context. This will execute the queries given the
+      # selector and options against the database.
+      #
+      # Example:
+      #
+      # <tt>Mongoid::Contexts::Mongo.new(selector, options, klass)</tt>
+      def initialize(selector, options, klass)
+        @selector, @options, @klass = selector, options, klass
+        if klass.hereditary
+          @hereditary = true
+        end
+      end
+
+      # Return the last result for the +Context+. Essentially does a find_one on
+      # the collection with the sorting reversed. If no sorting parameters have
+      # been provided it will default to ids.
+      #
+      # Example:
+      #
+      # <tt>context.last</tt>
+      #
+      # Returns:
+      #
+      # The last document in the collection.
+      def last
+        opts = process_options
+        sorting = opts[:sort]
+        sorting = [[:_id, :asc]] unless sorting
+        opts[:sort] = sorting.collect { |option| [ option[0], option[1].invert ] }
+        attributes = @klass.collection.find_one(@selector, opts)
+        attributes ? instantiate(attributes) : nil
+      end
+
+      MAX_REDUCE = "function(obj, prev) { if (prev.max == 'start') { prev.max = obj.[field]; } " +
+        "if (prev.max < obj.[field]) { prev.max = obj.[field]; } }"
+      # Return the max value for a field.
+      #
+      # This will take the internally built selector and options
+      # and pass them on to the Ruby driver's +group()+ method on the collection. The
+      # collection itself will be retrieved from the class provided, and once the
+      # query has returned it will provided a grouping of keys with sums.
+      #
+      # Example:
+      #
+      # <tt>context.max(:age)</tt>
+      #
+      # Returns:
+      #
+      # A numeric max value.
+      def max(field)
+        grouped(:max, field.to_s, MAX_REDUCE)
+      end
+
+      MIN_REDUCE = "function(obj, prev) { if (prev.min == 'start') { prev.min = obj.[field]; } " +
+        "if (prev.min > obj.[field]) { prev.min = obj.[field]; } }"
+      # Return the min value for a field.
+      #
+      # This will take the internally built selector and options
+      # and pass them on to the Ruby driver's +group()+ method on the collection. The
+      # collection itself will be retrieved from the class provided, and once the
+      # query has returned it will provided a grouping of keys with sums.
+      #
+      # Example:
+      #
+      # <tt>context.min(:age)</tt>
+      #
+      # Returns:
+      #
+      # A numeric minimum value.
+      def min(field)
+        grouped(:min, field.to_s, MIN_REDUCE)
+      end
+
+      # Return the first result for the +Context+.
+      #
+      # Example:
+      #
+      # <tt>context.one</tt>
+      #
+      # Return:
+      #
+      # The first document in the collection.
+      def one
+        attributes = @klass.collection.find_one(@selector, process_options)
+        attributes ? instantiate(attributes) : nil
+      end
+
+      alias :first :one
+
+      SUM_REDUCE = "function(obj, prev) { if (prev.sum == 'start') { prev.sum = 0; } prev.sum += obj.[field]; }"
+      # Sum the context.
+      #
+      # This will take the internally built selector and options
+      # and pass them on to the Ruby driver's +group()+ method on the collection. The
+      # collection itself will be retrieved from the class provided, and once the
+      # query has returned it will provided a grouping of keys with sums.
+      #
+      # Example:
+      #
+      # <tt>context.sum(:age)</tt>
+      #
+      # Returns:
+      #
+      # A numeric value that is the sum.
+      def sum(field)
+        grouped(:sum, field.to_s, SUM_REDUCE)
+      end
+
+      protected
+      # Common functionality for grouping operations. Currently used by min, max
+      # and sum. Will gsub the field name in the supplied reduce function.
+      def grouped(start, field, reduce)
+        collection = @klass.collection.group(
+          nil,
+          @selector,
+          { start => "start" },
+          reduce.gsub("[field]", field),
+          true
+        )
+        collection.first[start.to_s]
+      end
+
+      # If hereditary instantiate by _type otherwise use the klass.
+      def instantiate(attrs)
+        @hereditary ? attrs["_type"].constantize.instantiate(attrs) : @klass.instantiate(attrs)
+      end
+
+      # Filters the field list. If no fields have been supplied, then it will be
+      # empty. If fields have been defined then _type will be included as well.
+      def process_options
+        fields = @options[:fields]
+        if fields && fields.size > 0 && !fields.include?(:_type)
+          fields << :_type
+          @options[:fields] = fields
+        end
+        @options.dup
+      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
+        WillPaginate::Collection.create(page, per_page, count) do |pager|
+          pager.replace(@collection)
+        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

@@ -17,8 +17,36 @@ module Mongoid #:nodoc:
   class Criteria
     include Enumerable
 
+    attr_accessor :documents
     attr_reader :klass, :options, :selector
 
+    delegate \
+      :aggregate,
+      :count,
+      :execute,
+      :first,
+      :group,
+      :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 + (other.is_a?(Criteria) ? other.entries : 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 - (other.is_a?(Criteria) ? other.entries : other)
+    end
+
     # Returns true if the supplied +Enumerable+ or +Criteria+ is equal to the results
     # of this +Criteria+ or the criteria itself.
     #
@@ -39,19 +67,6 @@ module Mongoid #:nodoc:
       end
     end
 
-    AGGREGATE_REDUCE = "function(obj, prev) { prev.count++; }"
-    # Aggregate the criteria. This will take the internally built selector and options
-    # and pass them on to the Ruby driver's +group()+ method on the collection. The
-    # collection itself will be retrieved from the class provided, and once the
-    # query has returned it will provided a grouping of keys with counts.
-    #
-    # Example:
-    #
-    # <tt>criteria.select(:field1).where(:field1 => "Title").aggregate(Person)</tt>
-    def aggregate
-      @klass.collection.group(@options[:fields], @selector, { :count => 0 }, AGGREGATE_REDUCE, true)
-    end
-
     # Adds a criterion to the +Criteria+ that specifies values that must all
     # be matched in order to return results. Similar to an "in" clause but the
     # underlying conditional logic is an "AND" and not an "OR". The MongoDB
@@ -92,15 +107,12 @@ module Mongoid #:nodoc:
       where(selector)
     end
 
-    # Get the count of matching documents in the database for the +Criteria+.
-    #
-    # Example:
-    #
-    # <tt>criteria.count</tt>
+    # Return or create the context in which this criteria should be executed.
     #
-    # Returns: <tt>Integer</tt>
-    def count
-      @count ||= @klass.collection.find(@selector, process_options).count
+    # This will return an Enumerable context if the class is embedded,
+    # otherwise it will return a Mongo context for root classes.
+    def context
+      @context ||= determine_context
     end
 
     # Merges the supplied argument hash into a single criteria
@@ -167,30 +179,6 @@ module Mongoid #:nodoc:
       @options = extras; filter_options; self
     end
 
-    GROUP_REDUCE = "function(obj, prev) { prev.group.push(obj); }"
-    # Groups the criteria. This will take the internally built selector and options
-    # and pass them on to the Ruby driver's +group()+ method on the collection. The
-    # collection itself will be retrieved from the class provided, and once the
-    # query has returned it will provided a grouping of keys with objects.
-    #
-    # Example:
-    #
-    # <tt>criteria.select(:field1).where(:field1 => "Title").group(Person)</tt>
-    def group
-      @klass.collection.group(
-        @options[:fields],
-        @selector,
-        { :group => [] },
-        GROUP_REDUCE,
-        true
-      ).collect do |docs|
-        docs["group"] = docs["group"].collect do |attrs|
-          instantiate(attrs)
-        end
-        docs
-      end
-    end
-
     # Adds a criterion to the +Criteria+ that specifies values where any can
     # be matched in order to return results. This is similar to an SQL "IN"
     # clause. The MongoDB conditional operator that will be used is "$in".
@@ -234,29 +222,13 @@ module Mongoid #:nodoc:
     # type: One of :all, :first:, or :last
     # klass: The class to execute on.
     def initialize(klass)
-      @selector, @options, @klass = {}, {}, klass
+      @selector, @options, @klass, @documents = {}, {}, klass, []
       if klass.hereditary
         @selector = { :_type => { "$in" => klass._types } }
         @hereditary = true
       end
     end
 
-    # Return the last result for the +Criteria+. Essentially does a find_one on
-    # the collection with the sorting reversed. If no sorting parameters have
-    # been provided it will default to ids.
-    #
-    # Example:
-    #
-    # <tt>Criteria.select(:name).where(:name = "Chrissy").last</tt>
-    def last
-      opts = process_options
-      sorting = opts[:sort]
-      sorting = [[:_id, :asc]] unless sorting
-      opts[:sort] = sorting.collect { |option| [ option[0], option[1].invert ] }
-      attributes = @klass.collection.find_one(@selector, opts)
-      attributes ? instantiate(attributes) : nil
-    end
-
     # Adds a criterion to the +Criteria+ that specifies the maximum number of
     # results to return. This is mostly used in conjunction with <tt>skip()</tt>
     # to handle paginated results.
@@ -274,38 +246,6 @@ module Mongoid #:nodoc:
       @options[:limit] = value; self
     end
 
-    MIN_REDUCE = "function(obj, prev) { if (prev.min == 'start') { prev.min = obj.[field]; } " +
-      "if (prev.min > obj.[field]) { prev.min = obj.[field]; } }"
-    # Return the min value for a field.
-    #
-    # This will take the internally built selector and options
-    # and pass them on to the Ruby driver's +group()+ method on the collection. The
-    # collection itself will be retrieved from the class provided, and once the
-    # query has returned it will provided a grouping of keys with sums.
-    #
-    # Example:
-    #
-    # <tt>criteria.min(:age)</tt>
-    def min(field)
-      grouped(:min, field.to_s, MIN_REDUCE)
-    end
-
-    MAX_REDUCE = "function(obj, prev) { if (prev.max == 'start') { prev.max = obj.[field]; } " +
-      "if (prev.max < obj.[field]) { prev.max = obj.[field]; } }"
-    # Return the max value for a field.
-    #
-    # This will take the internally built selector and options
-    # and pass them on to the Ruby driver's +group()+ method on the collection. The
-    # collection itself will be retrieved from the class provided, and once the
-    # query has returned it will provided a grouping of keys with sums.
-    #
-    # Example:
-    #
-    # <tt>criteria.max(:age)</tt>
-    def max(field)
-      grouped(:max, field.to_s, MAX_REDUCE)
-    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.
@@ -320,6 +260,7 @@ module Mongoid #:nodoc:
     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
@@ -357,7 +298,7 @@ module Mongoid #:nodoc:
         new_scope.merge(self)
         return new_scope
       else
-        return collect.send(name, *args)
+        return entries.send(name, *args)
       end
     end
 
@@ -388,18 +329,6 @@ module Mongoid #:nodoc:
       @options[:skip]
     end
 
-    # Return the first result for the +Criteria+.
-    #
-    # Example:
-    #
-    # <tt>Criteria.select(:name).where(:name = "Chrissy").one</tt>
-    def one
-      attributes = @klass.collection.find_one(@selector, process_options)
-      attributes ? instantiate(attributes) : nil
-    end
-
-    alias :first :one
-
     # Adds a criterion to the +Criteria+ that specifies the fields that will
     # get returned from the Document. Used mainly for list views that do not
     # require all fields to be present. This is similar to SQL "SELECT" values.
@@ -433,30 +362,6 @@ module Mongoid #:nodoc:
       @options[:sort] = params; self
     end
 
-    # Either returns the page option and removes it from the options, or
-    # returns a default value of 1.
-    def page
-      skips, limits = @options[:skip], @options[:limit]
-      (skips && limits) ? (skips + limits) / limits : 1
-    end
-
-    # Executes the +Criteria+ and paginates the results.
-    #
-    # Example:
-    #
-    # <tt>criteria.paginate</tt>
-    def paginate
-      @collection ||= execute
-      WillPaginate::Collection.create(page, per_page, count) do |pager|
-        pager.replace(@collection)
-      end
-    end
-
-    # Returns the number of results per page or the default of 20.
-    def per_page
-      (@options[:limit] || 20).to_i
-    end
-
     # Returns the selector and options as a +Hash+ that would be passed to a
     # scope for use with named scopes.
     def scoped
@@ -481,20 +386,7 @@ module Mongoid #:nodoc:
       @options[:skip] = value; self
     end
 
-    SUM_REDUCE = "function(obj, prev) { if (prev.sum == 'start') { prev.sum = 0; } prev.sum += obj.[field]; }"
-    # Sum the criteria.
-    #
-    # This will take the internally built selector and options
-    # and pass them on to the Ruby driver's +group()+ method on the collection. The
-    # collection itself will be retrieved from the class provided, and once the
-    # query has returned it will provided a grouping of keys with sums.
-    #
-    # Example:
-    #
-    # <tt>criteria.sum(:age)</tt>
-    def sum(field)
-      grouped(:sum, field.to_s, SUM_REDUCE)
-    end
+    alias :to_ary :to_a
 
     # Translate the supplied arguments into a +Criteria+ object.
     #
@@ -554,24 +446,12 @@ module Mongoid #:nodoc:
     end
 
     protected
-    # Execute the criteria. This will take the internally built selector and options
-    # and pass them on to the Ruby driver's +find()+ method on the collection. The
-    # collection itself will be retrieved from the class provided, and once the
-    # query has returned new documents of the type of class provided will be instantiated.
-    #
-    # If this is a +Criteria+ to only find the first object, this will return a
-    # single object of the type of class provided.
-    #
-    # If this is a +Criteria+ to find multiple results, will return an +Array+ of
-    # objects of the type of class provided.
-    def execute
-      attributes = @klass.collection.find(@selector, process_options)
-      if attributes
-        @count = attributes.count
-        attributes.collect { |doc| instantiate(doc) }
-      else
-        []
+    # Determines the context to be used for this criteria.
+    def determine_context
+      if @klass.embedded
+        return Contexts::Enumerable.new(@selector, @options, @documents)
       end
+      Contexts::Mongo.new(@selector, @options, @klass)
     end
 
     # Filters the unused options out of the options +Hash+. Currently this
@@ -586,35 +466,6 @@ module Mongoid #:nodoc:
       end
     end
 
-    # Common functionality for grouping operations. Currently used by min, max
-    # and sum. Will gsub the field name in the supplied reduce function.
-    def grouped(start, field, reduce)
-      collection = @klass.collection.group(
-        nil,
-        @selector,
-        { start => "start" },
-        reduce.gsub("[field]", field),
-        true
-      )
-      collection.first[start.to_s]
-    end
-
-    # If hereditary instantiate by _type otherwise use the klass.
-    def instantiate(attrs)
-      @hereditary ? attrs["_type"].constantize.instantiate(attrs) : @klass.instantiate(attrs)
-    end
-
-    # Filters the field list. If no fields have been supplied, then it will be
-    # empty. If fields have been defined then _type will be included as well.
-    def process_options
-      fields = @options[:fields]
-      if fields && fields.size > 0 && !fields.include?(:_type)
-        fields << :_type
-        @options[:fields] = fields
-      end
-      @options.dup
-    end
-
     # Update the selector setting the operator on the value for each key in the
     # supplied attributes +Hash+.
     def update_selector(attributes, operator)