mongoid 2.8.1 → 3.0.0.rc

data/lib/mongoid/reloading.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
-module Mongoid #:nodoc:
+module Mongoid
   # This module handles reloading behaviour of documents.
   module Reloading
 
@@ -16,18 +16,16 @@ module Mongoid #:nodoc:
     #
     # @since 1.0.0
     def reload
-      _reload.tap do |reloaded|
-        if Mongoid.raise_not_found_error && reloaded.empty?
-          raise Errors::DocumentNotFound.new(self.class, id)
-        end
-        @attributes = reloaded
-      end
-      tap do |doc|
-        doc.changed_attributes.clear
-        doc.apply_defaults
-        doc.reload_relations
-        doc.run_callbacks(:initialize)
+      reloaded = _reload
+      if Mongoid.raise_not_found_error && reloaded.empty?
+        raise Errors::DocumentNotFound.new(self.class, id, id)
       end
+      @attributes = reloaded
+      changed_attributes.clear
+      apply_defaults
+      reload_relations
+      run_callbacks(:initialize)
+      self
     end
 
     private
@@ -54,7 +52,7 @@ module Mongoid #:nodoc:
     #
     # @since 2.3.2
     def reload_root_document
-      {}.merge(collection.find_one(:_id => id) || {})
+      {}.merge(collection.find(_id: id).one || {})
     end
 
     # Reload the embedded document.
@@ -67,7 +65,7 @@ module Mongoid #:nodoc:
     # @since 2.3.2
     def reload_embedded_document
       extract_embedded_attributes({}.merge(
-        _root.collection.find_one(:_id => _root.id)
+        _root.collection.find(_id: _root.id).one
       ))
     end
 

data/lib/mongoid/scoping.rb

