mongoid 1.1.4 → 1.2.0

data/lib/mongoid/collections/operations.rb

@@ -0,0 +1,39 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Collections #:nodoc:
+    module Operations #:nodoc:
+      # Constant definining all the read operations available for a
+      # Mongo:Collection. This is used in delegation.
+      READ = [
+        :[],
+        :count,
+        :distinct,
+        :find,
+        :find_one,
+        :group,
+        :index_information,
+        :map_reduce,
+        :mapreduce,
+        :options
+      ]
+
+      # Constant definining all the write operations available for a
+      # Mongo:Collection. This is used in delegation.
+      WRITE = [
+        :<<,
+        :create_index,
+        :drop,
+        :drop_index,
+        :drop_indexes,
+        :insert,
+        :remove,
+        :rename,
+        :save,
+        :update
+      ]
+
+      # Convenience constant for getting back all collection operations.
+      ALL = (READ + WRITE)
+    end
+  end
+end

data/lib/mongoid/collections/slaves.rb

@@ -0,0 +1,44 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Collections #:nodoc:
+    class Slaves
+      include Mimic
+
+      attr_reader :iterator
+
+      # All read operations should delegate to the slave connections.
+      # These operations mimic the methods on a Mongo:Collection.
+      #
+      # Example:
+      #
+      # <tt>collection.save({ :name => "Al" })</tt>
+      proxy(:collection, Operations::READ)
+
+      # Is the collection of slaves empty or not?
+      #
+      # Return:
+      #
+      # True is the iterator is not set, false if not.
+      def empty?
+        @iterator.nil?
+      end
+
+      # Create the new database reader. Will create a collection from the
+      # slave databases and cycle through them on each read.
+      #
+      # Example:
+      #
+      # <tt>Reader.new(slaves, "mongoid_people")</tt>
+      def initialize(slaves, name)
+        unless slaves.blank?
+          @iterator = CyclicIterator.new(slaves.collect { |db| db.collection(name) })
+        end
+      end
+
+      protected
+      def collection
+        @iterator.next
+      end
+    end
+  end
+end

data/lib/mongoid/commands.rb

@@ -107,6 +107,7 @@ module Mongoid #:nodoc:
       def set_attributes(attrs = {})
         run_callbacks(:before_update)
         write_attributes(attrs)
+        run_callbacks(:after_update)
       end
 
     end

data/lib/mongoid/config.rb

@@ -5,28 +5,80 @@ module Mongoid #:nodoc
 
     attr_accessor \
       :allow_dynamic_fields,
+      :max_successive_reads,
+      :reconnect_time,
+      :parameterize_keys,
       :persist_in_safe_mode,
       :raise_not_found_error
 
     # Defaults the configuration options to true.
     def initialize
       @allow_dynamic_fields = true
+      @max_successive_reads = 10
+      @parameterize_keys = true
       @persist_in_safe_mode = true
       @raise_not_found_error = true
+      @reconnect_time = 3
     end
 
-    # Sets the Mongo::DB to be used.
-    def database=(db)
-      raise Errors::InvalidDatabase.new(
-          "Database should be a Mongo::DB, not #{db.class.name}"
-        ) unless db.kind_of?(Mongo::DB)
-      @database = db
+    # Sets the Mongo::DB master database to be used. If the object trying to me
+    # set is not a valid +Mongo::DB+, then an error will be raise.
+    #
+    # Example:
+    #
+    # <tt>Config.master = Mongo::Connection.db("test")</tt>
+    #
+    # Returns:
+    #
+    # The Master DB instance.
+    def master=(db)
+      raise Errors::InvalidDatabase.new(db) unless db.kind_of?(Mongo::DB)
+      @master = db
     end
 
-    # Returns the Mongo::DB to use or raise an error if none was set.
-    def database
-      @database || (raise Errors::InvalidDatabase.new("No database has been set, please use Mongoid.database="))
+    # Returns the master database, or if none has been set it will raise an
+    # error.
+    #
+    # Example:
+    #
+    # <tt>Config.master</tt>
+    #
+    # Returns:
+    #
+    # The master +Mongo::DB+
+    def master
+      @master || (raise Errors::InvalidDatabase.new(nil))
     end
 
