mongoid 2.0.2 → 2.1.0

data/lib/mongoid/collections/master.rb

@@ -14,11 +14,13 @@ module Mongoid #:nodoc:
       # @example Proxy the driver save.
       #   collection.save({ :name => "Al" })
       Operations::ALL.each do |name|
-        define_method(name) do |*args|
-          retry_on_connection_failure do
-            collection.send(name, *args)
+        class_eval <<-EOS, __FILE__, __LINE__
+          def #{name}(*args)
+            retry_on_connection_failure do
+              collection.#{name}(*args)
+            end
           end
-        end
+        EOS
       end
 
       # Create the new database writer. Will create a collection from the

data/lib/mongoid/collections/operations.rb

@@ -2,6 +2,7 @@
 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 = [

data/lib/mongoid/collections/retry.rb

@@ -31,9 +31,16 @@ module Mongoid #:nodoc:
           retries += 1
           raise ex if retries > Mongoid.max_retries_on_connection_failure
           Kernel.sleep(0.5)
+          log_retry retries
           retry
         end
       end
+
+      private
+
+      def log_retry(retry_number)
+        Mongoid.logger.warn "A Mongo::ConnectionFailure was raised. Retry attempt ##{retry_number}."
+      end
     end
   end
 end

data/lib/mongoid/components.rb

@@ -16,7 +16,7 @@ module Mongoid #:nodoc
     include ActiveModel::Observing
     include ActiveModel::Serializers::JSON
     include ActiveModel::Serializers::Xml
-    include Mongoid::Atomicity
+    include Mongoid::Atomic
     include Mongoid::Attributes
     include Mongoid::Collections
     include Mongoid::Copyable
@@ -32,7 +32,6 @@ module Mongoid #:nodoc
     include Mongoid::Matchers
     include Mongoid::NamedScope
     include Mongoid::NestedAttributes
-    include Mongoid::Paths
     include Mongoid::Persistence
     include Mongoid::Relations
     include Mongoid::Safety
@@ -41,5 +40,6 @@ module Mongoid #:nodoc
     include Mongoid::State
     include Mongoid::Validations
     include Mongoid::Callbacks
+    include Mongoid::MultiDatabase
   end
 end

data/lib/mongoid/config.rb

@@ -13,8 +13,9 @@ module Mongoid #:nodoc
     extend self
     include ActiveModel::Observing
 
-    attr_accessor :master, :slaves, :settings
+    attr_accessor :master, :settings, :defaults
     @settings = {}
+    @defaults = {}
 
     # Define a configuration option with a default.
     #
@@ -28,22 +29,33 @@ module Mongoid #:nodoc
     #
     # @since 2.0.0.rc.1
     def option(name, options = {})
-      define_method(name) do
-        settings.has_key?(name) ? settings[name] : options[:default]
-      end
-      define_method("#{name}=") { |value| settings[name] = value }
-      define_method("#{name}?") { send(name) }
+      defaults[name] = settings[name] = options[:default]
+
+      class_eval <<-RUBY
+        def #{name}
+          settings[#{name.inspect}]
+        end
+
+        def #{name}=(value)
+          settings[#{name.inspect}] = value
+        end
+
+        def #{name}?
+          #{name}
+        end
+      RUBY
     end
 
     option :allow_dynamic_fields, :default => true
     option :autocreate_indexes, :default => false
     option :binding_defaults, :default => { :binding => false, :continue => true }
     option :embedded_object_id, :default => true
+    option :identity_map_enabled, :default => false
     option :include_root_in_json, :default => false
     option :max_retries_on_connection_failure, :default => 0
     option :parameterize_keys, :default => true
     option :persist_in_safe_mode, :default => false
-    option :preload_models, :default => true
+    option :preload_models, :default => false
     option :raise_not_found_error, :default => true
     option :skip_version_check, :default => false
     option :time_zone, :default => nil
@@ -125,7 +137,7 @@ module Mongoid #:nodoc
     #
     # @since 2.0.1
     def load!(path)
-      environment = defined?(Rails) ? Rails.env : ENV["RACK_ENV"]
+      environment = defined?(Rails) && Rails.respond_to?(:env) ? Rails.env : ENV["RACK_ENV"]
       settings = YAML.load(ERB.new(File.new(path).read).result)[environment]
       if settings.present?
         from_hash(settings)
@@ -139,7 +151,7 @@ module Mongoid #:nodoc
     #
     # @return [ Logger ] The default Logger instance.
     def default_logger
-      defined?(Rails) ? Rails.logger : ::Logger.new($stdout)
+      defined?(Rails) && Rails.respond_to?(:logger) ? Rails.logger : ::Logger.new($stdout)
     end
 
     # Returns the logger, or defaults to Rails logger or stdout logger.
@@ -177,30 +189,18 @@ module Mongoid #:nodoc
 
     # Sets whether the times returned from the database use the ruby or
     # the ActiveSupport time zone.
-    # If you omit this setting, then times will use the ruby time zone.
     #
-    # Example:
+    # @note If you omit this setting, then times will use the ruby time zone.
     #
-    # <tt>Config.use_activesupport_time_zone = true</tt>
+    # @example Set the time zone config.
+    #   Config.use_activesupport_time_zone = true
     #
-    # Returns:
+    # @param [ true, false ] value Whether to use Active Support time zones.
     #
-    # A boolean
+    # @return [ true, false ] The supplied value or false if nil.
     def use_activesupport_time_zone=(value)
       @use_activesupport_time_zone = value || false
     end
-
-    # Sets whether the times returned from the database use the ruby or
-    # the ActiveSupport time zone.
-    # If the setting is false, then times will use the ruby time zone.
-    #
-    # Example:
-    #
-    # <tt>Config.use_activesupport_time_zone</tt>
-    #
-    # Returns:
-    #
-    # A boolean
     attr_reader :use_activesupport_time_zone
     alias_method :use_activesupport_time_zone?, :use_activesupport_time_zone
 
@@ -265,39 +265,17 @@ module Mongoid #:nodoc
     # @example Reset the configuration options.
     #   config.reset
     def reset
-      settings.clear
+      settings.replace(defaults)
     end
 
-    # Sets the Mongo::DB slave databases to be used. If the objects provided
-    # are not valid +Mongo::DBs+ an error will be raised.
-    #
-    # @example Set the slaves.
-    #   config.slaves = [ Mongo::Connection.db("test") ]
-    #
-    # @param [ Array<Mongo::DB> ] dbs The slave databases.
-    #
-    # @raise [ Errors::InvalidDatabase ] If the slaves arent valid objects.
-    #
-    # @return [ Array<Mongo::DB> ] The slave DB instances.
-    def slaves=(dbs)
-      return unless dbs
-      dbs.each do |db|
-        check_database!(db)
-      end
-      @slaves = dbs
+    # @deprecated User replica sets instead.
+    def slaves
+      slave_warning!
     end
 
-    # Returns the slave databases or nil if none have been set.
-    #
-    # @example Get the slaves.
-    #   config.slaves
-    #
-    # @return [ Array<Mongo::DB>, nil ] The slave databases.
-    def slaves
-      unless @slaves
-        @master, @slaves = configure_databases(@settings) if @settings && @settings[:database]
-      end
-      @slaves
+    # @deprecated User replica sets instead.
+    def slaves=(dbs)
+      slave_warning!
     end
 
     protected
@@ -358,5 +336,14 @@ module Mongoid #:nodoc
         end
       end
     end
+
+    # Temporarily here so people can move to replica sets.
+    def slave_warning!
+      warn(
+        "Using Mongoid for traditional slave databases will be removed in the " +
+        "next release in preference of replica sets. Please change your setup " +
+        "accordingly."
+      )
+    end
   end
 end

data/lib/mongoid/config/database.rb

@@ -6,6 +6,9 @@ module Mongoid #:nodoc:
     # database from options.
     class Database < Hash
 
+      # keys to remove from self to not pass through to Mongo::Connection
+      PRIVATE_OPTIONS = %w(uri database username password)
+
       # Configure the database connections. This will return an array
       # containing the master and an array of slaves.
       #
@@ -142,11 +145,12 @@ module Mongoid #:nodoc:
       #
       # @since 2.0.0.rc.1
       def optional(slave = false)
-        {
+        ({
           :pool_size => pool_size,
           :logger => Mongoid::Logger.new,
           :slave_ok => slave
-        }
+        }).merge(self).reject { |k,v| PRIVATE_OPTIONS.include? k }.
+          inject({}) { |memo, (k, v)| memo[k.to_sym] = v; memo} # mongo likes symbols
       end
 
       # Get a Mongo compliant URI for the database connection.

data/lib/mongoid/config/replset_database.rb

@@ -14,9 +14,13 @@ module Mongoid #:nodoc:
       #
       # @since 2.0.0.rc.5
       def configure
-        #yes, construction is weird but the driver wants "A list of host-port pairs ending with a hash containing any options"
-        #mongo likes symbols
-        options = self.inject({}) { |memo, (k, v)| memo[k.to_sym] = v; memo}
+        # yes, construction is weird but the driver wants 
+        # "A list of host-port pairs ending with a hash containing any options"
+        # mongo likes symbols
+        options = self.inject({ :logger => Mongoid::Logger.new }) do |memo, (k, v)|
+          memo[k.to_sym] = v
+          memo
+        end
         connection = Mongo::ReplSetConnection.new(*(hosts << options))
 
         if authenticating?

data/lib/mongoid/contexts.rb

@@ -4,15 +4,21 @@ require "mongoid/contexts/mongo"
 
 module Mongoid
   module Contexts
+    extend self
+
     # Determines the context to be used for this criteria. If the class is an
     # embedded document, then the 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:
+    # @example Get the context for the criteria.
+    #   Contexts.context_for(criteria)
+    #
+    # @param [ Criteria ] criteria The criteria to use.
+    # @param [ true, false ] embedded Whether this is on embedded documents.
     #
-    # <tt>Contexts.context_for(criteria)</tt>
-    def self.context_for(criteria, embedded = false)
+    # @return [ Enumerable, Mongo ] The appropriate context.
+    def context_for(criteria, embedded = false)
       embedded ? Enumerable.new(criteria) : Mongo.new(criteria)
     end
   end

data/lib/mongoid/contexts/enumerable.rb

@@ -56,7 +56,9 @@ module Mongoid #:nodoc:
       def delete_all
         atomically(:$pull) do
           set_collection
-          count.tap { filter.each(&:delete) }
+          count.tap do
+            filter.each { |doc| doc.delete }
+          end
         end
       end
       alias :delete :delete_all
@@ -72,7 +74,9 @@ module Mongoid #:nodoc:
       def destroy_all
         atomically(:$pull) do
           set_collection
-          count.tap { filter.each(&:destroy) }
+          count.tap do
+            filter.each { |doc| doc.destroy }
+          end
         end
       end
       alias :destroy :destroy_all
@@ -252,7 +256,7 @@ module Mongoid #:nodoc:
       #
       # @return [ Collection ] The root collection.
       def set_collection
-        root = documents.first._root
+        root = documents.first.try(:_root)
         @collection = root.collection if root && !root.embedded?
       end
 

data/lib/mongoid/contexts/mongo.rb

@@ -6,18 +6,34 @@ module Mongoid #:nodoc:
 
       delegate :klass, :options, :field_list, :selector, :to => :criteria
 
+      # Perform an add to set on the matching documents.
+      #
+      # @example Add to set on all matching.
+      #   Person.where(:name => "Alex").add_to_set(:aliases, "value")
+      #
+      # @param [ String ] field The field to add to.
+      # @param [ Object ] value The value to add.
+      #
+      # @return [ Object ] The update value.
+      #
+      # @since 2.1.0
+      def add_to_set(field, value)
+        klass.collection.update(
+          selector,
+          { "$addToSet" => { field => value } },
+          :multi => true
+        )
+      end
+
       # 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>
+      # @example Aggreate the context.
+      #   context.aggregate
       #
-      # Returns:
-      #
-      # A +Hash+ with field values as keys, counts as values
+      # @return [ Hash ] A +Hash+ with field values as keys, counts as values
       def aggregate
         klass.collection.group(
           :key => field_list,
@@ -34,13 +50,12 @@ module Mongoid #:nodoc:
       # collection itself will be retrieved from the class provided, and once the
       # query has returned it will provided a grouping of keys with averages.
       #
-      # Example:
-      #
-      # <tt>context.avg(:age)</tt>
+      # @example Get the average for a field.
+      #   context.avg(:age)
       #
-      # Returns:
+      # @param [ Symbol ] field The field to get the average for.
       #
-      # A numeric value that is the average.
+      # @return [ Numeric ] A numeric value that is the average.
       def avg(field)
         total = sum(field)
         total ? (total / count) : nil
@@ -49,9 +64,10 @@ module Mongoid #:nodoc:
       # Determine if the context is empty or blank given the criteria. Will
       # perform a quick has_one asking only for the id.
       #
-      # Example:
+      # @example Is the context empty?
+      #   context.blank?a
       #
-      # <tt>context.blank?</tt>
+      # @return [ true, false ] True if blank.
       def blank?
         klass.collection.find_one(selector, { :fields => [ :_id ] }).nil?
       end
@@ -102,9 +118,12 @@ module Mongoid #:nodoc:
       # Gets an array of distinct values for the supplied field across the
       # entire collection or the susbset given the criteria.
       #
-      # Example:
+      # @example Get the distinct values.
+      #   context.distinct(:title)
+      #
+      # @param [ Symbol ] field The field to get the values for.
       #
-      # <tt>context.distinct(:title)</tt>
+      # @return [ Array<Object> ] The distinct values for the field.
       def distinct(field)
         klass.collection.distinct(field, selector)
       end
@@ -114,29 +133,35 @@ module Mongoid #:nodoc:
       # 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:
+      # @example Execute the criteria on the context.
+      #   context.execute
       #
-      # <tt>context.execute</tt>
-      #
-      # Returns:
-      #
-      # An enumerable +Cursor+.
+      # @return [ Cursor ] An enumerable +Cursor+ of results.
       def execute
         klass.collection.find(selector, process_options) || []
       end
 
+      # Return the first result for the +Context+.
+      #
+      # @example Get the first document.
+      #   context.one
+      #
+      # @return [ Document ] The first document in the collection.
+      def first
+        attributes = klass.collection.find_one(selector, process_options)
+        attributes ? Mongoid::Factory.from_db(klass, attributes) : nil
+      end
+      alias :one :first
+
       # 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:
+      # @example Get the criteria as a group.
+      #   context.group
       #
-      # <tt>context.group</tt>
-      #
-      # Returns:
-      #
-      # A +Hash+ with field values as keys, arrays of documents as values.
+      # @return [ Hash ] Hash with field values as keys, arrays of documents as values.
       def group
         klass.collection.group(
           :key => field_list,
@@ -154,24 +179,23 @@ module Mongoid #:nodoc:
       # Create the new mongo context. This will execute the queries given the
       # selector and options against the database.
       #
-      # Example:
+      # @example Create a new context.
+      #   Mongoid::Contexts::Mongo.new(criteria)
       #
-      # <tt>Mongoid::Contexts::Mongo.new(criteria)</tt>
+      # @param [ Criteria ] criteria The criteria to create with.
       def initialize(criteria)
         @criteria = criteria
         if klass.hereditary? && !criteria.selector.keys.include?(:_type)
           @criteria = criteria.in(:_type => criteria.klass._types)
         end
-        @criteria.enslave if klass.enslaved?
         @criteria.cache if klass.cached?
       end
 
       # Iterate over each +Document+ in the results. This can take an optional
       # block to pass to each argument in the results.
       #
-      # Example:
-      #
-      # <tt>context.iterate { |doc| p doc }</tt>
+      # @example Iterate over the results.
+      #   context.iterate { |doc| p doc }
       def iterate(&block)
         return caching(&block) if criteria.cached?
         if block_given?
@@ -183,18 +207,15 @@ module Mongoid #:nodoc:
       # the collection with the sorting reversed. If no sorting parameters have
       # been provided it will default to ids.
       #
-      # Example:
+      # @example Get the last document.
+      #   context.last
       #
-      # <tt>context.last</tt>
-      #
-      # Returns:
-      #
-      # The last document in the collection.
+      # @return [ Document ] 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 ] }
+        sorting = opts[:sort] ||= []
+        sorting << [:_id, :asc]
+        opts[:sort] = sorting.map{ |option| [ option[0], option[1].invert ] }.uniq
         attributes = klass.collection.find_one(selector, opts)
         attributes ? Mongoid::Factory.from_db(klass, attributes) : nil
       end
@@ -206,13 +227,12 @@ module Mongoid #:nodoc:
       # 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>
+      # @example Get the max value.
+      #   context.max(:age)
       #
-      # Returns:
+      # @param [ Symbol ] field The field to get the max for.
       #
-      # A numeric max value.
+      # @return [ Numeric ] A numeric max value.
       def max(field)
         grouped(:max, field.to_s, Javascript.max)
       end
@@ -224,43 +244,44 @@ module Mongoid #:nodoc:
       # 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:
+      # @example Get the min value.
+      #   context.min(:age)
       #
-      # <tt>context.min(:age)</tt>
+      # @param [ Symbol ] field The field to get the min for.
       #
-      # Returns:
-      #
-      # A numeric minimum value.
+      # @return [ Numeric ] A numeric minimum value.
       def min(field)
         grouped(:min, field.to_s, Javascript.min)
       end
 
-      # Return the first result for the +Context+.
+      # Perform a pull on the matching documents.
       #
-      # Example:
+      # @example Pull on all matching.
+      #   Person.where(:name => "Alex").pull(:aliases, "value")
       #
-      # <tt>context.one</tt>
+      # @param [ String ] field The field to pull from.
+      # @param [ Object ] value The value to pull.
       #
-      # Return:
+      # @return [ Object ] The update value.
       #
-      # The first document in the collection.
-      def one
-        attributes = klass.collection.find_one(selector, process_options)
-        attributes ? Mongoid::Factory.from_db(klass, attributes) : nil
+      # @since 2.1.0
+      def pull(field, value)
+        klass.collection.update(
+          selector,
+          { "$pull" => { field => value } },
+          :multi => true
+        )
       end
 
-      alias :first :one
-
       # Return the first result for the +Context+ and skip it
       # for successive calls.
       #
-      # Returns:
+      # @example Get the first document and shift.
+      #   context.shift
       #
-      # The first document in the collection.
+      # @return [ Document ] The first document in the collection.
       def shift
-        document = first
-        criteria.skip((options[:skip] || 0) + 1)
-        document
+        first.tap { criteria.skip((options[:skip] || 0) + 1) }
       end
 
       # Sum the context.
@@ -270,43 +291,16 @@ module Mongoid #:nodoc:
       # 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>
+      # @example Get the sum for a field.
+      #   context.sum(:age)
       #
-      # Returns:
+      # @param [ Symbol ] field The field who's values to sum.
       #
-      # A numeric value that is the sum.
+      # @return [ Numeric ] A numeric value that is the sum.
       def sum(field)
         grouped(:sum, field.to_s, Javascript.sum)
       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(
-          :cond => selector,
-          :initial => { start => "start" },
-          :reduce => reduce.gsub("[field]", field)
-        )
-        collection.empty? ? nil : collection.first[start.to_s]
-      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)
-          if fields.kind_of?(Hash)
-            fields[:_type] = 1 if fields.first.last != 0 # Not excluding
-          else
-            fields << :type
-          end
-          options[:fields] = fields
-        end
-        options.dup
-      end
-
       # Very basic update that will perform a simple atomic $set of the
       # attributes provided in the hash. Can be expanded to later for more
       # robust functionality.
@@ -321,15 +315,19 @@ module Mongoid #:nodoc:
         klass.collection.update(
           selector,
           { "$set" => attributes },
-          :multi => true,
-          :safe => Mongoid.persist_in_safe_mode
-        )
+          Safety.merge_safety_options(:multi => true)
+        ).tap do
+          Threaded.clear_safety_options!
+        end
       end
       alias :update :update_all
 
       protected
 
       # Iterate over each +Document+ in the results and cache the collection.
+      #
+      # @example Execute with caching.
+      #   context.caching
       def caching(&block)
         if defined? @collection
           @collection.each(&block)
@@ -341,6 +339,46 @@ module Mongoid #:nodoc:
           end
         end
       end
+
+      # Common functionality for grouping operations. Currently used by min, max
+      # and sum. Will gsub the field name in the supplied reduce function.
+      #
+      # @example Execute the group function.
+      #   context.group(0, :avg, "")
+      #
+      # @param [ Object ] start The value to start the map/reduce with.
+      # @param [ String ] field The field to aggregate.
+      # @param [ String ] reduce The reduce JS function.
+      #
+      # @return [ Numeric ] A numeric result.
+      def grouped(start, field, reduce)
+        collection = klass.collection.group(
+          :cond => selector,
+          :initial => { start => "start" },
+          :reduce => reduce.gsub("[field]", field)
+        )
+        collection.empty? ? nil : collection.first[start.to_s]
+      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.
+      #
+      # @example Process the field list.
+      #   context.process_options
+      #
+      # @return [ Hash ] The options.
+      def process_options
+        fields = options[:fields]
+        if fields && fields.size > 0 && !fields.include?(:_type)
+          if fields.kind_of?(Hash)
+            fields[:_type] = 1 if fields.first.last != 0 # Not excluding
+          else
+            fields << :type
+          end
+          options[:fields] = fields
+        end
+        options.dup
+      end
     end
   end
 end