mongoid 7.6.2 → 8.0.1

data/lib/mongoid/association/referenced/has_many/enumerable.rb

@@ -240,19 +240,15 @@ module Mongoid
           # @note Automatically adding a sort on _id when no other sort is
           #   defined on the criteria has the potential to cause bad performance issues.
           #   If you experience unexpected poor performance when using #first or #last,
-          #   use the option { id_sort: :none }.
-          #   Be aware that #first/#last won't guarantee order in this case.
+          #   use #take instead.
+          #   Be aware that #take won't guarantee order.
           #
-          # @param [ Integer | Hash ] limit_or_opts The number of documents to
-          #   return, or a hash of options.
-          #
-          # @option limit_or_opts [ :none ] :id_sort This option is deprecated.
-          #   Don't apply a sort on _id if no other sort is defined on the criteria.
+          # @param [ Integer ] limit The number of documents to return.
           #
           # @return [ Document ] The first document found.
-          def first(limit_or_opts = nil)
+          def first(limit = nil)
             _loaded.try(:values).try(:first) ||
-                _added[(ul = _unloaded.try(:first, limit_or_opts)).try(:_id)] ||
+                _added[(ul = _unloaded.try(:first, limit)).try(:_id)] ||
                 ul ||
                 _added.values.try(:first)
           end
@@ -329,20 +325,16 @@ module Mongoid
           # @note Automatically adding a sort on _id when no other sort is
           #   defined on the criteria has the potential to cause bad performance issues.
           #   If you experience unexpected poor performance when using #first or #last,
-          #   use the option { id_sort: :none }.
-          #   Be aware that #first/#last won't guarantee order in this case.
-          #
-          # @param [ Integer | Hash ] limit_or_opts The number of documents to
-          #   return, or a hash of options.
+          #   use #take instead.
+          #   Be aware that #take won't guarantee order.
           #
-          # @option limit_or_opts [ :none ] :id_sort This option is deprecated.
-          #   Don't apply a sort on _id if no other sort is defined on the criteria.
+          # @param [ Integer ] limit The number of documents to return.
           #
           # @return [ Document ] The last document found.
-          def last(limit_or_opts = nil)
+          def last(limit = nil)
             _added.values.try(:last) ||
                 _loaded.try(:values).try(:last) ||
-                _added[(ul = _unloaded.try(:last, limit_or_opts)).try(:_id)] ||
+                _added[(ul = _unloaded.try(:last, limit)).try(:_id)] ||
                 ul
           end
 

data/lib/mongoid/association/referenced/has_many/proxy.rb

@@ -71,10 +71,11 @@ module Mongoid
           #
           # @return [ Document ] The new document.
           def build(attributes = {}, type = nil)
-            doc = Factory.build(type || klass, attributes)
+            doc = Factory.execute_build(type || klass, attributes, execute_callbacks: false)
             append(doc)
             doc.apply_post_processed_defaults
             yield(doc) if block_given?
+            doc.run_pending_callbacks
             doc.run_callbacks(:build) { doc }
             doc
           end
@@ -92,13 +93,15 @@ module Mongoid
           #
           # @return [ Document ] The matching document.
           def delete(document)
-            execute_callback :before_remove, document
-            _target.delete(document) do |doc|
-              if doc
-                unbind_one(doc)
-                cascade!(doc) if !_assigning?
+            execute_callbacks_around(:remove, document) do
+              _target.delete(document) do |doc|
+                if doc
+                  unbind_one(doc)
+                  cascade!(doc) if !_assigning?
+                end
+              end.tap do
+                reset_unloaded
               end
-              execute_callback :after_remove, doc
             end
           end
 
@@ -467,111 +470,12 @@ module Mongoid
           # @return [ Integer ] The number of documents deleted.
           def remove_all(conditions = nil, method = :delete_all)
             selector = conditions || {}
