mongoid 3.1.7 → 4.0.2

data/lib/mongoid/{scoping.rb → scopable.rb}

@@ -1,9 +1,12 @@
 # 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
+  #
+  # @since 4.0.0
+  module Scopable
     extend ActiveSupport::Concern
 
     included do
@@ -12,6 +15,27 @@ module Mongoid
       self._declared_scopes = {}
     end
 
+    private
+
+    # Apply the default scoping to the attributes of the document, as long as
+    # they are not complex queries.
+    #
+    # @api private
+    #
+    # @example Apply the default scoping.
+    #   document.apply_default_scoping
+    #
+    # @return [ true, false ] If default scoping was applied.
+    #
+    # @since 4.0.0
+    def apply_default_scoping
+      if default_scoping
+        default_scoping.call.selector.each do |field, value|
+          attributes[field] = value unless value.respond_to?(:each_pair)
+        end
+      end
+    end
+
     module ClassMethods
 
       # Returns a hash of all the scopes defined for this class, including
@@ -22,7 +46,7 @@ module Mongoid
       #     include Mongoid::Document
       #     field :active, type: Boolean
       #
-      #     scope :active, where(active: true)
+      #     scope :active, -> { where(active: true) }
       #   end
       #   Band.scopes
       #
@@ -104,14 +128,14 @@ module Mongoid
       #     field :active, type: Boolean
       #     field :count, type: Integer
       #
-      #     scope :active, where(active: true)
+      #     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.
+      # @param [ Proc ] conditions The conditions of the scope.
       #
-      # @raise [ Errors::InvalidScope ] If the scope is not a proc or criteria.
+      # @raise [ Errors::InvalidScope ] If the scope is not a proc.
       # @raise [ Errors::ScopeOverwrite ] If the scope name already exists.
       #
       # @since 1.0.0
@@ -120,7 +144,7 @@ module Mongoid
         check_scope_validity(value)
         check_scope_name(normalized)
         _declared_scopes[normalized] = {
-          scope: strip_default_scope(value),
+          scope: value,
           extension: Module.new(&block)
         }
         define_scope_method(normalized)
@@ -279,7 +303,7 @@ module Mongoid
       #
       # @since 3.0.0
       def check_scope_validity(value)
-        unless value.respond_to?(:to_proc)
+        unless value.respond_to?(:call)
           raise Errors::InvalidScope.new(self, value)
         end
       end
@@ -298,15 +322,15 @@ module Mongoid
       #
       # @since 3.0.0
       def define_scope_method(name)
