mongoid 2.4.10 → 3.0.0

data/lib/mongoid/callbacks.rb

@@ -1,26 +1,77 @@
 # encoding: utf-8
-module Mongoid #:nodoc:
+module Mongoid
 
   # This module contains all the callback hooks for Mongoid.
   module Callbacks
     extend ActiveSupport::Concern
 
     CALLBACKS = [
-      :before_validation, :after_validation,
-      :after_initialize, :after_build,
-      :before_create, :around_create, :after_create,
-      :before_destroy, :around_destroy, :after_destroy,
-      :before_save, :around_save, :after_save,
-      :before_update, :around_update, :after_update,
+      :after_build,
+      :after_create,
+      :after_destroy,
+      :after_initialize,
+      :after_save,
+      :after_update,
+      :after_upsert,
+      :after_validation,
+      :around_create,
+      :around_destroy,
+      :around_save,
+      :around_update,
+      :around_upsert,
+      :before_create,
+      :before_destroy,
+      :before_save,
+      :before_update,
+      :before_upsert,
+      :before_validation
     ]
 
     included do
       extend ActiveModel::Callbacks
       include ActiveModel::Validations::Callbacks
 
-      define_model_callbacks :initialize, :only => :after
-      define_model_callbacks :build, :only => :after
-      define_model_callbacks :create, :destroy, :save, :update
+      define_model_callbacks :initialize, only: :after
+      define_model_callbacks :build, only: :after
+      define_model_callbacks :create, :destroy, :save, :update, :upsert
+    end
+
+    # Run only the after callbacks for the specific event.
+    #
+    # @note ActiveSupport does not allow this type of behaviour by default, so
+    #   Mongoid has to get around it and implement itself.
+    #
+    # @example Run only the after save callbacks.
+    #   model.run_after_callbacks(:save)
+    #
+    # @param [ Array<Symbol> ] kinds The events that are occurring.
+    #
+    # @return [ Object ] The result of the chain executing.
+    #
+    # @since 3.0.0
+    def run_after_callbacks(*kinds)
+      kinds.each do |kind|
+        run_targeted_callbacks(:after, kind)
+      end
+    end
+
+    # Run only the before callbacks for the specific event.
+    #
+    # @note ActiveSupport does not allow this type of behaviour by default, so
+    #   Mongoid has to get around it and implement itself.
+    #
+    # @example Run only the before save callbacks.
+    #   model.run_before_callbacks(:save, :create)
+    #
+    # @param [ Array<Symbol> ] kinds The events that are occurring.
+    #
+    # @return [ Object ] The result of the chain executing.
+    #
+    # @since 3.0.0
+    def run_before_callbacks(*kinds)
+      kinds.each do |kind|
+        run_targeted_callbacks(:before, kind)
+      end
     end
 
     # Run the callbacks for the document. This overrides active support's
@@ -39,35 +90,16 @@ module Mongoid #:nodoc:
     #
     # @since 2.3.0
     def run_callbacks(kind, *args, &block)
-      run_cascading_callbacks(cascadable_children(kind), kind, *args) {}
+      cascadable_children(kind).each do |child|
+        unless child.run_callbacks(child_callback_type(kind, child), *args)
+          return false
+        end
+      end
       super(kind, *args, &block)
     end
 
     private
 
-    # Execute the callbacks, including all children that have cascade callbacks
-    # set to true.
-    #
-    # @example Run the cascading callbacks.
-    #   document.run_cascading_callbacks([], :update)
-    #
-    # @param [ Array<Document> ] children The cascading children.
-    # @param [ Symbol ] kind The callback type.
-    # @param [ Array ] args The options.
-    #
-    # @since 2.3.0
-    def run_cascading_callbacks(children, kind, *args, &block)
-      if child = children.pop
-        run_cascading_callbacks(children, kind, *args) do
-          child.run_callbacks(child_callback_type(kind, child), *args) do
-            block.call
-          end
-        end
-      else
-        block.call
-      end
-    end
-
     # Get all the child embedded documents that are flagged as cascadable.
     #
     # @example Get all the cascading children.