-            selector.merge!(criteria.selector)
-
-            # Scanning before the delete means scanning only what is already in
-            # memory, so it is only done where there is a pattern whose cost has
-            # to be bounded. Everywhere else the delete comes first and the scan
-            # sees the survivors, which is what this association has always
-            # done.
-            #
-            # The limit is read once and carried into whichever branch is taken.
-            # Letting the branch below ask again would read it a second time,
-            # across a server round trip, and a limit that had become positive
-            # in the meantime would put a deadline on the delete_if -- a query,
-            # and an unbind of every match -- which is the arrangement this
-            # branch exists to avoid.
-            limit = Matcher::RegexpBudget.limit_for(selector)
-            return remove_all_bounded(selector, method, limit) if limit
-
-            removed = klass.send(method, selector)
-
-            # No scope around this. The scan runs after the delete, so the
-            # association this loads comes back holding only what the delete did
-            # not match, and there is no pattern here to bound in any case.
-            # Opening a scope would save _matches? from deciding once per
-            # document -- 0.48us against 1.74us for the match itself -- but a
-            # scope with nothing to bound suppresses that decision for
-            # everything nested inside it, and loading the association runs
-            # find callbacks. A pattern in a selector one of those evaluates
-            # would go unguarded, which costs more than the saving is worth on a
-            # path that has just made two round trips.
+            removed = klass.send(method, selector.merge!(criteria.selector))
             _target.delete_if do |doc|
               doc._matches?(selector).tap do |b|
                 unbind_one(doc) if b
               end
             end
-
-            removed
-          end
-
-          # Deletes all related documents matching a selector that carries a
-          # regular expression, with the whole scan under one regexp budget.
-          #
-          # The scan runs before anything is deleted, so a budget that runs out
-          # leaves both the database and the association untouched rather than
-          # reporting a failure for a delete that has already happened. It also
-          # means the budget is closed by the time the association is mutated,
-          # so where the budget is enforced with Timeout there is no window for
-          # the exception to land in the middle of an unbind.
-          #
-          # @param [ Hash ] selector The selector to delete with.
-          # @param [ Symbol ] method The deletion method to call.
-          # @param [ Float ] limit The seconds the scan may spend, as read by
-          #   the caller when it chose this path.
-          #
-          # @return [ Integer ] The number of documents deleted.
-          def remove_all_bounded(selector, method, limit)
-            # Only what the association already holds. Iterating it instead
-            # would load the whole association before the delete, and for a
-            # broad pattern that is every document the association has: /.*/ is
-            # both the cheapest pattern an attacker can supply and the one that
-            # matches everything, so bounding the cost of the matching would
-            # have been paid for with an unbounded amount of memory. Nothing is
-            # missed by not loading, because the server evaluates the same
-            # selector for the delete itself.
-            #
-            # It also means the scan runs no query, so no deadline of ours can
-            # land on one. Where the budget is enforced with Timeout, covering
-            # a query would report a slow network as a regexp timeout and could
-            # deliver the asynchronous exception inside the driver's socket
-            # read.
-            documents = _target.in_memory
-
-            matching = Matcher::RegexpBudget.open_with(limit) do
-              documents.select { |doc| doc._matches?(selector) }
-            end
-
-            removed = klass.send(method, selector)
-
-            # The ids are already known to be in memory, so the loaded and added
-            # documents can be dropped directly. Enumerable#delete would look
-            # each one up by id and stop at the first hash that has it, which
-            # removes the wrong instance when both hashes hold one for the same
-            # id. Enumerable#delete_if drops it from both, as this does, but
-            # only after load_all!, which is the load this scan exists to avoid.
-            #
-            # Which documents get unbound has always depended on which ones
-            # happened to be in memory, and scanning only what is in memory
-            # keeps that. It matters for has_and_belongs_to_many, whose
-            # unbind_one pulls the id out of the foreign key array on _base and
-            # marks it dirty; the scan used to run after the delete, against an
-            # association that a cold proxy had just reloaded as holding only
-            # the survivors, so nothing matched and nothing was unbound.
-            #
-            # TODO: unbinding should not depend on what was in memory. Every
-            # matched document leaves the association, so every one of them
-            # should be unbound, which would also stop _base's foreign key
-            # array from keeping ids that no longer resolve. That is a
-            # behaviour change for has_and_belongs_to_many and belongs in a
-            # ticket of its own, with a release note; it should not ride along
-            # on this one.
-            matching.each do |doc|
-              unbind_one(doc)
-              _target._loaded.delete(doc._id)
-              _target._added.delete(doc._id)
-            end
-
             removed
           end
 

data/lib/mongoid/association/referenced/has_one/buildable.rb

@@ -53,7 +53,7 @@ module Mongoid
           end
 
           def execute_query(object, base)
