mongoid 3.0.0.rc → 3.0.0

data/lib/mongoid/relations/referenced/many_to_many.rb

@@ -28,12 +28,10 @@ module Mongoid
           docs = args.flatten
           return concat(docs) if docs.size > 1
           if doc = docs.first
-            if !target.include?(doc)
-              append(doc)
-              base.push(foreign_key, doc.id)
-              if persistable? || _creating?
-                doc.save
-              end
+            append(doc)
+            base.add_to_set(foreign_key, doc.id)
+            if persistable? || _creating?
+              doc.save
             end
           end
           unsynced(base, foreign_key) and self
@@ -52,21 +50,24 @@ module Mongoid
         #
         # @since 2.4.0
         def concat(documents)
-          ids, inserts = [], []
+          ids, docs, inserts = {}, [], []
           documents.each do |doc|
-            next if doc.nil? || target.include?(doc)
+            next unless doc
             append(doc)
             if persistable? || _creating?
-              ids.push(doc.id)
-              save_or_delay(doc, inserts)
+              ids[doc.id] = true
+              save_or_delay(doc, docs, inserts)
             else
-              base.send(foreign_key).push(doc.id) and unsynced(base, foreign_key)
+              existing = base.send(foreign_key)
+              unless existing.include?(doc.id)
+                existing.push(doc.id) and unsynced(base, foreign_key)
+              end
             end
           end
           if persistable? || _creating?
-            base.push_all(foreign_key, ids)
+            base.push_all(foreign_key, ids.keys)
           end
-          persist_delayed(inserts)
+          persist_delayed(docs, inserts)
           self
         end
 

data/lib/mongoid/scoping.rb

@@ -284,23 +284,6 @@ module Mongoid
         SCOPE
       end
 
-      # When inheriting, we want to copy the scopes from the parent class and
-      # set the on the child to start, mimicking the behaviour of the old
-      # class_inheritable_accessor that was deprecated in Rails edge.
-      #
-      # @api private
-      #
-      # @example Inherit from this class.
-      #   Person.inherited(Doctor)
-      #
-      # @param [ Class ] subclass The inheriting class.
-      #
-      # @since 2.0.0.rc.6
-      def inherited(subclass)
-        super
-        subclass.scopes = scopes.dup
-      end
-
       # Strip the default scope from the provided value, if it is a criteria.
       # This is used by named scopes - they should not have the default scoping
       # applied to them.

data/lib/mongoid/serialization.rb

@@ -27,43 +27,112 @@ module Mongoid
     # @since 2.0.0.rc.6
     def serializable_hash(options = nil)
       options ||= {}
+      attrs = {}
 
-      only   = Array.wrap(options[:only]).map(&:to_s)
-      except = Array.wrap(options[:except]).map(&:to_s)
-
-      except |= ['_type'] unless Mongoid.include_type_for_serialization
-
-      field_names = self.class.attribute_names
-      attribute_names = (as_document.keys + field_names).sort
-      if only.any?
-        attribute_names &= only
-      elsif except.any?
-        attribute_names -= except
-      end
+      names = field_names(options)
 
-      method_names = Array.wrap(options[:methods]).map do |name|
-        name.to_s if respond_to?(name)
-      end.compact
+      _serializing do
+        method_names = Array.wrap(options[:methods]).map do |name|
+          name.to_s if respond_to?(name)
+        end.compact
 
-      attrs = {}
-      (attribute_names + method_names).each do |name|
-        without_autobuild do
-          if relations.has_key?(name)
-            value = send(name)
-            attrs[name] = value ? value.serializable_hash(options) : nil
-          elsif attribute_names.include?(name) && !fields.has_key?(name)
-            attrs[name] = read_attribute(name)
-          else
-            attrs[name] = send(name)
+        (names + method_names).each do |name|
+          without_autobuild do
+            serialize_attribute(attrs, name, names, options)
           end
         end
+        serialize_relations(attrs, options) if options[:include]
       end
-      serialize_relations(attrs, options) if options[:include]
       attrs
     end
 
     private
 
