mongoid 6.4.8 → 7.0.13

data/lib/mongoid/atomic.rb

@@ -36,7 +36,9 @@ module Mongoid
     # @since 2.2.0
     def add_atomic_pull(document)
       document.flagged_for_destroy = true
-      (delayed_atomic_pulls[document.metadata_name.to_s] ||= []).push(document)
+      key = document.association_name.to_s
+      delayed_atomic_pulls[key] ||= []
+      delayed_atomic_pulls[key] << document
     end
 
     # Add an atomic unset for the document.
@@ -51,7 +53,9 @@ module Mongoid
     # @since 3.0.0
     def add_atomic_unset(document)
       document.flagged_for_destroy = true
-      (delayed_atomic_unsets[document.metadata_name.to_s] ||= []).push(document)
+      key = document.association_name.to_s
+      delayed_atomic_unsets[key] ||= []
+      delayed_atomic_unsets[key] << document
     end
 
     # Returns path of the attribute for modification
@@ -189,7 +193,13 @@ module Mongoid
     #
     # @since 2.1.0
     def atomic_paths
-      @atomic_paths ||= __metadata ? __metadata.path(self) : Atomic::Paths::Root.new(self)
+      @atomic_paths ||= begin
+        if _association
+          _association.path(self)
+        else
+          Atomic::Paths::Root.new(self)
+        end
+      end
     end
 
     # Get all the attributes that need to be pulled.
@@ -218,7 +228,7 @@ module Mongoid
     # @example Get the pushes.
     #   person.atomic_pushes
     #
-    # @return [ Hash ] The The $push and $each operations.
+    # @return [ Hash ] The $push and $each operations.
     #
     # @since 2.1.0
     def atomic_pushes

data/lib/mongoid/attributes/dynamic.rb

@@ -38,12 +38,13 @@ module Mongoid
       # @since 4.0.0
       def define_dynamic_reader(name)
         return unless name.valid_method_name?