-            query_criteria(object, base).limit(1).first(id_sort: :none)
+            query_criteria(object, base).take
           end
 
           def with_polymorphic_criterion(criteria, base)

data/lib/mongoid/association/referenced/has_one/proxy.rb

@@ -49,17 +49,14 @@ module Mongoid
           #
           # @return [ One ] The association.
           def substitute(replacement)
-            # If the same object currently associated is being assigned,
-            # rebind the association and save the target but do not destroy
-            # the target.
-
-            unbind_one
-            if persistable?
-              # TODO can this entire method be skipped if self == replacement?
-              if _association.destructive? && self != replacement
-                send(_association.dependent)
-              else
-                save if persisted?
+            if self != replacement
+              unbind_one
+              if persistable?
+                if _association.destructive?
+                  send(_association.dependent)
+                else
+                  save if persisted?
+                end
               end
             end
             HasOne::Proxy.new(_base, replacement, _association) if replacement

data/lib/mongoid/association/referenced/syncable.rb

@@ -67,8 +67,8 @@ module Mongoid
         #
         # @return [ Object ] The updated values.
         def update_inverse_keys(association)
-          if changes.has_key?(association.foreign_key)
-            old, new = changes[association.foreign_key]
+          if previous_changes.has_key?(association.foreign_key)
+            old, new = previous_changes[association.foreign_key]
             adds, subs = new - (old || []), (old || []) - new
 
             # If we are autosaving we don't want a duplicate to get added - the

data/lib/mongoid/association/relatable.rb

@@ -242,7 +242,7 @@ module Mongoid
       #
       # @return [ String ] The foreign key check.
       def foreign_key_check
-        @foreign_key_check ||= "#{foreign_key}_changed?" if (stores_foreign_key? && foreign_key)
+        @foreign_key_check ||= "#{foreign_key}_previously_changed?" if (stores_foreign_key? && foreign_key)
       end
 
       # Create an association proxy object using the owner and target.
@@ -299,6 +299,35 @@ module Mongoid
                       end
       end
 
+      # @return [ Array<String> ] The associations above this one in the inclusion tree.
+      attr_accessor :parent_inclusions
+
+      def parent_inclusions
+        @parent_inclusions ||= []
+      end
+
+      # Is this association an embeds_many or has_many association?
+      #
+      # @return [ true | false ] true if it is a *_many association, false if not.
+      def many?
+        [Referenced::HasMany, Embedded::EmbedsMany].any? { |a| self.is_a?(a) }
+      end
+
+      # Is this association an embeds_one or has_one association?
+      #
+      # @return [ true | false ] true if it is a *_one association, false if not.
+      def one?
+        [Referenced::HasOne, Embedded::EmbedsOne].any? { |a| self.is_a?(a) }
+      end
+
+      # Is this association an embedded_in or belongs_to association?
+      #
+      # @return [ true | false ] true if it is an embedded_in or belongs_to
+      #   association, false if not.
+      def in_to?
+        [Referenced::BelongsTo, Embedded::EmbeddedIn].any? { |a| self.is_a?(a) }
+      end
+
       private
 
       # Gets the model classes with inverse associations of this model. This is used to determine
@@ -404,10 +433,15 @@ module Mongoid
       def namespace_hierarchy(mod)
         parent = Object
         hier = [parent]
-        mod.name.split('::').each do |part|
-          parent = parent.const_get(part)
-          hier << parent
+
+        # name is not present on anonymous modules
+        if mod.name
+          mod.name.split('::').each do |part|
+            parent = parent.const_get(part)
+            hier << parent
+          end
         end
+
         hier.reverse
       end
 

data/lib/mongoid/attributes/processing.rb

@@ -43,11 +43,18 @@ module Mongoid
       # @return [ true, false ] True if pending, false if not.
       def pending_attribute?(key, value)
         name = key.to_s
-        if relations.has_key?(name)
+
+        aliased = if aliased_associations.key?(name)
+          aliased_associations[name]
+        else
+          name
+        end
+
+        if relations.has_key?(aliased)
           pending_relations[name] = value
           return true
         end
-        if nested_attributes.has_key?(name)
+        if nested_attributes.has_key?(aliased)
           pending_nested[name] = value
           return true
         end

data/lib/mongoid/attributes.rb

@@ -86,10 +86,26 @@ module Mongoid
     def read_attribute(name)
       field = fields[name.to_s]
       raw = read_raw_attribute(name)