+    alias :database :master
+    alias :database= :master=
+
+    # Sets the Mongo::DB slave databases to be used. If the objects trying to me
+    # set are not valid +Mongo::DBs+, then an error will be raise.
+    #
+    # Example:
+    #
+    # <tt>Config.slaves = [ Mongo::Connection.db("test") ]</tt>
+    #
+    # Returns:
+    #
+    # The slaves DB instances.
+    def slaves=(dbs)
+      dbs.each { |db| raise Errors::InvalidDatabase.new(db) unless db.kind_of?(Mongo::DB) }
+      @slaves = dbs
+    end
+
+    # Returns the slave databases, or if none has been set nil
+    #
+    # Example:
+    #
+    # <tt>Config.slaves</tt>
+    #
+    # Returns:
+    #
+    # The slave +Mongo::DBs+
+    def slaves
+      @slaves
+    end
   end
 end

data/lib/mongoid/contexts/enumerable.rb

@@ -5,7 +5,7 @@ module Mongoid #:nodoc:
       include Paging
       attr_reader :selector, :options, :documents
 
-      delegate :first, :last, :to => :documents
+      delegate :first, :last, :to => :execute
 
       # Return aggregation counts of the grouped documents. This will count by
       # the first field provided in the fields array.
@@ -21,7 +21,7 @@ module Mongoid #:nodoc:
 
       # Gets the number of documents in the array. Delegates to size.
       def count
-        @documents.size
+        @count ||= @documents.size
       end
 
       # Groups the documents by the first field supplied in the field options.
@@ -40,8 +40,8 @@ module Mongoid #:nodoc:
       # Returns:
       #
       # An +Array+ of documents that matched the selector.
-      def execute
-        @documents.select { |document| document.matches?(@selector) }
+      def execute(paginating = false)
+        limit(@documents.select { |document| document.matches?(@selector) })
       end
 
       # Create the new enumerable context. This will need the selector and
@@ -61,10 +61,7 @@ module Mongoid #:nodoc:
       #
       # The numerical largest value.
       def max(field)
-        largest = @documents.inject(nil) do |memo, doc|
-          value = doc.send(field)
-          (memo && memo >= value) ? memo : value
-        end
+        determine(field, :>=)
       end
 
       # Get the smallest value for the field in all the documents.
@@ -73,10 +70,7 @@ module Mongoid #:nodoc:
       #
       # The numerical smallest value.
       def min(field)
-        smallest = @documents.inject(nil) do |memo, doc|
-          value = doc.send(field)
-          (memo && memo <= value) ? memo : value
-        end
+        determine(field, :<=)
       end
 
       # Get one document.
@@ -84,9 +78,7 @@ module Mongoid #:nodoc:
       # Returns:
       #
       # The first document in the +Array+
-      def one
-        @documents.first
-      end
+      alias :one :first
 
       # Get the sum of the field values for all the documents.
       #
@@ -100,6 +92,23 @@ module Mongoid #:nodoc:
         end
       end
 
+      protected
+      # If the field exists, perform the comparison and set if true.
+      def determine(field, operator)
+        matching = @documents.inject(nil) do |memo, doc|
+          value = doc.send(field)
+          (memo && memo.send(operator, value)) ? memo : value
+        end
+      end
+
+      # Limits the result set if skip and limit options.
+      def limit(documents)
+        skip, limit = @options[:skip], @options[:limit]
+        if skip && limit
+          return documents.slice(skip, limit)
+        end
+        documents
+      end
     end
   end
 end

data/lib/mongoid/contexts/mongo.rb

@@ -35,6 +35,28 @@ module Mongoid #:nodoc:
         @count ||= @klass.collection.find(@selector, process_options).count
       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 enumerable +Cursor+.
+      def execute(paginating = false)
+        cursor = @klass.collection.find(@selector, process_options)
+        if cursor
+          @count = cursor.count if paginating
+          cursor
+        else
+          []
+        end
+      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
@@ -57,34 +79,12 @@ module Mongoid #:nodoc:
           true
         ).collect do |docs|
           docs["group"] = docs["group"].collect do |attrs|