+    # Enter the serialization block.
+    #
+    # @api private
+    #
+    # @example Begin serialization.
+    #   document._serializing do
+    #   end
+    #
+    # @return [ Object ] The result of the yield.
+    #
+    # @since 3.0.0
+    def _serializing
+      Threaded.begin("serialization")
+      yield
+    ensure
+      Threaded.exit("serialization")
+    end
+
+    # Are we in a serialization block? We use this to protect multiple
+    # unnecessary calls to #as_document.
+    #
+    # @api private
+    #
+    # @example Are we in serialization?
+    #   document._serializing?
+    #
+    # @return [ true, false ] If we are serializing.
+    #
+    # @since 3.0.0
+    def _serializing?
+      Threaded.executing?("serialization")
+    end
+
+    # Get the names of all fields that will be serialized.
+    #
+    # @api private
+    #
+    # @example Get all the field names.
+    #   document.send(:field_names)
+    #
+    # @return [ Array<String> ] The names of the fields.
+    #
+    # @since 3.0.0
+    def field_names(options)
+      names = (_serializing? ? attribute_names : as_document.keys + attribute_names).uniq.sort
+
+      only = Array.wrap(options[:only]).map(&:to_s)
+      except = Array.wrap(options[:except]).map(&:to_s)
+      except |= ['_type'] unless Mongoid.include_type_for_serialization
+
+      if !only.empty?
+        names &= only
+      elsif !except.empty?
+        names -= except
+      end
+      names
+    end
+
+    # Serialize a single attribute. Handles relations, fields, and dynamic
+    # attributes.
+    #
+    # @api private
+    #
+    # @example Serialize the attribute.
+    #   document.serialize_attribute({}, "id" , [ "id" ])
+    #
+    # @param [ Hash ] attrs The attributes.
+    # @param [ String ] name The attribute name.
+    # @param [ Array<String> ] names The names of all attributes.
+    # @param [ Hash ] options The options.
+    #
+    # @return [ Object ] The attribute.
+    #
+    # @since 3.0.0
+    def serialize_attribute(attrs, name, names, options)
+      if relations.has_key?(name)
+        value = send(name)
+        attrs[name] = value ? value.serializable_hash(options) : nil
+      elsif names.include?(name) && !fields.has_key?(name)
+        attrs[name] = read_attribute(name)
+      else
+        attrs[name] = send(name)
+      end
+    end
+
     # For each of the provided include options, get the relation needed and
     # provide it in the hash.
     #

data/lib/mongoid/sessions.rb

@@ -184,6 +184,20 @@ module Mongoid
         @database_name ||= __database_name__
       end
 
+      # Get the overridden database name. This either can be overridden by
+      # using +Model.with+ or by overriding at the global level via
+      # +Mongoid.override_database(:name)+.
+      #
+      # @example Get the overridden database name.
+      #   Model.database_override
+      #
+      # @return [ String, Symbol ] The overridden database name.
+      #
+      # @since 3.0.0
+      def database_override
+        persistence_options.try { |opts| opts[:database] } || Threaded.database_override
+      end
+
       # Get the session for this model. This is determined in the following order:
       #
       #   1. Any custom configuration provided by the 'store_in' macro.
@@ -197,11 +211,7 @@ module Mongoid
       # @since 3.0.0
       def mongo_session
         session = __session__
-        if persistence_options && name = persistence_options[:database]
-          session.use(name)
-        else
-          session.use(database_name)
-        end
+        session.use(database_override || database_name)
         session
       end
 
@@ -217,6 +227,20 @@ module Mongoid
         Threaded.persistence_options(self)
       end
 
+      # Get the overridden session name. This either can be overridden by
+      # using +Model.with+ or by overriding at the global level via
+      # +Mongoid.override_session(:name)+.
+      #
+      # @example Get the overridden session name.
+      #   Model.session_override
+      #
+      # @return [ String, Symbol ] The overridden session name.
+      #
+      # @since 3.0.0
+      def session_override
+        persistence_options.try { |opts| opts[:session] } || Threaded.session_override
+      end
+
       # Give this model specific custom default storage options.
       #
       # @example Store this model by default in "artists"
@@ -346,7 +370,7 @@ module Mongoid
       #
       # @since 3.0.0
       def __session__
-        if persistence_options && name = persistence_options[:session]
+        if name = session_override
           Sessions.with_name(name)
         elsif storage_options && name = storage_options[:session]
           Sessions.with_name(name)

data/lib/mongoid/sessions/factory.rb

@@ -58,7 +58,9 @@ module Mongoid
       #
       # @since 3.0.0
       def create_session(configuration)
+        raise Errors::NoSessionsConfig.new unless configuration
         config, options = parse(configuration)
+        configuration.merge!(config) if configuration.delete(:uri)
         session = Moped::Session.new(config[:hosts], options)
         session.use(config[:database])
         if authenticated?(config)

data/lib/mongoid/threaded.rb

@@ -22,6 +22,32 @@ module Mongoid
       stack(name).push(true)
     end
 
+    # Get the global database override.
+    #
+    # @example Get the global database override.
+    #   Threaded.database_override
+    #
+    # @return [ String, Symbol ] The override.
+    #
+    # @since 3.0.0
+    def database_override
+      Thread.current["[mongoid]:db-override"]
+    end
+
+    # Set the global database override.
+    #
+    # @example Set the global database override.
+    #   Threaded.database_override = :testing
+    #
+    # @param [ String, Symbol ] The global override name.
+    #
+    # @return [ String, Symbol ] The override.
+    #
+    # @since 3.0.0
+    def database_override=(name)
+      Thread.current["[mongoid]:db-override"] = name
+    end
+
     # Get the database sessions from the current thread.
     #
     # @example Get the database sessions.
@@ -296,6 +322,32 @@ module Mongoid
       Thread.current["[mongoid]:selection"] = value
     end
 