-      field ? field.demongoize(raw) : raw
+      process_raw_attribute(name.to_s, raw, field)
     end
     alias :[] :read_attribute
 
+
+    # Process the raw attribute values just read from the documents attributes.
+    #
+    # @param [ String ] name The name of the attribute to get.
+    # @param [ Object ] raw The raw attribute value.
+    # @param [ Field | nil ] field The field to use for demongoization or nil.
+    #
+    # @return [ Object ] The value of the attribute.
+    #
+    # @api private
+    def process_raw_attribute(name, raw, field)
+      value = field ? field.demongoize(raw) : raw
+      attribute_will_change!(name) if value.resizable?
+      value
+    end
+
     # 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_raw_attribute.
@@ -121,6 +137,7 @@ module Mongoid
     # @raise [ Errors::ReadonlyAttribute ] If the field cannot be removed due
     #   to being flagged as reaodnly.
     def remove_attribute(name)
+      validate_writable_field_name!(name.to_s)
       as_writable_attribute!(name) do |access|
         _assigning do
           attribute_will_change!(access)
@@ -143,6 +160,8 @@ module Mongoid
     # @param [ String, Symbol ] name The name of the attribute to update.
     # @param [ Object ] value The value to set for the attribute.
     def write_attribute(name, value)
+      validate_writable_field_name!(name.to_s)
+
       field_name = database_field_name(name)
 
       if attribute_missing?(field_name)
@@ -151,7 +170,6 @@ module Mongoid
 
       if attribute_writable?(field_name)
         _assigning do
-          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(field_name, value)
@@ -164,6 +182,11 @@ module Mongoid
           else
             attributes[field_name] = typed_value
           end
+
+          # when writing an attribute, also remove it from the unsets,
+          # so that removing then writing doesn't result in a removal.
+          delayed_atomic_unsets.delete(field_name)
+
           typed_value
         end
       else
@@ -266,7 +289,11 @@ module Mongoid
       end
 
       if hash_dot_syntax?(normalized)
-        attributes.__nested__(normalized)
+        if fields.key?(normalized)
+          attributes[normalized]
+        else
+          attributes.__nested__(normalized)
+        end
       else
         attributes[normalized]
       end
@@ -325,30 +352,6 @@ module Mongoid
 
     private
 
-    # 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 ] field_name The name of the field.
-    # @param [ Object ] value The value to be validated.
-    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?(field.type)
-        unless value.is_a?(field.type)
-          raise Mongoid::Errors::InvalidValue.new(field.type, value.class)
-        end
-      end
-    end
-
     def lookup_attribute_presence(name, value)
       if localized_fields.has_key?(name) && value
         value = localized_fields[name].send(:lookup, value)

data/lib/mongoid/cacheable.rb

@@ -15,7 +15,7 @@ module Mongoid
     # plural model name.
     #
     # If new_record?     - will append /new
-    # If not             - will append /id-updated_at.to_formatted_s(cache_timestamp_format)
+    # If not             - will append /id-updated_at.to_s(cache_timestamp_format)
     # Without updated_at - will append /id
     #
     # This is usually called inside a cache() block
@@ -26,7 +26,7 @@ module Mongoid
     # @return [ String ] the string with or without updated_at
     def cache_key
       return "#{model_key}/new" if new_record?
-      return "#{model_key}/#{_id}-#{updated_at.utc.to_formatted_s(cache_timestamp_format)}" if do_or_do_not(:updated_at)
+      return "#{model_key}/#{_id}-#{updated_at.utc.to_s(cache_timestamp_format)}" if do_or_do_not(:updated_at)
       "#{model_key}/#{_id}"
     end
   end

data/lib/mongoid/changeable.rb

@@ -62,13 +62,14 @@ module Mongoid
 
     # Call this method after save, so the changes can be properly switched.
     #
-    # This will unset the memoized children array, set new record to
+    # This will unset the memoized children array, set new record flag to
     # false, set the document as validated, and move the dirty changes.
     #
     # @example Move the changes to previous.
     #   person.move_changes
     def move_changes
       @previous_changes = changes
+      @previous_attributes = attributes.dup
       Atomic::UPDATES.each do |update|
         send(update).clear
       end
@@ -81,6 +82,7 @@ module Mongoid
     #   document.post_persist
     def post_persist
       reset_persisted_descendants