-            instantiate(attrs)
+            Mongoid::Factory.build(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.
       #
@@ -115,7 +115,7 @@ module Mongoid #:nodoc:
         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
+        attributes ? Mongoid::Factory.build(attributes) : nil
       end
 
       MAX_REDUCE = "function(obj, prev) { if (prev.max == 'start') { prev.max = obj.[field]; } " +
@@ -169,7 +169,7 @@ module Mongoid #:nodoc:
       # The first document in the collection.
       def one
         attributes = @klass.collection.find_one(@selector, process_options)
-        attributes ? instantiate(attributes) : nil
+        attributes ? Mongoid::Factory.build(attributes) : nil
       end
 
       alias :first :one
@@ -193,7 +193,6 @@ module Mongoid #:nodoc:
         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)
@@ -207,11 +206,6 @@ module Mongoid #:nodoc:
         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

data/lib/mongoid/contexts/paging.rb

@@ -12,9 +12,9 @@ module Mongoid #:nodoc:
       #
       # A collection of documents paginated.
       def paginate
-        @collection ||= execute
+        @collection ||= execute(true)
         WillPaginate::Collection.create(page, per_page, count) do |pager|
-          pager.replace(@collection)
+          pager.replace(@collection.to_a)
         end
       end
 

data/lib/mongoid/criteria.rb

@@ -25,8 +25,9 @@ module Mongoid #:nodoc:
     include Criterion::Optional
     include Enumerable
 
+    attr_reader :collection, :ids, :klass, :options, :selector
+
     attr_accessor :documents
-    attr_reader :klass, :options, :selector
 
     delegate \
       :aggregate,
@@ -46,13 +47,13 @@ module Mongoid #:nodoc:
     # 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)
+      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 - (other.is_a?(Criteria) ? other.entries : other)
+      entries - comparable(other)
     end
 
     # Returns true if the supplied +Enumerable+ or +Criteria+ is equal to the results
@@ -69,7 +70,7 @@ module Mongoid #:nodoc:
         self.selector == other.selector && self.options == other.options
       when Enumerable
         @collection ||= execute
-        return (@collection == other)
+        return (@collection.collect == other)
       else
         return false
       end
@@ -108,7 +109,11 @@ module Mongoid #:nodoc:
     # <tt>criteria.each { |doc| p doc }</tt>
     def each(&block)
       @collection ||= execute
-      block_given? ? @collection.each { |doc| yield doc } : self
+      if block_given?
+        docs = []
+        @collection.each { |doc| docs << doc; yield doc }
+      end
+      self
     end
 
     # Create the new +Criteria+ object. This will initialize the selector
@@ -219,7 +224,18 @@ module Mongoid #:nodoc:
     end
 
     protected
-    # Determines the context to be used for this criteria.
+    # Determines the context to be used for this criteria. If the class is an
+    # embedded document, then thw context will be the array in the has_many
+    # association it is in. If the class is a root, then the database itself
+    # will be the context.
+    #
+    # Example:
+    #
+    # <tt>criteria#determine_context</tt>
+    #
+    # Returns:
+    #
+    # A enumerable or mongo context.
     def determine_context
       if @klass.embedded
         return Contexts::Enumerable.new(@selector, @options, @documents)
@@ -230,6 +246,12 @@ module Mongoid #:nodoc:
     # 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)
@@ -239,14 +261,33 @@ module Mongoid #:nodoc:
       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
 
     class << self
-      # Return a criteria or single document based on an id search.
+      # Create a criteria or single document based on an id search. Will handle
+      # if a single id has been passed or mulitple ids.
+      #
+      # Example:
+      #
+      #   Criteria.id_criteria(Person, [1, 2, 3])
+      #
+      # Returns:
+      #
+      # The single or multiple documents.
       def id_criteria(klass, params)
         criteria = new(klass).id(params)
         result = params.is_a?(String) ? criteria.one : criteria.entries