@@ -78,19 +110,23 @@ module Mongoid #:nodoc:
     # @return [ Array<Document> ] The children.
     #
     # @since 2.3.0
-    def cascadable_children(kind)
-      [].tap do |children|
-        relations.each_pair do |name, metadata|
-          next unless metadata.cascading_callbacks?
+    def cascadable_children(kind, children = Set.new)
+      embedded_relations.each_pair do |name, metadata|
+        next unless metadata.cascading_callbacks?
+        without_autobuild do
           delayed_pulls = delayed_atomic_pulls[name]
-          children.concat(delayed_pulls) if delayed_pulls
-          child = send(name)
-          Array.wrap(child).each do |doc|
-            children.push(doc) if cascadable_child?(kind, doc)
-            children.concat(doc.send(:cascadable_children, kind))
+          delayed_unsets = delayed_atomic_unsets[name]
+          children.merge(delayed_pulls) if delayed_pulls
+          children.merge(delayed_unsets) if delayed_unsets
+          relation = send(name)
+          Array.wrap(relation).each do |child|
+            next if children.include?(child)
+            children.add(child) if cascadable_child?(kind, child)
+            children.merge(child.send(:cascadable_children, kind, children))
           end
         end
       end
+      children.to_a
     end
 
     # Determine if the child should fire the callback.
@@ -132,5 +168,32 @@ module Mongoid #:nodoc:
         kind
       end
     end
+
+    # Run only the callbacks for the target location (before, after, around)
+    # and kind (save, update, create).
+    #
+    # @example Run the targeted callbacks.
+    #   model.run_targeted_callbacks(:before, :save)
+    #
+    # @param [ Symbol ] place The time to run, :before, :after, :around.
+    # @param [ Symbol ] kind The type of callback, :save, :create, :update.
+    #
+    # @return [ Object ] The result of the chain execution.
+    #
+    # @since 3.0.0
+    def run_targeted_callbacks(place, kind)
+      name = "_run__#{place}__#{kind}__callbacks"
+      unless respond_to?(name)
+        chain = ActiveSupport::Callbacks::CallbackChain.new(name, {})
+        send("_#{kind}_callbacks").each do |callback|
+          chain.push(callback) if callback.kind == place
+        end
+        class_eval <<-EOM
+          def #{name}() #{chain.compile} end
+          protected :#{name}
+        EOM
+      end
+      send(name)
+    end
   end
 end

data/lib/mongoid/components.rb

@@ -1,6 +1,6 @@
 # encoding: utf-8
-module Mongoid #:nodoc
-  module Components #:nodoc
+module Mongoid
+  module Components
     extend ActiveSupport::Concern
 
     # All modules that a +Document+ is composed of are defined in this
@@ -21,23 +21,19 @@ module Mongoid #:nodoc
     include Mongoid::Atomic
     include Mongoid::Dirty
     include Mongoid::Attributes
-    include Mongoid::Collections
-    include Mongoid::Copyable
-    include Mongoid::DefaultScope
-    include Mongoid::Extras
+    include Mongoid::Evolvable
     include Mongoid::Fields
     include Mongoid::Hierarchy
     include Mongoid::Indexes
     include Mongoid::Inspection
     include Mongoid::JSON
-    include Mongoid::Keys
     include Mongoid::Matchers
-    include Mongoid::NamedScope
     include Mongoid::NestedAttributes
     include Mongoid::Persistence
     include Mongoid::Relations
     include Mongoid::Reloading
-    include Mongoid::Safety
+    include Mongoid::Scoping
+    include Mongoid::Sessions
     include Mongoid::Serialization
     include Mongoid::Sharding
     include Mongoid::State
@@ -45,35 +41,30 @@ module Mongoid #:nodoc
     include Mongoid::Timestamps::Timeless
     include Mongoid::Validations
     include Mongoid::Callbacks