+      reset_attributes_before_type_cast
       move_changes
     end
 
@@ -133,6 +135,13 @@ module Mongoid
 
     private
 
+    # Get attributes of the document before the document was saved.
+    #
+    # @return [ Hash ] Previous attributes
+    def previous_attributes
+      @previous_attributes ||= {}
+    end
+
     # Get the old and new value for the provided attribute.
     #
     # @example Get the attribute change.
@@ -185,6 +194,25 @@ module Mongoid
       attribute_changed?(attr) ? changed_attributes[attr] : attributes[attr]
     end
 
+    # Get the previous attribute value that was changed
+    # before the document was saved.
+    #
+    # It the document has not been saved yet, or was just loaded from database,
+    # this method returns nil for all attributes.
+    #
+    # @param [ String ] attr The attribute name.
+    #
+    # @return [ Object | nil ] Attribute value before the document was saved,
+    #   or nil if the document has not been saved yet.
+    def attribute_previously_was(attr)
+      attr = database_field_name(attr)
+      if previous_changes.key?(attr)
+        previous_changes[attr].first
+      else
+        previous_attributes[attr]
+      end
+    end
+
     # Flag an attribute as going to change.
     #
     # @example Flag the attribute.
@@ -221,6 +249,10 @@ module Mongoid
       end
     end
 
+    def reset_attributes_before_type_cast
+      @attributes_before_type_cast = @attributes.dup
+    end
+
     module ClassMethods
 
       private
@@ -291,7 +323,7 @@ module Mongoid
         end
       end
 
-      # Creates the dirty change previous value accessor.
+      # Creates the dirty change previous value accessors.
       #
       # @example Create the accessor.
       #   Model.create_dirty_previous_value_accessor("name", "alias")
@@ -303,6 +335,9 @@ module Mongoid
           re_define_method("#{meth}_was") do
             attribute_was(name)
           end
+          re_define_method("#{meth}_previously_was") do
+            attribute_previously_was(name)
+          end
         end
       end
 

data/lib/mongoid/clients/factory.rb

@@ -95,10 +95,6 @@ module Mongoid
             [MONGOID_WRAPPING_LIBRARY] + options[:wrapping_libraries]
           else
             [MONGOID_WRAPPING_LIBRARY]
-          end.tap do |wrap|
-            if defined?(::Rails) && ::Rails.respond_to?(:version)
-              wrap << { name: 'Rails', version: ::Rails.version }
-            end
           end
           options[:wrapping_libraries] = wrap_lib
         end

data/lib/mongoid/clients/options.rb

@@ -45,6 +45,10 @@ module Mongoid
             PersistenceContext.new(self.class)
       end
 
+      def persistence_context?
+        !!(PersistenceContext.get(self) || PersistenceContext.get(self.class))
+      end
+
       private
 
       def set_persistence_context(options_or_context)

data/lib/mongoid/clients/sessions.rb

@@ -43,13 +43,7 @@ module Mongoid
         Threaded.set_session(session)
         yield(session)
       rescue Mongo::Error::InvalidSession => ex
-        if
-          # Driver 2.13.0+
-          defined?(Mongo::Error::SessionsNotSupported) &&
-            Mongo::Error::SessionsNotSupported === ex ||
-          # Legacy drivers
-          ex.message == Mongo::Session::SESSIONS_NOT_SUPPORTED
-        then
+        if Mongo::Error::SessionsNotSupported === ex
           raise Mongoid::Errors::InvalidSessionUse.new(:sessions_not_supported)
         end
         raise Mongoid::Errors::InvalidSessionUse.new(:invalid_session_use)
@@ -100,13 +94,7 @@ module Mongoid
           Threaded.set_session(session)
           yield(session)
         rescue Mongo::Error::InvalidSession => ex
-          if
-            # Driver 2.13.0+
-            defined?(Mongo::Error::SessionsNotSupported) &&
-              Mongo::Error::SessionsNotSupported === ex ||
-            # Legacy drivers
-            ex.message == Mongo::Session::SESSIONS_NOT_SUPPORTED
-          then
+          if Mongo::Error::SessionsNotSupported === ex
             raise Mongoid::Errors::InvalidSessionUse.new(:sessions_not_supported)
           end
           raise Mongoid::Errors::InvalidSessionUse.new(:invalid_session_use)