mongoid 8.0.7 → 8.1.0

data/lib/mongoid/attributes/processing.rb

@@ -43,46 +43,22 @@ module Mongoid
       # @return [ true | false ] True if pending, false if not.
       def pending_attribute?(key, value)
         name = key.to_s
+
         aliased = if aliased_associations.key?(name)
           aliased_associations[name]
         else
           name
         end
+
         if relations.has_key?(aliased)
-          set_pending_relation(name, aliased, value)
+          pending_relations[name] = value
           return true
         end
         if nested_attributes.has_key?(aliased)
-          set_pending_nested(name, aliased, value)
-          return true
-        end
-        false
-      end
-
-      # Set value of the pending relation.
-      #
-      # @param [ Symbol ] name The name of the relation.
-      # @param [ Symbol ] aliased The aliased name of the relation.
-      # @param [ Object ] value The value of the relation.
-      def set_pending_relation(name, aliased, value)
-        if stored_as_associations.include?(name)
-          pending_relations[aliased] = value
-        else
-          pending_relations[name] = value
-        end
-      end
-
-      # Set value of the pending nested attribute.
-      #
-      # @param [ Symbol ] name The name of the nested attribute.
-      # @param [ Symbol ] aliased The aliased name of the nested attribute.
-      # @param [ Object ] value The value of the nested attribute.
-      def set_pending_nested(name, aliased, value)
-        if stored_as_associations.include?(name)
-          pending_nested[aliased] = value
-        else
           pending_nested[name] = value
+          return true
         end
+        return false
       end
 
       # Get all the pending associations that need to be set.

data/lib/mongoid/attributes/projector.rb

@@ -6,7 +6,7 @@ module Mongoid
     # This module defines projection helpers.
     #
     # Projection rules are rather non-trivial. See
-    # https://docs.mongodb.com/manual/reference/method/db.collection.find/#find-projection
+    # https://www.mongodb.com/docs/manual/reference/method/db.collection.find/#find-projection
     # for server documentation.
     # 4.4 server (and presumably all older ones) requires that a projection
     # for content fields is either exclusionary or inclusionary, i.e. one

data/lib/mongoid/attributes/readonly.rb

@@ -61,7 +61,7 @@ module Mongoid
         #     attr_readonly :name, :genre
         #   end
         #
-        # @param [ Array<Symbol> ] names The names of the fields.
+        # @param [ Symbol... ] *names The names of the fields.
         def attr_readonly(*names)
           names.each do |name|
             readonly_attributes << database_field_name(name)

data/lib/mongoid/attributes.rb

@@ -177,8 +177,14 @@ module Mongoid
             attribute_will_change!(field_name)
           end
           if localized
-            attributes[field_name] ||= {}
-            attributes[field_name].merge!(typed_value)
+            present = fields[field_name].try(:localize_present?)
+            loc_key, loc_val = typed_value.first
+            if present && loc_val.blank?
+              attributes[field_name]&.delete(loc_key)
+            else
+              attributes[field_name] ||= {}
+              attributes[field_name].merge!(typed_value)
+            end
           else
             attributes[field_name] = typed_value
           end

data/lib/mongoid/changeable.rb

@@ -68,9 +68,13 @@ module Mongoid
     # @example Move the changes to previous.
     #   person.move_changes
     def move_changes
+      @changes_before_last_save = @previous_changes
       @previous_changes = changes
+      @attributes_before_last_save = @previous_attributes
       @previous_attributes = attributes.dup
-      reset_atomic_updates!
+      Atomic::UPDATES.each do |update|
+        send(update).clear
+      end
       changed_attributes.clear
     end
 
@@ -131,6 +135,72 @@ module Mongoid
       mods
     end
 