-        (class << self; self; end).class_eval <<-SCOPE, __FILE__, __LINE__ + 1
-          def #{name}(*args)
-            scoping = _declared_scopes[:#{name}]
+        singleton_class.class_eval do
+          define_method name do |*args|
+            scoping = _declared_scopes[name]
             scope, extension = scoping[:scope][*args], scoping[:extension]
-            criteria = with_default_scope.merge(scope || all)
+            criteria = with_default_scope.merge(scope || queryable)
             criteria.extend(extension)
             criteria
           end
-        SCOPE
+        end
       end
 
       # Process the default scope value. If one already exists, we merge the
@@ -327,30 +351,6 @@ module Mongoid
           value.to_proc
         end
       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/selectable.rb

@@ -0,0 +1,59 @@
+# encoding: utf-8
+module Mongoid
+
+  # Provides behaviour for generating the selector for a specific document.
+  #
+  # @since 4.0.0
+  module Selectable
+    extend ActiveSupport::Concern
+
+    # Get the atomic selector for the document. This is a hash in the simplest
+    # case { "_id" => id }, but can become more complex for embedded documents
+    # and documents that use a shard key.
+    #
+    # @example Get the document's atomic selector.
+    #   document.atomic_selector
+    #
+    # @return [ Hash ] The document's selector.
+    #
+    # @since 1.0.0
+    def atomic_selector
+      @atomic_selector ||=
+        (embedded? ? embedded_atomic_selector : root_atomic_selector)
+    end
+
+    private
+
+    # Get the atomic selector for an embedded document.
+    #
+    # @api private
+    #
+    # @example Get the embedded atomic selector.
+    #   document.embedded_atomic_selector
+    #
+    # @return [ Hash ] The embedded document selector.
+    #
+    # @since 4.0.0
+    def embedded_atomic_selector
+      if persisted? && _id_changed?
+        _parent.atomic_selector
+      else
+        _parent.atomic_selector.merge("#{atomic_path}._id" => _id)
+      end
+    end
+
+    # Get the atomic selector for a root document.
+    #
+    # @api private
+    #
+    # @example Get the root atomic selector.
+    #   document.root_atomic_selector
+    #
+    # @return [ Hash ] The root document selector.
+    #
+    # @since 4.0.0
+    def root_atomic_selector
+      { "_id" => _id }.merge!(shard_key_selector)
+    end
+  end
+end

data/lib/mongoid/{serialization.rb → serializable.rb}

@@ -3,9 +3,18 @@ module Mongoid
 
   # This module provides the extra behaviour for including relations in JSON
   # and XML serialization.
-  module Serialization
+  #
+  # @since 4.0.0
+  module Serializable
     extend ActiveSupport::Concern
 
+    # We need to redefine where the JSON configuration is getting defined,
+    # similar to +ActiveRecord+.
+    included do
+      undef_method :include_root_in_json
+      delegate :include_root_in_json, to: ::Mongoid
+    end
+
     # Gets the document as a serializable hash, used by ActiveModel's JSON
     # serializer.
     #
@@ -93,7 +102,7 @@ module Mongoid
         attrs[name] = value ? value.serializable_hash(options) : nil
       elsif names.include?(name) && !fields.has_key?(name)
         attrs[name] = read_attribute(name)
-      else
+      elsif !attribute_missing?(name)
         attrs[name] = send(name)
       end
     end

data/lib/mongoid/sessions/factory.rb

@@ -61,6 +61,8 @@ module Mongoid
         raise Errors::NoSessionsConfig.new unless configuration
         config, options = parse(configuration)
         configuration.merge!(config) if configuration.delete(:uri)
+
+        options[:instrumenter] = ActiveSupport::Notifications
         session = Moped::Session.new(config[:hosts], options)
         session.use(config[:database])
         if authenticated?(config)

data/lib/mongoid/sessions/options.rb

@@ -0,0 +1,185 @@
+# encoding: utf-8
+module Mongoid
+  module Sessions
+    module Options
+      extend ActiveSupport::Concern
+
+      # 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)
+        @persistence_options = options
+        self
+      end
+
+      def persistence_options
+        @persistence_options
+      end
+
+      def mongo_session
+        if persistence_options
+          if persistence_options[:session]
+            session = Sessions.with_name(persistence_options[:session])
+          else
+            session = Sessions.with_name(self.class.session_name)
+            session.use(self.class.database_name)
+          end
+          session.with(persistence_options)
+        end
+      end
+
+      def collection_name
+        if persistence_options && v = persistence_options[:collection]
+          return v.to_sym
+        end
+      end
+
+      module Threaded
+
+        # Get the persistence options for the current thread.
+        #
+        # @example Get the persistence options.
+        #   Threaded.persistence_options(Band)
+        #
+        # @param [ Class ] klass The model class.
+        #
+        # @return [ Hash ] The current persistence options.
+        #
+        # @since 4.0.0
+        def persistence_options(klass = self)
+          Thread.current["[mongoid][#{klass}]:persistence-options"]
+        end
+
+        private
+        # Set the persistence options on the current thread.
+        #
+        # @api private
+        #
+        # @example Set the persistence options.
+        #   Threaded.set_persistence_options(Band, { safe: { fsync: true }})
+        #
+        # @param [ Class ] klass The model class.
+        # @param [ Hash ] options The persistence options.
+        #
+        # @return [ Hash ] The persistence options.
+        #
+        # @since 4.0.0
+        def set_persistence_options(klass, options)
+          Thread.current["[mongoid][#{klass}]:persistence-options"] = options
+        end
+      end
+
+      module ClassMethods
+        include Threaded
+
+        def session_name
+          if persistence_options && v = persistence_options[:session]
+            return v.to_sym
+          end
+          super
+        end
+
+        def collection_name
+          if persistence_options && v = persistence_options[:collection]
+            return v.to_sym
+          end
+          super
+        end
+
+        def database_name
+          if persistence_options && v = persistence_options[:database]
+            return v.to_sym
+          end
+          super
+        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)
+          Proxy.new(self, (persistence_options || {}).merge(options))
+        end
+      end
+
+      class Proxy < BasicObject
+        include Threaded
+
+        undef_method :==
+
+        def initialize(target, options)
+          @target = target
+          @options = options
+        end
+
+        def persistence_options
+          @options
+        end
+
+        def respond_to?(*args)
+          @target.respond_to?(*args)
+        end
+
+        def method_missing(name, *args, &block)
+          set_persistence_options(@target, @options)
+          ret = @target.send(name, *args, &block)
+          if Mongoid::Criteria == ret.class
+            ret.with @options
+          end
+          ret
+        ensure
+          set_persistence_options(@target, nil)
+        end
+
+        def send(symbol, *args)
+          __send__(symbol, *args)
+        end
+
+        def self.const_missing(name)
+          ::Object.const_get(name)
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/sessions/storage_options.rb