-    include Mongoid::MultiDatabase
+    include Mongoid::Copyable
 
     MODULES = [
       Mongoid::Atomic,
       Mongoid::Attributes,
-      Mongoid::Collections,
       Mongoid::Copyable,
-      Mongoid::DefaultScope,
       Mongoid::Dirty,
-      Mongoid::Extras,
       Mongoid::Fields,
       Mongoid::Hierarchy,
       Mongoid::Indexes,
       Mongoid::Inspection,
       Mongoid::JSON,
-      Mongoid::Keys,
+      Mongoid::Loggable,
       Mongoid::Matchers,
-      Mongoid::NamedScope,
       Mongoid::NestedAttributes,
       Mongoid::Persistence,
       Mongoid::Relations,
       Mongoid::Relations::Proxy,
-      Mongoid::Safety,
+      Mongoid::Scoping,
       Mongoid::Serialization,
       Mongoid::Sharding,
       Mongoid::State,
       Mongoid::Validations,
-      Mongoid::Callbacks,
-      Mongoid::MultiDatabase,
+      Mongoid::Callbacks
     ]
 
     class << self
@@ -88,11 +79,9 @@ module Mongoid #:nodoc
       #
       # @since 2.1.8
       def prohibited_methods
-        @prohibited_methods ||= MODULES.inject([]) do |methods, mod|
-          methods.tap do |mets|
-            mets << mod.instance_methods.map{ |m| m.to_sym }
-          end
-        end.flatten
+        @prohibited_methods ||= MODULES.flat_map do |mod|
+          mod.instance_methods.map{ |m| m.to_sym }
+        end
       end
     end
   end

data/lib/mongoid/config/environment.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
-module Mongoid #:nodoc
+module Mongoid
   module Config
 
     # Encapsulates logic for getting environment information.
@@ -8,11 +8,13 @@ module Mongoid #:nodoc
 
       # Get the name of the environment that we are running under. This first
       # looks for Rails, then Sinatra, then a RACK_ENV environment variable,
-      # and if none of those are found returns "development".
+      # and if none of those are found raises an error.
       #
       # @example Get the env name.
       #   Environment.env_name
       #
+      # @raise [ Errors::NoEnvironment ] If no environment was set.
+      #
       # @return [ String ] The name of the current environment.
       #
       # @since 2.3.0
@@ -33,8 +35,9 @@ module Mongoid #:nodoc
       # @return [ Hash ] The settings.
       #
       # @since 2.3.0
-      def load_yaml(path)
-        YAML.load(ERB.new(File.new(path).read).result)[env_name]
+      def load_yaml(path, environment = nil)
+        env = environment ? environment.to_s : env_name
+        YAML.load(ERB.new(File.new(path).read).result)[env]
       end
     end
   end

data/lib/mongoid/config/inflections.rb

@@ -0,0 +1,6 @@
+# encoding: utf-8
+ActiveSupport::Inflector.inflections do |inflect|
+  inflect.singular(/address$/, "address")
+  inflect.singular("addresses", "address")
+  inflect.irregular("canvas", "canvases")
+end

data/lib/mongoid/config/options.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
-module Mongoid #:nodoc
+module Mongoid
   module Config
 
     # Encapsulates logic for setting options.

data/lib/mongoid/config/validators/option.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+module Mongoid
+  module Config
+    module Validators
+
+      # Validator for configuration options.
+      module Option
+        extend self
+
+        # Validate a configuration option.
+        #
+        # @example Validate a configuraiton option.
+        #
+        # @param [ String ] option The name of the option.
+        #
+        # @since 3.0.0
+        def validate(option)
+          unless Config.settings.keys.include?(option.to_sym)
+            raise Errors::InvalidConfigOption.new(option)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/config/validators/session.rb