+    # Get the global session override.
+    #
+    # @example Get the global session override.
+    #   Threaded.session_override
+    #
+    # @return [ String, Symbol ] The override.
+    #
+    # @since 3.0.0
+    def session_override
+      Thread.current["[mongoid]:session-override"]
+    end
+
+    # Set the global session override.
+    #
+    # @example Set the global session override.
+    #   Threaded.session_override = :testing
+    #
+    # @param [ String, Symbol ] The global override name.
+    #
+    # @return [ String, Symbol ] The override.
+    #
+    # @since 3.0.0
+    def session_override=(name)
+      Thread.current["[mongoid]:session-override"] = name
+    end
+
     # Get the mongoid scope stack for chained criteria.
     #
     # @example Get the scope stack.

data/lib/mongoid/timestamps/created.rb

@@ -19,7 +19,7 @@ module Mongoid
       def set_created_at
         if !created_at
           time = Time.now.utc
-          self.updated_at = time if is_a?(Updated)
+          self.updated_at = time if is_a?(Updated) && !updated_at_changed?
           self.created_at = time
         end
       end

data/lib/mongoid/timestamps/updated.rb

@@ -8,7 +8,8 @@ module Mongoid
 
       included do
         field :updated_at, type: Time
-        set_callback :save, :before, :set_updated_at, if: :able_to_set_updated_at?
+        set_callback :create, :before, :set_updated_at, if: :able_to_set_updated_at?
+        set_callback :update, :before, :set_updated_at, if: :able_to_set_updated_at?
       end
 
       # Update the updated_at field on the Document to the current time.

data/lib/mongoid/validations/uniqueness.rb

@@ -145,7 +145,7 @@ module Mongoid
       #
       # @since 2.3.0
       def filter(value)
-        !case_sensitive? && value ? /^#{Regexp.escape(value.to_s)}$/i : value
+        !case_sensitive? && value ? /\A#{Regexp.escape(value.to_s)}$/i : value
       end
 
       # Scope the criteria to the scope options provided.
@@ -165,6 +165,7 @@ module Mongoid
         Array.wrap(options[:scope]).each do |item|
           criteria = criteria.where(item => document.attributes[item.to_s])
         end
+        criteria = criteria.where(deleted_at: nil) if document.paranoid?
         criteria
       end
 
@@ -242,7 +243,7 @@ module Mongoid
       # @since 2.4.10
       def validate_embedded(document, attribute, value)
         return if skip_validation?(document)
-        relation = document._parent.send(document.metadata.name)
+        relation = document._parent.send(document.metadata_name)
         criteria = create_criteria(relation, document, attribute, value)
         add_error(document, attribute, value) if criteria.count > 1
       end

data/lib/mongoid/version.rb

@@ -1,4 +1,4 @@
 # encoding: utf-8
 module Mongoid
-  VERSION = "3.0.0.rc"
+  VERSION = "3.0.0"
 end

data/lib/rails/generators/mongoid/config/templates/mongoid.yml

@@ -58,3 +58,11 @@ development:
 
     # Ensure all times are UTC in the app side. (default: false)
     # use_utc: false
+test:
+  sessions:
+    default:
+      database: <%= database_name || app_name %>_test
+      hosts:
+        - localhost:27017
+      options:
+        consistency: :strong

data/lib/rails/mongoid.rb

@@ -20,9 +20,12 @@ module Rails
         next if model.index_options.empty?
         unless model.embedded?
           model.create_indexes
-          logger.info("Creating indexes on: #{model} for: #{model.index_options.keys.join(", ")}.")
+          logger.info("MONGOID: Created indexes on #{model}:")
+          model.index_options.each_pair do |index, options|
+            logger.info("MONGOID: Index: #{index}, Options: #{options}")
+          end
         else
-          logger.info("Index ignored on: #{model}, please define in the root model.")
+          logger.info("MONGOID: Index ignored on: #{model}, please define in the root model.")
         end
       end
     end
@@ -44,7 +47,7 @@ module Rails
         indexes = model.collection.indexes.map{ |doc| doc["name"] }
         indexes.delete_one("_id_")
         model.remove_indexes
-        logger.info("Removing indexes on: #{model} for: #{indexes.join(', ')}.")
+        logger.info("MONGOID: Removing indexes on: #{model} for: #{indexes.join(', ')}.")
       end
     end
 
@@ -63,7 +66,7 @@ module Rails
         begin
           determine_model(file, logger)
         rescue => e
-          logger.error(%Q{Failed to determine model from #{file}:
+          logger.error(%Q{MONGOID: Failed to determine model from #{file}:
             #{e.class}:#{e.message}
             #{e.backtrace.join("\n")}
           })
@@ -138,7 +141,7 @@ module Rails
         name = parts.join("::")
         klass = name.constantize
       rescue NameError, LoadError
-        logger.info("Attempted to constantize #{name}, trying without namespacing.")
+        logger.info("MONGOID: Attempted to constantize #{name}, trying without namespacing.")
         klass = parts.last.constantize
       end
       klass if klass.ancestors.include?(::Mongoid::Document)