@@ -0,0 +1,140 @@
+# encoding: utf-8
+module Mongoid
+  module Sessions
+    module StorageOptions
+      extend ActiveSupport::Concern
+
+      included do
+
+        cattr_accessor :storage_options, instance_writer: false do
+          storage_options_defaults
+        end
+      end
+
+      module ClassMethods
+
+        # 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)
+          storage_options.merge!(options)
+        end
+
+        # Reset the store_in options
+        #
+        # @example Reset the store_in options
+        #   Model.reset_storage_options!
+        #
+        # @since 4.0.0
+        def reset_storage_options!
+          self.storage_options = storage_options_defaults.dup
+        end
+
+        # Get the default storage options.
+        #
+        # @example Get the default storage options.
+        #   Model.storage_options_defaults
+        #
+        # @return [ Hash ] Default storage options.
+        #
+        # @since 4.0.0
+        def storage_options_defaults
+          {
+            collection: name.collectionize.to_sym,
+            session: :default,
+            database: -> { Mongoid.sessions[session_name][:database] }
+          }
+        end
+
+        # 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
+          __evaluate__(storage_options[:collection])
+        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
+          __evaluate__(storage_options[:session])
+        end
+
+        # Get the database name for the model.
+        #
+        # @example Get the database name.
+        #   Model.database_name
+        #
+        # @return [ Symbol ] The name of the session.
+        #
+        # @since 4.0.0
+        def database_name
+          __evaluate__(storage_options[:database])
+        end
+
+        private
+
+        # Eval the provided value, either byt calling it if it responds to call
+        # or returning the value itself.
+        #
+        # @api private
+        #
+        # @example Evaluate the name.
+        #   Model.__evaluate__(:name)
+        #
+        # @param [ String, Symbol, Proc ] name The name.
+        #
+        # @return [ Symbol ] The value as a symbol.
+        #
+        # @since 3.1.0
+        def __evaluate__(name)
+          return nil unless name
+          name.respond_to?(:call) ? name.call.to_sym : name.to_sym
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/sessions/thread_options.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+module Mongoid
+  module Sessions
+    module ThreadOptions
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+
+        def session_name
+          Threaded.session_override || super
+        end
+
+        def database_name
+          Threaded.database_override || super
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/sessions/validators/storage.rb

@@ -19,12 +19,24 @@ module Mongoid
         #
         # @since 3.0.0
         def validate(klass, options)
-          if !options.is_a?(::Hash) || !valid_keys?(options)
-            raise Errors::InvalidStorageOptions.new(klass, options)
-          end
+          valid_keys?(options) or raise Errors::InvalidStorageOptions.new(klass, options)
+          valid_parent?(klass) or raise Errors::InvalidStorageParent.new(klass)
         end
 
         private
+        # Determine if the current klass is valid to change store_in
+        # options
+        #
+        # @api private
+        #
+        # @param [ Class ] klass
+        #
+        # @return [ true, false ] If the class is valid
+        #
+        # @since 4.0.0
+        def valid_parent?(klass)
+          !klass.superclass.include?(Mongoid::Document)
+        end
 
         # Determine if all keys in the options hash are valid.
         #
@@ -39,6 +51,7 @@ module Mongoid
         #
         # @since 3.0.0
         def valid_keys?(options)
+          return false unless options.is_a?(::Hash)
           options.keys.all? do |key|
             VALID_OPTIONS.include?(key)
           end