@@ -0,0 +1,140 @@
+# encoding: utf-8
+module Mongoid
+  module Config
+    module Validators
+
+      # Validator for session specific configuration.
+      module Session
+        extend self
+
+        STANDARD = [ :database, :hosts, :username, :password ]
+
+        # Validate the session configuration.
+        #
+        # @example Validate the session config.
+        #   Session.validate({ default: { hosts: [ "localhost:27017" ] }})
+        #
+        # @param [ Hash ] sessions The sessions config.
+        #
+        # @since 3.0.0
+        def validate(sessions)
+          unless sessions.has_key?(:default)
+            raise Errors::NoDefaultSession.new(sessions.keys)
+          end
+          sessions.each_pair do |name, config|
+            validate_session_database(name, config)
+            validate_session_hosts(name, config)
+            validate_session_uri(name, config)
+          end
+        end
+
+        private
+
+        # Validate that the session config has database.
+        #
+        # @api private
+        #
+        # @example Validate the session has database.
+        #   validator.validate_session_database(:default, {})
+        #
+        # @param [ String, Symbol ] name The config key.
+        # @param [ Hash ] config The configuration.
+        #
+        # @since 3.0.0
+        def validate_session_database(name, config)
+          if no_database_or_uri?(config)
+            raise Errors::NoSessionDatabase.new(name, config)
+          end
+        end
+
+        # Validate that the session config has hosts.
+        #
+        # @api private
+        #
+        # @example Validate the session has hosts.
+        #   validator.validate_session_hosts(:default, {})
+        #
+        # @param [ String, Symbol ] name The config key.
+        # @param [ Hash ] config The configuration.
+        #
+        # @since 3.0.0
+        def validate_session_hosts(name, config)
+          if no_hosts_or_uri?(config)
+            raise Errors::NoSessionHosts.new(name, config)
+          end
+        end
+
+        # Validate that not both a uri and standard options are provided for a
+        # single session.
+        #
+        # @api private
+        #
+        # @example Validate the uri and options.
+        #   validator.validate_session_uri(:default, {})
+        #
+        # @param [ String, Symbol ] name The config key.
+        # @param [ Hash ] config The configuration.
+        #
+        # @since 3.0.0
+        def validate_session_uri(name, config)
+          if both_uri_and_standard?(config)
+            raise Errors::MixedSessionConfiguration.new(name, config)
+          end
+        end
+
+        # Return true if the configuration has no database or uri option
+        # defined.
+        #
+        # @api private
+        #
+        # @example Validate the options.
+        #   validator.no_database_or_uri?(config)
+        #
+        # @param [ Hash ] config The configuration options.
+        #
+        # @return [ true, false ] If no database or uri is defined.
+        #
+        # @since 3.0.0
+        def no_database_or_uri?(config)
+          !config.has_key?(:database) && !config.has_key?(:uri)
+        end
+
+        # Return true if the configuration has no hosts or uri option
+        # defined.
+        #
+        # @api private
+        #
+        # @example Validate the options.
+        #   validator.no_hosts_or_uri?(config)
+        #
+        # @param [ Hash ] config The configuration options.
+        #
+        # @return [ true, false ] If no hosts or uri is defined.
+        #
+        # @since 3.0.0
+        def no_hosts_or_uri?(config)
+          !config.has_key?(:hosts) && !config.has_key?(:uri)
+        end
+
+        # Return true if the configuration has both standard options and a uri
+        # defined.
+        #
+        # @api private
+        #
+        # @example Validate the options.
+        #   validator.no_database_or_uri?(config)
+        #
+        # @param [ Hash ] config The configuration options.
+        #
+        # @return [ true, false ] If both standard and uri are defined.
+        #
+        # @since 3.0.0
+        def both_uri_and_standard?(config)
+          config.has_key?(:uri) && config.keys.any? do |key|
+            STANDARD.include?(key.to_sym)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/config/validators.rb

@@ -0,0 +1,3 @@
+# encoding: utf-8
+require "mongoid/config/validators/option"
+require "mongoid/config/validators/session"