+    # Returns the original value of an attribute before the last save.
+    #
+    # This method is useful in after callbacks to get the original value of
+    #   an attribute before the save that triggered the callbacks to run.
+    #
+    # @param [ Symbol | String ] attr The name of the attribute.
+    #
+    # @return [ Object ] Value of the attribute before the last save.
+    def attribute_before_last_save(attr)
+      attr = database_field_name(attr)
+      attributes_before_last_save[attr]
+    end
+
+    # Returns the change to an attribute during the last save.
+    #
+    # @param [ Symbol | String ] attr The name of the attribute.
+    #
+    # @return [ Array<Object> | nil ] If the attribute was changed, returns
+    #   an array containing the original value and the saved value, otherwise nil.
+    def saved_change_to_attribute(attr)
+      attr = database_field_name(attr)
+      previous_changes[attr]
+    end
+
+    # Returns whether this attribute changed during the last save.
+    #
+    # This method is useful in after callbacks, to see the change
+    #   in an attribute during the save that triggered the callbacks to run.
+    #
+    # @param [ String ] attr The name of the attribute.
+    # @param **kwargs The optional keyword arguments.
+    #
+    # @option **kwargs [ Object ] :from The object the attribute was changed from.
+    # @option **kwargs [ Object ] :to The object the attribute was changed to.
+    #
+    # @return [ true | false ] Whether the attribute has changed during the last save.
+    def saved_change_to_attribute?(attr, **kwargs)
+      changes = saved_change_to_attribute(attr)
+      return false unless changes.is_a?(Array)
+      if kwargs.key?(:from) && kwargs.key?(:to)
+        changes.first == kwargs[:from] && changes.last == kwargs[:to]
+      elsif kwargs.key?(:from)
+        changes.first == kwargs[:from]
+      elsif kwargs.key?(:to)
+        changes.last == kwargs[:to]
+      else
+        true
+      end
+    end
+
+    # Returns whether this attribute change the next time we save.
+    #
+    # This method is useful in validations and before callbacks to determine
+    #   if the next call to save will change a particular attribute.
+    #
+    # @param [ String ] attr The name of the attribute.
+    # @param **kwargs The optional keyword arguments.
+    #
+    # @option **kwargs [ Object ] :from The object the attribute was changed from.
+    # @option **kwargs [ Object ] :to The object the attribute was changed to.
+    #
+    # @return [ true | false ] Whether the attribute change the next time we save.
+    def will_save_change_to_attribute?(attr, **kwargs)
+      attribute_changed?(attr, **kwargs)
+    end
+
     private
 
     # Get attributes of the document before the document was saved.
@@ -140,6 +210,14 @@ module Mongoid
       @previous_attributes ||= {}
     end
 
+    def changes_before_last_save
+      @changes_before_last_save ||= {}
+    end
+
+    def attributes_before_last_save
+      @attributes_before_last_save ||= {}
+    end
+
     # Get the old and new value for the provided attribute.
     #
     # @example Get the attribute change.
@@ -159,12 +237,24 @@ module Mongoid
     #   model.attribute_changed?("name")
     #
     # @param [ String ] attr The name of the attribute.
+    # @param **kwargs The optional keyword arguments.
+    #
+    # @option **kwargs [ Object ] :from The object the attribute was changed from.
+    # @option **kwargs [ Object ] :to The object the attribute was changed to.
     #
     # @return [ true | false ] Whether the attribute has changed.
-    def attribute_changed?(attr)
+    def attribute_changed?(attr, **kwargs)
       attr = database_field_name(attr)
       return false unless changed_attributes.key?(attr)
-      changed_attributes[attr] != attributes[attr]
+      return false if changed_attributes[attr] == attributes[attr]
+      if kwargs.key?(:from)
+        return false if changed_attributes[attr] != kwargs[:from]
+      end
+      if kwargs.key?(:to)
+        return false if attributes[attr] != kwargs[:to]
+      end
+
+      true
     end
 
     # Get whether or not the field has a different value from the default.
@@ -300,8 +390,11 @@ module Mongoid
       # @param [ String ] meth The name of the accessor.
       def create_dirty_change_check(name, meth)
         generated_methods.module_eval do
-          re_define_method("#{meth}_changed?") do
-            attribute_changed?(name)
+          re_define_method("#{meth}_changed?") do |**kwargs|
+            attribute_changed?(name, **kwargs)
+          end
+          re_define_method("will_save_change_to_#{meth}?") do |**kwargs|
+            will_save_change_to_attribute?(name, **kwargs)
           end
         end
       end
@@ -336,6 +429,15 @@ module Mongoid
           re_define_method("#{meth}_previously_was") do
             attribute_previously_was(name)
           end
+          re_define_method("#{meth}_before_last_save") do
+            attribute_before_last_save(name)
+          end
+          re_define_method("saved_change_to_#{meth}") do
+            saved_change_to_attribute(name)
+          end
+          re_define_method("saved_change_to_#{meth}?") do |**kwargs|
+            saved_change_to_attribute?(name, **kwargs)
+          end
         end
       end
 

data/lib/mongoid/clients/storage_options.rb