@@ -0,0 +1,329 @@
+# encoding: utf-8
+module Mongoid
+
+  # This module contains behaviour for all Mongoid scoping - named scopes,
+  # default scopes, and criteria accessors via scoped and unscoped.
+  module Scoping
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :default_scoping
+      class_attribute :scopes
+      self.scopes = {}
+    end
+
+    module ClassMethods
+
+      # Add a default scope to the model. This scope will be applied to all
+      # criteria unless #unscoped is specified.
+      #
+      # @example Define a default scope with a criteria.
+      #   class Band
+      #     include Mongoid::Document
+      #     field :active, type: Boolean
+      #     default_scope where(active: true)
+      #   end
+      #
+      # @example Define a default scope with a proc.
+      #   class Band
+      #     include Mongoid::Document
+      #     field :active, type: Boolean
+      #     default_scope ->{ where(active: true) }
+      #   end
+      #
+      # @param [ Proc, Criteria ] scope The default scope.
+      #
+      # @raise [ Errors::InvalidScope ] If the scope is not a proc or criteria.
+      #
+      # @return [ Proc ] The default scope.
+      #
+      # @since 1.0.0
+      def default_scope(value)
+        check_scope_validity(value)
+        self.default_scoping = value.to_proc
+      end
+
+      # Is the class able to have the default scope applied?
+      #
+      # @example Can the default scope be applied?
+      #   Band.default_scopable?
+      #
+      # @return [ true, false ] If the default scope can be applied.
+      #
+      # @since 3.0.0
+      def default_scopable?
+        default_scoping? && !Threaded.executing?(:without_default_scope)
+      end
+
+      # Get a queryable, either the last one on the scope stack or a fresh one.
+      #
+      # @api private
+      #
+      # @example Get a queryable.
+      #   Model.queryable
+      #
+      # @return [ Criteria ] The queryable.
+      #
+      # @since 3.0.0
+      def queryable
+        scope_stack.last || Criteria.new(self)
+      end
+
+      # Create a scope that can be accessed from the class level or chained to
+      # criteria by the provided name.
+      #
+      # @example Create named scopes.
+      #
+      #   class Person
+      #     include Mongoid::Document
+      #     field :active, type: Boolean
+      #     field :count, type: Integer
+      #
+      #     scope :active, where(active: true)
+      #     scope :at_least, ->(count){ where(:count.gt => count) }
+      #   end
+      #
+      # @param [ Symbol ] name The name of the scope.
+      # @param [ Proc, Criteria ] conditions The conditions of the scope.
+      #
+      # @raise [ Errors::InvalidScope ] If the scope is not a proc or criteria.
+      # @raise [ Errors::ScopeOverwrite ] If the scope name already exists.
+      #
+      # @since 1.0.0
+      def scope(name, value, &block)
+        normalized = name.to_sym
+        check_scope_validity(value)
+        check_scope_name(normalized)
+        scopes[normalized] = {
+          scope: strip_default_scope(value),
+          extension: Module.new(&block)
+        }
+        define_scope_method(normalized)
+      end
+
+      # Initializes and returns the current scope stack.
+      #
+      # @example Get the scope stack.
+      #   Person.scope_stack
+      #
+      # @return [ Array<Criteria> ] The scope stack.
+      #
+      # @since 1.0.0
+      def scope_stack
+        Threaded.scope_stack[object_id] ||= []
+      end
+
+      # Get a criteria for the document with normal scoping.
+      #
+      # @example Get the criteria.
+      #   Band.scoped(skip: 10)
+      #
+      # @note This will force the default scope to be applied.
+      #
+      # @param [ Hash ] options Query options for the criteria.
+      #
+      # @option options [ Integer ] :skip Optional number of documents to skip.
+      # @option options [ Integer ] :limit Optional number of documents to
+      #   limit.
+      # @option options [ Array ] :sort Optional sorting options.
+      #
+      # @return [ Criteria ] A scoped criteria.
+      #
+      # @since 3.0.0
+      def scoped(options = nil)
+        queryable.scoped(options)
+      end
+
+      # Get the criteria without the default scoping applied.
+      #
+      # @example Get the unscoped criteria.
+      #   Band.unscoped
+      #
+      # @example Yield to block with no default scoping.
+      #   Band.unscoped do
+      #     Band.where(name: "Depeche Mode")
+      #   end
+      #
+      # @note This will force the default scope to be removed.
+      #
+      # @return [ Criteria, Object ] The unscoped criteria or result of the
+      #   block.
+      #
+      # @since 3.0.0
+      def unscoped
+        if block_given?
+          without_default_scope do
+            yield(self)
+          end
+        else
+          queryable.unscoped
+        end
+      end
+
+      # Get a criteria with the default scope applied, if possible.
+      #
+      # @example Get a criteria with the default scope.
+      #   Model.with_default_scope
+      #
+      # @return [ Criteria ] The criteria.
+      #
+      # @since 3.0.0
+      def with_default_scope
+        queryable.with_default_scope
+      end
+      alias :criteria :with_default_scope
+
+      # Pushes the provided criteria onto the scope stack, and removes it after the
+      # provided block is yielded.
+      #
+      # @example Yield to the criteria.
+      #   Person.with_scope(criteria)
+      #
+      # @param [ Criteria ] criteria The criteria to apply.
+      #
+      # @return [ Criteria ] The yielded criteria.
+      #
+      # @since 1.0.0
+      def with_scope(criteria)
+        scope_stack.push(criteria)
+        begin
+          yield criteria
+        ensure
+          scope_stack.pop
+        end
+      end
+
+      # Execute the block without applying the default scope.
+      #
+      # @example Execute without the default scope.
+      #   Band.without_default_scope do
+      #     Band.where(name: "Depeche Mode")
+      #   end
+      #
+      # @return [ Object ] The result of the block.
+      #
+      # @since 3.0.0
+      def without_default_scope
+        Threaded.begin("without_default_scope")
+        yield
+      ensure
+        Threaded.exit("without_default_scope")
+      end
+
+      private
+
+      # Warns or raises exception if overriding another scope or method.
+      #
+      # @api private
+      #
+      # @example Warn or raise error if name exists.
+      #   Model.valid_scope_name?("test")
+      #
+      # @param [ String, Symbol ] name The name of the scope.
+      #
+      # @raise [ Errors::ScopeOverwrite ] If the name exists and configured to
+      #   raise the error.
+      #
+      # @since 2.1.0
+      def check_scope_name(name)
+        if scopes[name] || respond_to?(name, true)
+          if Mongoid.scope_overwrite_exception
+            raise Errors::ScopeOverwrite.new(self.name, name)
+          else
+            if Mongoid.logger
+              Mongoid.logger.warn(
+                "Creating scope :#{name}. " +
+                "Overwriting existing method #{self.name}.#{name}."
+              )
+            end
+          end
+        end
+      end
+
+      # Checks if the intended scope is a valid object, either a criteria or
+      # proc with a criteria.
+      #
+      # @api private
+      #
+      # @example Check if the scope is valid.
+      #   Model.check_scope_validity({})
+      #
+      # @param [ Object ] value The intended scope.
+      #
+      # @raise [ Errors::InvalidScope ] If the scope is not a valid object.
+      #
+      # @since 3.0.0
+      def check_scope_validity(value)
+        unless value.respond_to?(:to_proc)
+          raise Errors::InvalidScope.new(self, value)
+        end
+      end
+
+      # Defines the actual class method that will execute the scope when
+      # called.
+      #
+      # @api private
+      #
+      # @example Define the scope class method.
+      #   Model.define_scope_method(:active)
+      #
+      # @param [ Symbol ] name The method/scope name.
+      #
+      # @return [ Method ] The defined method.
+      #
+      # @since 3.0.0
+      def define_scope_method(name)
+        (class << self; self; end).class_eval <<-SCOPE
+          def #{name}(*args)
+            scoping = scopes[:#{name}]
+            scope, extension = scoping[:scope][*args], scoping[:extension]
+            criteria = with_default_scope.merge(scope)
+            criteria.extend(extension)
+            criteria
+          end
+        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.
+      #
+      # @api private
+      #
+      # @example Strip the default scope.
+      #   Model.strip_default_scope
+      #
+      # @param [ Proc, Criteria ] value The value to strip from.
+      #
+      # @return [ Proc ] The stripped criteria, as a proc.
+      #
+      # @since 3.0.0
+      def strip_default_scope(value)
+        if value.is_a?(Criteria)
+          default = default_scoping.try(:call)
+          value.remove_scoping(default)
+          value.to_proc
+        else
+          value
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/serialization.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
-module Mongoid # :nodoc:
+module Mongoid
 
   # This module provides the extra behaviour for including relations in JSON
   # and XML serialization.
@@ -33,7 +33,7 @@ module Mongoid # :nodoc:
 
       except |= ['_type'] unless Mongoid.include_type_for_serialization
 
-      field_names = fields.keys.map { |field| field.to_s }
+      field_names = self.class.attribute_names
       attribute_names = (as_document.keys + field_names).sort
       if only.any?
         attribute_names &= only
@@ -45,8 +45,9 @@ module Mongoid # :nodoc:
         name.to_s if respond_to?(name)
       end.compact
 
-      {}.tap do |attrs|
-        (attribute_names + method_names).each do |name|
+      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
@@ -56,29 +57,9 @@ module Mongoid # :nodoc:
             attrs[name] = send(name)
           end
         end
-        serialize_relations(attrs, options) if options[:include]
-      end
-    end
-
-    class << self
-
-      # Serialize the provided object into a Mongo friendly value, using the
-      # field serialization method for the passed in type. If no type is
-      # given then we assume generic object serialization, which just returns
-      # the value itself.
-      #
-      # @example Mongoize the object.
-      #   Mongoid::Serialization.mongoize(time, Time)
-      #
-      # @param [ Object ] object The object to convert.
-      # @param [ Class ] klass The type of the object.
-      #
-      # @return [ Object ] The converted object.
-      #
-      # @since 2.1.0
-      def mongoize(object, klass = Object)
-        Fields::Mappings.for(klass).instantiate(:mongoize).serialize(object)
       end
+      serialize_relations(attrs, options) if options[:include]
+      attrs
     end
 
     private
@@ -139,7 +120,7 @@ module Mongoid # :nodoc:
       if inclusions.is_a?(Hash)
         inclusions[name]
       else
-        { :except => options[:except], :only => options[:only] }
+        { except: options[:except], only: options[:only] }
       end
     end
   end

data/lib/mongoid/sessions.rb

@@ -0,0 +1,359 @@
+# encoding: utf-8
+require "mongoid/sessions/factory"
+require "mongoid/sessions/validators"
+
+module Mongoid
+  module Sessions
+    extend ActiveSupport::Concern
+
+    included do
+      cattr_accessor :default_collection_name, :storage_options
+      self.default_collection_name = self.name.collectionize.to_sym
+    end
+
+    # Get the collection for this model from the session. Will check for an
+    # overridden collection name from the store_in macro or the collection
+    # with a pluralized model name.
+    #
+    # @example Get the model's collection.
+    #   Model.collection
+    #
+    # @return [ Moped::Collection ] The collection.
+    #
+    # @since 3.0.0
+    def collection
+      self.class.collection
+    end
+
+    # Get the name of the collection this model persists to. This will be
+    # either the pluralized class name or the option defined in the store_in
+    # macro.
+    #
+    # @example Get the collection name.
+    #   Model.collection_name
+    #
+    # @return [ String ] The name of the collection.
+    #
+    # @since 3.0.0
+    def collection_name
+      self.class.collection_name
+    end
+
+    # Get the session for this model. This is determined in the following order:
+    #
+    #   1. Any custom configuration provided by the 'store_in' macro.
+    #   2. The 'default' session as provided in the mongoid.yml
+    #
+    # @example Get the session.
+    #   model.mongo_session
+    #
+    # @return [ Moped::Session ] The default moped session.
+    #
+    # @since 3.0.0
+    def mongo_session
+      self.class.mongo_session
+    end
+
+    # Tell the next persistance operation to store in a specific collection,
+    # database or session.
+    #
+    # @example Save the current document to a different collection.
+    #   model.with(collection: "secondary").save
+    #
+    # @example Save the current document to a different database.
+    #   model.with(database: "secondary").save
+    #
+    # @example Save the current document to a different session.
+    #   model.with(session: "replica_set").save
+    #
+    # @example Save with a combination of options.
+    #   model.with(session: "sharded", database: "secondary").save
+    #
+    # @param [ Hash ] options The storage options.
+    #
+    # @option options [ String, Symbol ] :collection The collection name.
+    # @option options [ String, Symbol ] :database The database name.
+    # @option options [ String, Symbol ] :session The session name.
+    #
+    # @return [ Document ] The current document.
+    #
+    # @since 3.0.0
+    def with(options)
+      Threaded.set_persistence_options(self.class, options)
+      self
+    end
+
+    class << self
+
+      # Clear all sessions from the current thread.
+      #
+      # @example Clear all sessions.
+      #   Mongoid::Sessions.clear
+      #
+      # @return [ Array ] The empty sessions.
+      #
+      # @since 3.0.0
+      def clear
+        Threaded.sessions.clear
+      end
+
+      # Get the default session.
+      #
+      # @example Get the default session.
+      #   Mongoid::Sessions.default
+      #
+      # @return [ Moped::Session ] The default session.
+      #
+      # @since 3.0.0
+      def default
+        Threaded.sessions[:default] ||= Sessions::Factory.default
+      end
+
+      # Get a session with the provided name.
+      #
+      # @example Get a session with the name.
+      #   Mongoid::Sessions.with_name(:replica)
+      #
+      # @param [ Symbol ] name The name of the session.
+      #
+      # @return [ Moped::Session ] The named session.
+      #
+      # @since 3.0.0
+      def with_name(name)
+        Threaded.sessions[name.to_sym] ||= Sessions::Factory.create(name)
+      end
+    end
+
+    module ClassMethods
+
+      # Clear all persistence options from the current thread.
+      #
+      # @example Clear the persistence options.
+      #   Mongoid::Sessions.clear_persistence_options
+      #
+      # @return [ true ] True.
+      #
+      # @since 3.0.0
+      def clear_persistence_options
+        Threaded.clear_persistence_options(self)
+      end
+
+      # Get the collection for this model from the session. Will check for an
+      # overridden collection name from the store_in macro or the collection
+      # with a pluralized model name.
+      #
+      # @example Get the model's collection.
+      #   Model.collection
+      #
+      # @return [ Moped::Collection ] The collection.
+      #
+      # @since 3.0.0
+      def collection
+        if opts = persistence_options
+          coll = mongo_session.with(opts)[opts[:collection] || collection_name]
+          clear_persistence_options
+          coll
+        else
+          mongo_session[collection_name]
+        end
+      end
+
+      # Get the name of the collection this model persists to. This will be
+      # either the pluralized class name or the option defined in the store_in
+      # macro.
+      #
+      # @example Get the collection name.
+      #   Model.collection_name
+      #
+      # @return [ Symbol ] The name of the collection.
+      #
+      # @since 3.0.0
+      def collection_name
+        @collection_name ||= __collection_name__
+      end
+
+      # Get the default database name for this model.
+      #
+      # @example Get the default database name.
+      #   Model.database_name
+      #
+      # @return [ Symbol ] The name of the database.
+      #
+      # @since 3.0.0
+      def database_name
+        @database_name ||= __database_name__
+      end
+
+      # Get the session for this model. This is determined in the following order:
+      #
+      #   1. Any custom configuration provided by the 'store_in' macro.
+      #   2. The 'default' session as provided in the mongoid.yml
+      #
+      # @example Get the session.
+      #   Model.mongo_session
+      #
+      # @return [ Moped::Session ] The default moped session.
+      #
+      # @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
+      end
+
+      # Get the persistence options from the current thread.
+      #
+      # @example Get the persistence options.
+      #   Model.persistence_options
+      #
+      # @return [ Hash ] The persistence options.
+      #
+      # @since 3.0.0
+      def persistence_options
+        Threaded.persistence_options(self)
+      end
+
+      # Give this model specific custom default storage options.
+      #
+      # @example Store this model by default in "artists"
+      #   class Band
+      #     include Mongoid::Document
+      #     store_in collection: "artists"
+      #   end
+      #
+      # @example Store this model by default in the sharded db.
+      #   class Band
+      #     include Mongoid::Document
+      #     store_in database: "echo_shard"
+      #   end
+      #
+      # @example Store this model by default in a different session.
+      #   class Band
+      #     include Mongoid::Document
+      #     store_in session: "secondary"
+      #   end
+      #
+      # @example Store this model with a combination of options.
+      #   class Band
+      #     include Mongoid::Document
+      #     store_in collection: "artists", database: "secondary"
+      #   end
+      #
+      # @param [ Hash ] options The storage options.
+      #
+      # @option options [ String, Symbol ] :collection The collection name.
+      # @option options [ String, Symbol ] :database The database name.
+      # @option options [ String, Symbol ] :session The session name.
+      #
+      # @return [ Class ] The model class.
+      #
+      # @since 3.0.0
+      def store_in(options)
+        Validators::Storage.validate(self, options)
+        @collection_name, @database_name = nil, nil
+        self.storage_options = options
+      end
+
+      # Tell the next persistance operation to store in a specific collection,
+      # database or session.
+      #
+      # @example Create a document in a different collection.
+      #   Model.with(collection: "secondary").create(name: "test")
+      #
+      # @example Create a document in a different database.
+      #   Model.with(database: "secondary").create(name: "test")
+      #
+      # @example Create a document in a different session.
+      #   Model.with(session: "secondary").create(name: "test")
+      #
+      # @example Create with a combination of options.
+      #   Model.with(session: "sharded", database: "secondary").create
+      #
+      # @param [ Hash ] options The storage options.
+      #
+      # @option options [ String, Symbol ] :collection The collection name.
+      # @option options [ String, Symbol ] :database The database name.
+      # @option options [ String, Symbol ] :session The session name.
+      #
+      # @return [ Class ] The model class.
+      #
+      # @since 3.0.0
+      def with(options)
+        Threaded.set_persistence_options(self, options)
+        self
+      end
+
+      private
+
+      # Get the name of the collection this model persists to.
+      #
+      # @example Get the collection name.
+      #   Model.__collection_name__
+      #
+      # @return [ Symbol ] The name of the collection.
+      #
+      # @since 3.0.0
+      def __collection_name__
+        if storage_options && name = storage_options[:collection]
+          name.to_sym
+        else
+          default_collection_name
+        end
+      end
+
+      # Get the database name for the model.
+      #
+      # @example Get the database name.
+      #   Model.__database_name__
+      #
+      # @return [ Symbol ] The name of the database.
+      #
+      # @since 3.0.0
+      def __database_name__
+        if storage_options && name = storage_options[:database]
+          name.to_sym
+        else
+          Mongoid.sessions[__session_name__][:database]
+        end
+      end
+
+      # Get the session name for the model.
+      #
+      # @example Get the session name.
+      #   Model.__session_name__
+      #
+      # @return [ Symbol ] The name of the session.
+      #
+      # @since 3.0.0
+      def __session_name__
+        if storage_options && name = storage_options[:session]
+          name.to_sym
+        else
+          :default
+        end
+      end
+
+      # Get the session for this class.
+      #
+      # @example Get the session.
+      #   Model.__session__
+      #
+      # @return [ Moped::Session ] The moped session.
+      #
+      # @since 3.0.0
+      def __session__
+        if persistence_options && name = persistence_options[:session]
+          Sessions.with_name(name)
+        elsif storage_options && name = storage_options[:session]
+          Sessions.with_name(name)
+        else
+          Sessions.default
+        end
+      end
+    end
+  end
+end