-        class_eval <<-READER, __FILE__, __LINE__ + 1
-          def #{name}
-            attribute_will_change!(#{name.inspect})
-            read_attribute(#{name.inspect})
+
+        class_eval do
+          define_method(name) do
+            attribute_will_change!(name)
+            read_raw_attribute(name)
           end
-        READER
+        end
       end
 
       # Define a reader method for a dynamic attribute before type cast.
@@ -57,12 +58,12 @@ module Mongoid
       #
       # @since 4.0.0
       def define_dynamic_before_type_cast_reader(name)
-        class_eval <<-READER, __FILE__, __LINE__ + 1
-          def #{name}_before_type_cast
-            attribute_will_change!(#{name.inspect})
-            read_attribute_before_type_cast(#{name.inspect})
+        class_eval do
+          define_method("#{name}_before_type_cast") do
+            attribute_will_change!(name)
+            read_attribute_before_type_cast(name)
           end
-        READER
+        end
       end
 
       # Define a writer method for a dynamic attribute.
@@ -78,11 +79,11 @@ module Mongoid
       def define_dynamic_writer(name)
         return unless name.valid_method_name?
 
-        class_eval <<-WRITER, __FILE__, __LINE__ + 1
-          def #{name}=(value)
-            write_attribute(#{name.inspect}, value)
+        class_eval do
+          define_method("#{name}=") do |value|
+            write_attribute(name, value)
           end
-        WRITER
+        end
       end
 
       # If the attribute is dynamic, add a field for it with a type of object
@@ -147,7 +148,7 @@ module Mongoid
           getter = attr.reader
           define_dynamic_reader(getter)
           attribute_will_change!(attr.reader)
-          read_attribute(getter)
+          read_raw_attribute(getter)
         end
       end
     end

data/lib/mongoid/attributes/nested.rb

@@ -42,21 +42,27 @@ module Mongoid
         #   to a class method to reject documents with.
         # @option *args [ Integer ] :limit The max number to create.
         # @option *args [ true, false ] :update_only Only update existing docs.
+        # @options *args [ true, false ] :autosave Whether autosave should be enabled on the
+        #   association. Note that since the default is true, setting autosave to nil will still
+        #   enable it.
         def accepts_nested_attributes_for(*args)
-          options = args.extract_options!
+          options = args.extract_options!.dup
+          options[:autosave] = true if options[:autosave].nil?
+
           options[:reject_if] = REJECT_ALL_BLANK_PROC if options[:reject_if] == :all_blank
           args.each do |name|
             meth = "#{name}_attributes="
             self.nested_attributes["#{name}_attributes"] = meth
-            metadata = relations[name.to_s]
-            raise Errors::NestedAttributesMetadataNotFound.new(self, name) unless metadata
-            autosave_nested_attributes(metadata)
+            association = relations[name.to_s]
+            raise Errors::NestedAttributesMetadataNotFound.new(self, name) unless association
+            autosave_nested_attributes(association) if options[:autosave]
+
             re_define_method(meth) do |attrs|
               _assigning do
-                if metadata.polymorphic? and metadata.inverse_type
-                  options = options.merge!(:class_name => self.send(metadata.inverse_type))
+                if association.polymorphic? and association.inverse_type
+                  options = options.merge!(:class_name => self.send(association.inverse_type))
                 end
-                metadata.nested_builder(attrs, options).build(self)
+                association.nested_builder(attrs, options).build(self)
               end
             end
           end
@@ -71,12 +77,17 @@ module Mongoid
         # @example Add the autosave if appropriate.
         #   Person.autosave_nested_attributes(metadata)
         #
-        # @param [ Metadata ] metadata The existing relation metadata.
+        # @param [ Association ] association The existing association metadata.
         #
         # @since 3.1.4
-        def autosave_nested_attributes(metadata)
-          unless metadata.autosave == false
-            autosave(metadata.merge!(autosave: true))
+        def autosave_nested_attributes(association)
+          # In order for the autosave functionality to work properly, the association needs to be
+          # marked as autosave despite the fact that the option isn't present. Because the method
+          # Association#autosave? is implemented by checking the autosave option, this is the most
+          # straightforward way to mark it.
+          if association.autosave? || (association.options[:autosave].nil? && !association.embedded?)
+            association.options[:autosave] = true
+            Association::Referenced::AutoSave.define_autosave!(association)
           end
         end
       end

data/lib/mongoid/attributes/processing.rb

@@ -133,9 +133,9 @@ module Mongoid
       # @since 2.0.0.rc.7
       def process_relations
         pending_relations.each_pair do |name, value|
-          metadata = relations[name]
+          association = relations[name]
           if value.is_a?(Hash)
-            metadata.nested_builder(value, {}).build(self)
+            association.nested_builder(value, {}).build(self)
           else
             send("#{name}=", value)
           end

data/lib/mongoid/attributes/readonly.rb

@@ -22,17 +22,15 @@ module Mongoid
       #   readonly.
       #
       # @since 3.0.0
-      #
-      # @deprecated Use #as_writable_attribute! instead.
       def attribute_writable?(name)
-        new_record? || !readonly_attributes.include?(database_field_name(name))
+        new_record? || (!readonly_attributes.include?(name) && _loaded?(name))
       end
 
       private
 
       def as_writable_attribute!(name, value = :nil)
         normalized_name = database_field_name(name)
-        if new_record? || (!readonly_attributes.include?(normalized_name) && _loaded?(normalized_name))
+        if attribute_writable?(normalized_name)
           yield(normalized_name)
         else
           raise Errors::ReadonlyAttribute.new(name, value)

data/lib/mongoid/attributes.rb

@@ -29,7 +29,7 @@ module Mongoid
     #
     # @since 1.0.0
     def attribute_present?(name)
-      attribute = read_attribute(name)
+      attribute = read_raw_attribute(name)
       !attribute.blank? || attribute == false
     rescue ActiveModel::MissingAttributeError
       false
@@ -92,21 +92,15 @@ module Mongoid
     #
     # @since 1.0.0
     def read_attribute(name)
-      normalized = database_field_name(name.to_s)
-      if attribute_missing?(normalized)
-        raise ActiveModel::MissingAttributeError, "Missing attribute: '#{name}'."
-      end
-      if hash_dot_syntax?(normalized)
-        attributes.__nested__(normalized)
-      else
-        attributes[normalized]
-      end
+      field = fields[name.to_s]
+      raw = read_raw_attribute(name)
+      field ? field.demongoize(raw) : raw
     end
     alias :[] :read_attribute
 
     # Read a value from the attributes before type cast. If the value has not
     # yet been assigned then this will return the attribute's existing value
-    # using read_attribute.
+    # using read_raw_attribute.
     #
     # @example Read an attribute before type cast.
     #   person.read_attribute_before_type_cast(:price)
@@ -122,7 +116,7 @@ module Mongoid
       if attributes_before_type_cast.key?(attr)
         attributes_before_type_cast[attr]
       else
-        read_attribute(attr)
+        read_raw_attribute(attr)
       end
     end
 
@@ -163,23 +157,31 @@ module Mongoid
     #
     # @since 1.0.0
     def write_attribute(name, value)
-      as_writable_attribute!(name) do |access|
+      field_name = database_field_name(name)
+
+      if attribute_missing?(field_name)
+        raise ActiveModel::MissingAttributeError, "Missing attribute: '#{name}'"
+      end
+
+      if attribute_writable?(field_name)
         _assigning do
-          validate_attribute_value(access, value)
-          localized = fields[access].try(:localized?)
+          validate_attribute_value(field_name, value)
+          localized = fields[field_name].try(:localized?)
           attributes_before_type_cast[name.to_s] = value
-          typed_value = typed_value_for(access, value)
-          unless attributes[access] == typed_value || attribute_changed?(access)
-            attribute_will_change!(access)
+          typed_value = typed_value_for(field_name, value)
+          unless attributes[field_name] == typed_value || attribute_changed?(field_name)
+            attribute_will_change!(field_name)
           end
           if localized
-            attributes[access] ||= {}
-            attributes[access].merge!(typed_value)
+            attributes[field_name] ||= {}
+            attributes[field_name].merge!(typed_value)
           else
-            attributes[access] = typed_value
+            attributes[field_name] = typed_value
           end
           typed_value
         end
+      else
+        # TODO: MONGOID-5072
       end
     end
     alias :[]= :write_attribute
@@ -292,6 +294,20 @@ module Mongoid
       fields.key?(key) ? fields[key].mongoize(value) : value.mongoize
     end
 
+    private
+
+    def read_raw_attribute(name)
+      normalized = database_field_name(name.to_s)
+      if attribute_missing?(normalized)
+        raise ActiveModel::MissingAttributeError, "Missing attribute: '#{name}'"
+      end
+      if hash_dot_syntax?(normalized)
+        attributes.__nested__(normalized)
+      else
+        attributes[normalized]
+      end
+    end
+
     module ClassMethods
 
       # Alias the provided name to the original field. This will provide an
@@ -328,20 +344,28 @@ module Mongoid
 
     private
 
-    # Validates an attribute value. This provides validation checking if
-    # the value is valid for given a field.
-    # For now, only Hash and Array fields are validated.
+    # Validates an attribute value as being assignable to the specified field.
+    #
+    # For now, only Hash and Array fields are validated, and the value is
+    # being checked to be of an appropriate type (i.e. either Hash or Array,
+    # respectively, or nil).
+    #
+    # This method takes the name of the field as stored in the document
+    # in the database, not (necessarily) the Ruby method name used to read/write
+    # the said field.
     #
-    # @param [ String, Symbol ] access The name of the attribute to validate.
-    # @param [ Object ] value The to be validated.
+    # @param [ String, Symbol ] field_name The name of the field.
+    # @param [ Object ] value The value to be validated.
     #
     # @since 3.0.10
-    def validate_attribute_value(access, value)
-      return unless fields[access] && value
+    def validate_attribute_value(field_name, value)
+      return if value.nil?
+      field = fields[field_name]
+      return unless field
       validatable_types = [ Hash, Array ]
-      if validatable_types.include? fields[access].type
-        unless value.is_a? fields[access].type
-          raise Mongoid::Errors::InvalidValue.new(fields[access].type, value.class)
+      if validatable_types.include?(field.type)
+        unless value.is_a?(field.type)
+          raise Mongoid::Errors::InvalidValue.new(field.type, value.class)
         end
       end
     end

data/lib/mongoid/changeable.rb

@@ -227,7 +227,7 @@ module Mongoid
     # @since 2.3.0
     def attribute_will_change!(attr)
       unless changed_attributes.key?(attr)
-        changed_attributes[attr] = read_attribute(attr).__deep_copy__
+        changed_attributes[attr] = read_raw_attribute(attr).__deep_copy__
       end
     end
 

data/lib/mongoid/clients/options.rb

@@ -20,11 +20,12 @@ module Mongoid
       #
       # @since 6.0.0
       def with(options_or_context, &block)
+        original_context = PersistenceContext.get(self)
         original_cluster = persistence_context.cluster
         set_persistence_context(options_or_context)
         yield self
       ensure
-        clear_persistence_context(original_cluster)
+        clear_persistence_context(original_cluster, original_context)
       end
 
       def collection(parent = nil)
@@ -38,7 +39,7 @@ module Mongoid
       def mongo_client
         persistence_context.client
       end
-      
+
       def persistence_context
         PersistenceContext.get(self) ||
             PersistenceContext.get(self.class) ||
@@ -51,8 +52,8 @@ module Mongoid
         PersistenceContext.set(self, options_or_context)
       end
 
-      def clear_persistence_context(original_cluster = nil)
-        PersistenceContext.clear(self, original_cluster)
+      def clear_persistence_context(original_cluster = nil, context = nil)
+        PersistenceContext.clear(self, original_cluster, context)
       end
 
       module ClassMethods
@@ -92,11 +93,12 @@ module Mongoid
         #
         # @since 6.0.0
         def with(options, &block)
+          original_context = PersistenceContext.get(self)
           original_cluster = persistence_context.cluster
           PersistenceContext.set(self, options)
           yield self
         ensure
-          PersistenceContext.clear(self, original_cluster)
+          PersistenceContext.clear(self, original_cluster, original_context)
         end
 
         def persistence_context

data/lib/mongoid/clients/sessions.rb

@@ -38,12 +38,20 @@ module Mongoid
       #
       # @since 6.4.0
       def with_session(options = {})
-        raise Mongoid::Errors::InvalidSessionUse.new(:invalid_session_nesting) if Threaded.get_session
+        if Threaded.get_session
+          raise Mongoid::Errors::InvalidSessionUse.new(:invalid_session_nesting)
+        end
         session = persistence_context.client.start_session(options)
         Threaded.set_session(session)
         yield(session)
       rescue Mongo::Error::InvalidSession => ex
-        if ex.message == Mongo::Session::SESSIONS_NOT_SUPPORTED
+        if
+          # Driver 2.13.0+
+          defined?(Mongo::Error::SessionsNotSupported) &&
+            Mongo::Error::SessionsNotSupported === ex ||
+          # Legacy drivers
+          ex.message == Mongo::Session::SESSIONS_NOT_SUPPORTED
+        then
           raise Mongoid::Errors::InvalidSessionUse.new(:sessions_not_supported)
         end
         raise Mongoid::Errors::InvalidSessionUse.new(:invalid_session_use)
@@ -89,12 +97,20 @@ module Mongoid
         #
         # @since 6.4.0
         def with_session(options = {})
-          raise Mongoid::Errors::InvalidSessionUse.new(:invalid_session_nesting) if Threaded.get_session
+          if Threaded.get_session
+            raise Mongoid::Errors::InvalidSessionUse.new(:invalid_session_nesting)
+          end
           session = persistence_context.client.start_session(options)
           Threaded.set_session(session)
           yield(session)
         rescue Mongo::Error::InvalidSession => ex
-          if ex.message == Mongo::Session::SESSIONS_NOT_SUPPORTED
+          if
+            # Driver 2.13.0+
+            defined?(Mongo::Error::SessionsNotSupported) &&
+              Mongo::Error::SessionsNotSupported === ex ||
+            # Legacy drivers
+            ex.message == Mongo::Session::SESSIONS_NOT_SUPPORTED
+          then
             raise Mongoid::Errors::InvalidSessionUse.new(:sessions_not_supported)
           end
           raise Mongoid::Errors::InvalidSessionUse.new(:invalid_session_use)

data/lib/mongoid/composable.rb

@@ -43,7 +43,7 @@ module Mongoid
     include Inspectable
     include Matchable
     include Persistable
-    include Relations
+    include Association
     include Reloadable
     include Scopable
     include Selectable
@@ -70,7 +70,7 @@ module Mongoid
       Interceptable,
       Matchable,
       Persistable,
-      Relations,
+      Association,
       Reloadable,
       Scopable,
       Serializable,
@@ -83,8 +83,8 @@ module Mongoid
       Traversable,
       Validatable,
       Equality,
-      Relations::Synchronization,
-      Relations::Macros,
+      Association::Referenced::Syncable,
+      Association::Macros,
       ActiveModel::Model,
       ActiveModel::Validations
     ]

data/lib/mongoid/config/environment.rb

@@ -6,35 +6,48 @@ module Mongoid
     module Environment
       extend self
 
-      # 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 raises an error.
+      # Get the name of the environment that Mongoid is running under.
+      #
+      # Uses the following sources in order:
+      # - If +::Rails+ is defined, +Rails.env+.
+      # - If +::Sinatra+ is defined, +Sinatra::Base.environment+.
+      # - +RACK_ENV+
+      # - +MONGOID_ENV*
       #
       # @example Get the env name.
       #   Environment.env_name
       #
-      # @raise [ Errors::NoEnvironment ] If no environment was set.
+      # @raise [ Errors::NoEnvironment ] If environment name cannot be
+      #   determined because none of the sources was set.
       #
       # @return [ String ] The name of the current environment.
       #
       # @since 2.3.0
+      # @api public
       def env_name
-        return Rails.env if defined?(Rails) && Rails.respond_to?(:env)
-        return Sinatra::Base.environment.to_s if defined?(Sinatra)
-        ENV["RACK_ENV"] || ENV["MONGOID_ENV"] || raise(Errors::NoEnvironment.new)
+        if defined?(::Rails)
+          return ::Rails.env
+        end
+        if defined?(::Sinatra)
+          return ::Sinatra::Base.environment.to_s
+        end
+        ENV["RACK_ENV"] || ENV["MONGOID_ENV"] or raise Errors::NoEnvironment
       end
 
       # Load the yaml from the provided path and return the settings for the
-      # current environment.
+      # specified environment, or for the current Mongoid environment.
       #
       # @example Load the yaml.
       #   Environment.load_yaml("/work/mongoid.yml")
       #
       # @param [ String ] path The location of the file.
+      # @param [ String | Symbol ] environment Optional environment name to
+      #   override the current Mongoid environment.
       #
       # @return [ Hash ] The settings.
       #
       # @since 2.3.0
+      # @api private
       def load_yaml(path, environment = nil)
         env = environment ? environment.to_s : env_name
         YAML.load(ERB.new(File.new(path).read).result)[env]

data/lib/mongoid/config.rb

@@ -27,6 +27,7 @@ module Mongoid
     option :log_level, default: :info
     option :belongs_to_required_by_default, default: true
     option :app_name, default: nil
+    option :background_indexing, default: false
 
     # Has Mongoid been configured? This is checking that at least a valid
     # client config exists.

data/lib/mongoid/contextual/atomic.rb

@@ -118,7 +118,7 @@ module Mongoid
       # @since 3.0.0
       def push_all(pushes)
         push_each_updates = collect_operations(pushes).each.inject({}) do |ops, (field, elements)|
-          ops.merge!(field => {'$each' => elements})
+          ops.merge!(field => { '$each' => elements })
         end
         view.update_many("$push" => push_each_updates)
       end

data/lib/mongoid/contextual/geo_near.rb

@@ -242,7 +242,7 @@ module Mongoid
       # @since 3.0.0
       def documents
         results["results"].map do |attributes|
-          doc = Factory.from_db(criteria.klass, attributes["obj"], criteria.options[:fields])
+          doc = Factory.from_db(criteria.klass, attributes["obj"], criteria)
           doc.attributes["geo_near_distance"] = attributes["dis"]
           doc
         end

data/lib/mongoid/contextual/memory.rb

@@ -1,13 +1,13 @@
 # encoding: utf-8
 require "mongoid/contextual/aggregable/memory"
-require "mongoid/relations/eager"
+require "mongoid/association/eager_loadable"
 
 module Mongoid
   module Contextual
     class Memory
       include Enumerable
       include Aggregable::Memory
-      include Relations::Eager
+      include Association::EagerLoadable
       include Queryable
       include Positional
 
@@ -130,7 +130,7 @@ module Mongoid
       # @return [ Document ] The first document.
       #
       # @since 3.0.0
-      def first
+      def first(*args)
         eager_load([documents.first]).first
       end
       alias :one :first
@@ -155,6 +155,22 @@ module Mongoid
         apply_options
       end
 
+      # Increment a value on all documents.
+      #
+      # @example Perform the increment.
+      #   context.inc(likes: 10)
+      #
+      # @param [ Hash ] incs The operations.
+      #
+      # @return [ Enumerator ] The enumerator.
+      #
+      # @since 7.0.0
+      def inc(*args)
+        each do |document|
+          document.inc *args
+        end
+      end
+
       # Get the last document in the database for the criteria's selector.
       #
       # @example Get the last document.
@@ -446,6 +462,8 @@ module Mongoid
         doc.destroyed = true
       end
 
+      private
+
       def _session
         @criteria.send(:_session)
       end