@@ -6,10 +6,7 @@ module Mongoid
       extend ActiveSupport::Concern
 
       included do
-
-        cattr_accessor :storage_options, instance_writer: false do
-          storage_options_defaults
-        end
+        class_attribute :storage_options, instance_writer: false, default: storage_options_defaults
       end
 
       module ClassMethods
@@ -49,7 +46,7 @@ module Mongoid
         # @return [ Class ] The model class.
         def store_in(options)
           Validators::Storage.validate(self, options)
-          storage_options.merge!(options)
+          self.storage_options = self.storage_options.merge(options)
         end
 
         # Reset the store_in options

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

@@ -9,7 +9,7 @@ module Mongoid
         extend self
 
         # The valid options for storage.
-        VALID_OPTIONS = [ :collection, :database, :client ].freeze
+        VALID_OPTIONS = [ :collection, :collection_options, :database, :client ].freeze
 
         # Validate the options provided to :store_in.
         #
@@ -20,21 +20,9 @@ module Mongoid
         # @param [ Hash | String | Symbol ] options The provided options.
         def validate(klass, options)
           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.
-        def valid_parent?(klass)
-          !klass.superclass.include?(Mongoid::Document)
-        end
 
         # Determine if all keys in the options hash are valid.
         #

data/lib/mongoid/collection_configurable.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Mongoid
+
+  # Encapsulates behavior around defining collections.
+  module CollectionConfigurable
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      # Create the collection for the called upon Mongoid model.
+      #
+      # This method does not re-create existing collections.
+      #
+      # If the document includes `store_in` macro with `collection_options` key,
+      #   these options are used when creating the collection.
+      #
+      # @param [ true | false ] force If true, the method will drop existing
+      #   collections before creating new ones. If false, the method will create
+      #   only new collection (that do not exist in the database).
+      #
+      # @raise [ Errors::CreateCollectionFailure ] If collection creation failed.
+      # @raise [ Errors::DropCollectionFailure ] If an attempt to drop collection failed.
+      def create_collection(force: false)
+        if collection_name.empty?
+          # This is most probably an anonymous class, we ignore them.
+          return
+        end
+        if collection_name.match(/^system\./)
+          # We do not do anything with system collections.
+          return
+        end
+        if force
+          collection.drop
+        end
+        if coll_options = collection.database.list_collections(filter: { name: collection_name.to_s }).first
+          if force
+            raise Errors::DropCollectionFailure.new(collection_name)
+          else
+            logger.debug(
+              "MONGOID: Collection '#{collection_name}' already exists " +
+              "in database '#{database_name}' with options '#{coll_options}'."
+            )
+          end
+        else
+          begin
+            collection.database[collection_name, storage_options.fetch(:collection_options, {})].create
+          rescue Mongo::Error::OperationFailure => e
+            raise Errors::CreateCollectionFailure.new(
+              collection_name,
+              storage_options[:collection_options],
+              e
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/composable.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "mongoid/changeable"
+require "mongoid/collection_configurable"
 require "mongoid/findable"
 require "mongoid/indexable"
 require "mongoid/inspectable"
@@ -36,6 +37,7 @@ module Mongoid
     include Atomic
     include Changeable
     include Clients
+    include CollectionConfigurable
     include Attributes
     include Evolvable
     include Fields

data/lib/mongoid/config/defaults.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Config
+
+    # Encapsulates logic for loading defaults.
+    module Defaults
+
+      # Load the defaults for the feature flags in the given Mongoid version.
+      # Note that this method will load the *new* functionality introduced in
+      # the given Mongoid version.
+      #
+      # @param [ String | Float ] The version number as X.y.
+      #
+      # raises [ ArgumentError ] if an invalid version is given.
+      def load_defaults(version)
+        # Note that for 7.x, since all of the feature flag defaults have been
+        # flipped to the new functionality, all of the settings for those
+        # versions are to give old functionality. Because of this, it is
+        # possible to recurse to later version to get all of the options to
+        # turn off. Note that this won't be true when adding feature flags to
+        # 9.x, since the default will be the old functionality until the next
+        # major version is released. More likely, the recursion will have to go
+        # in the other direction (towards earlier versions).
+
+        case version.to_s
+        when "7.3"
+          # flags introduced in 7.4 - old functionality
+          self.broken_aggregables = true
+          self.broken_alias_handling = true
+          self.broken_and = true
+          self.broken_scoping = true
+          self.broken_updates = true
+          self.compare_time_by_ms = false
+          self.legacy_pluck_distinct = true
+          self.legacy_triple_equals = true
+          self.object_id_as_json_oid = true
+
+          load_defaults "7.4"
+        when "7.4"
+          # flags introduced in 7.5 - old functionality
+          self.legacy_attributes = true
+          self.overwrite_chained_operators = true
+
+          load_defaults "7.5"
+        when "7.5"
+          # flags introduced in 8.0 - old functionality
+          self.map_big_decimal_to_decimal128 = false
+        when "8.0"
+          # All flag defaults currently reflect 8.0 behavior.
+        when "8.1"
+          # flags introduced in 8.1 - new functionality
+          self.legacy_readonly = false
+        else
+          raise ArgumentError, "Unknown version: #{version}"
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/config/options.rb

@@ -25,8 +25,6 @@ module Mongoid
       # @param [ Hash ] options Extras for the option.
       #
       # @option options [ Object ] :default The default value.
-      # @option options [ Proc | nil ] :on_change The callback to invoke when the
-      #   setter is invoked.
       def option(name, options = {})
         defaults[name] = settings[name] = options[:default]
 
@@ -40,7 +38,6 @@ module Mongoid
 
           define_method("#{name}=") do |value|
             settings[name] = value
-            options[:on_change]&.call(value)
           end
 
           define_method("#{name}?") do

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Config
+    module Validators
+
+      # Validator for async query executor configuration.
+      #
+      # @api private
+      module AsyncQueryExecutor
+        extend self
+
+
+        def validate(options)
+          if options.key?(:async_query_executor)
+            if options[:async_query_executor].to_sym == :immediate && !options[:global_executor_concurrency].nil?
+              raise Errors::InvalidGlobalExecutorConcurrency
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/config/validators.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
 
+require "mongoid/config/validators/async_query_executor"
 require "mongoid/config/validators/option"
 require "mongoid/config/validators/client"

data/lib/mongoid/config.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "mongoid/config/defaults"
 require "mongoid/config/environment"
 require "mongoid/config/options"
 require "mongoid/config/validators"
@@ -11,6 +12,7 @@ module Mongoid
   module Config
     extend Forwardable
     extend Options
+    extend Defaults
     extend self
 
     def_delegators ::Mongoid, :logger, :logger=
@@ -70,6 +72,7 @@ module Mongoid
 
     # Use ActiveSupport's time zone in time operations instead of the
     # Ruby default time zone.
+    # @deprecated
     option :use_activesupport_time_zone, default: true
 
     # Return stored times as UTC.
@@ -125,35 +128,52 @@ module Mongoid
     # always return a Hash.
     option :legacy_attributes, default: false
 
-    # Allow BSON::Decimal128 to be parsed and returned directly in
-    # field values. When BSON 5 is present and the this option is set to false
-    # (the default), BSON::Decimal128 values in the database will be returned
-    # as BigDecimal.
-    #
-    # @note this option only has effect when BSON 5+ is present. Otherwise,
-    #   the setting is ignored.
-    option :allow_bson5_decimal128, default: false, on_change: -> (allow) do
-      if BSON::VERSION >= '5.0.0'
-        if allow
-          BSON::Registry.register(BSON::Decimal128::BSON_TYPE, BSON::Decimal128)
-        else
-          BSON::Registry.register(BSON::Decimal128::BSON_TYPE, BigDecimal)
-        end
-      end
-    end
-
-    # When this flag is true, callbacks for embedded documents will not be
-    # called. This is the default in 8.x, but will be changed to false in 9.0.
-    #
-    # Setting this flag to true (as it is in 8.x) may lead to stack
-    # overflow errors if there are more than cicrca 1000 embedded
+    # Sets the async_query_executor for the application. By default the thread pool executor
+    #   is set to `:immediate. Options are:
+    #
+    #   - :immediate - Initializes a single +Concurrent::ImmediateExecutor+
+    #   - :global_thread_pool - Initializes a single +Concurrent::ThreadPoolExecutor+
+    #      that uses the +async_query_concurrency+ for the +max_threads+ value.
+    option :async_query_executor, default: :immediate
+
+    # Defines how many asynchronous queries can be executed concurrently.
+    # This option should be set only if `async_query_executor` is set
+    # to `:global_thread_pool`.
+    option :global_executor_concurrency, default: nil
+
+    # When this flag is false, a document will become read-only only once the
+    # #readonly! method is called, and an error will be raised on attempting
+    # to save or update such documents, instead of just on delete. When this
+    # flag is true, a document is only read-only if it has been projected
+    # using #only or #without, and read-only documents will not be
+    # deletable/destroyable, but they will be savable/updatable.
+    # When this feature flag is turned on, the read-only state will be reset on
+    # reload, but when it is turned off, it won't be.
+    option :legacy_readonly, default: true
+
+    # When this flag is true, any attempt to change the _id of a persisted
+    # document will raise an exception (`Errors::ImmutableAttribute`).
+    # This will be the default in 9.0. When this flag is false (the default
+    # in 8.x), changing the _id of a persisted document might be ignored,
+    # or it might work, depending on the situation.
+    option :immutable_ids, default: false
+
+    # When this flag is true, callbacks for every embedded document will be
+    # called only once, even if the embedded document is embedded in multiple
     # documents in the root document's dependencies graph.
-    #
-    # It is strongly recommended to set this flag to false in 8.x, if you
-    # are not using around callbacks for embedded documents.
-    #
-    # See https://jira.mongodb.org/browse/MONGOID-5658 for more details.
-    option :around_callbacks_for_embeds, default: true
+    # This will be the default in 9.0. Setting this flag to false restores the
+    # pre-9.0 behavior, where callbacks are called for every occurrence of an
+    # embedded document. The pre-9.0 behavior leads to a problem that for multi
+    # level nested documents callbacks are called multiple times.
+    # See https://jira.mongodb.org/browse/MONGOID-5542
+    option :prevent_multiple_calls_of_embedded_callbacks, default: false
+
+    # Returns the Config singleton, for use in the configure DSL.
+    #
+    # @return [ self ] The Config singleton.
+    def config
+      self
+    end
 
     # Has Mongoid been configured? This is checking that at least a valid
     # client config exists.
@@ -236,6 +256,17 @@ module Mongoid
       end
     end
 
+    # Deregister a model in the application with Mongoid.
+    #
+    # @param [ Class ] klass The model to deregister.
+    #
+    # @api private
+    def deregister_model(klass)
+      LOCK.synchronize do
+        models.delete(klass)
+      end
+    end
+
     # From a hash of settings, load all the configuration.
     #
     # @example Load the configuration.
@@ -308,6 +339,7 @@ module Mongoid
     # @param [ Hash ] options The configuration options.
     def options=(options)
       if options
+        Validators::AsyncQueryExecutor.validate(options)
         options.each_pair do |option, value|
           Validators::Option.validate(option)
           send("#{option}=", value)
@@ -375,5 +407,44 @@ module Mongoid
         client
       end
     end
+
+    module DeprecatedOptions
+      OPTIONS = %i[ use_activesupport_time_zone
+                    broken_aggregables
+                    broken_alias_handling
+                    broken_and
+                    broken_scoping
+                    broken_updates
+                    compare_time_by_ms
+                    legacy_attributes
+                    legacy_pluck_distinct
+                    legacy_triple_equals
+                    object_id_as_json_oid
+                    overwrite_chained_operators ]
+
+      if RUBY_VERSION < '3.0'
+        def self.prepended(klass)
+          klass.class_eval do
+            OPTIONS.each do |option|
+              alias_method :"#{option}_without_deprecation=", :"#{option}="
+
+              define_method(:"#{option}=") do |value|
+                Mongoid::Warnings.send(:"warn_#{option}_deprecated")
+                send(:"#{option}_without_deprecation=", value)
+              end
+            end
+          end
+        end
+      else
+        OPTIONS.each do |option|
+          define_method(:"#{option}=") do |value|
+            Mongoid::Warnings.send(:"warn_#{option}_deprecated")
+            super(value)
+          end
+        end
+      end
+    end
+
+    prepend DeprecatedOptions
   end
 end

data/lib/mongoid/contextual/atomic.rb

@@ -150,7 +150,7 @@ module Mongoid
       # @example Unset the field on the matches.
       #   context.unset(:name)
       #
-      # @param [ String | Symbol | Array<String | Symbol> | Hash ] args
+      # @param [ [ String | Symbol | Array<String | Symbol> | Hash ]... ] *args
       #   The name(s) of the field(s) to unset.
       #   If a Hash is specified, its keys will be used irrespective of what
       #   each key's value is, even if the value is nil or false.