mongoid 8.0.13 → 8.1.0

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,22 +128,35 @@ 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
+    # 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
@@ -152,80 +168,12 @@ module Mongoid
     # See https://jira.mongodb.org/browse/MONGOID-5542
     option :prevent_multiple_calls_of_embedded_callbacks, default: false
 
-    # 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
-    # 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
-
-    # The maximum number of seconds that evaluating a single query in memory
-    # may spend executing regular expressions. Queries against an embedded
-    # association are evaluated in the calling thread, so a pattern built from
-    # user input runs locally and can otherwise consume unbounded CPU. The
-    # limit is cumulative over the whole query, since cost grows with the
-    # number of documents and conditions as well as with the pattern.
-    #
-    # Set to nil to remove the limit. On Ruby 3.2 and later the remaining
-    # budget is compiled into the pattern, so the limit counts only the time
-    # spent matching. Earlier Rubies have no per-Regexp timeout, so the query
-    # is bounded with Timeout instead and the limit is wall clock over the
-    # whole in-memory evaluation.
-    #
-    # See https://jira.mongodb.org/browse/MONGOID-5981 for details.
-    option :in_memory_regexp_time_limit, default: 5.0
-
-    # When false (default), query operators are restricted when building a
-    # selector, so that user-supplied input reaching the query builder cannot
-    # make MongoDB execute arbitrary JavaScript. Two rules are enforced:
-    #
-    # - An operator at the top level of an expression must appear in
-    #   +Criteria::Queryable::Selectable::ALLOWED_QUERY_OPERATORS+.
-    # - +$where+, +$function+, and +$accumulator+ are rejected at any depth,
-    #   including inside +$expr+ and the logical operators.
-    #
-    # This applies to every query method that accepts an expression, including
-    # +where+, +find_by+, +and+, +or+, +nor+, +not+, +any_of+, and +none_of+.
-    # It also governs the string form of +where+, e.g.
-    # +where("this.name == 'admin'")+, which the server evaluates as +$where+.
-    # Applications relying on that form must set this option to true.
-    #
-    # The APIs that request JavaScript explicitly, +Criteria#for_js+ and
-    # +js_query+, are unaffected: there the developer has asked for it.
-    #
-    # Set to true to restore the unrestricted pass-through behavior.
-    #
-    # Note that this option is deliberately not tied to +load_defaults+: an
-    # application that has opted into older defaults still gets the guard, and
-    # must set this option explicitly to turn it off.
-    #
-    # See https://jira.mongodb.org/browse/MONGOID-5939,
-    # https://jira.mongodb.org/browse/MONGOID-5993,
-    # https://jira.mongodb.org/browse/MONGOID-5994 for details.
-    option :allow_unsafe_query_operators, default: false
-
-    # When this flag is true, it will be possible to add a record to a
-    # "has_many" or "has_and_belongs_to_many" association by passing that
-    # record's id in the nested attributes for another parent record, even
-    # when the record does not already belong to that association. For a
-    # "has_many" association this moves the record to the new parent.
-    #
-    # When this flag is false, an id in nested attributes is only resolved
-    # within the association itself, and anything else raises an error.
-    #
-    # The default is `false`. Note that allowing reparenting via nested attributes
-    # is a potential security risk, since it could allow a malicious user to move
-    # records that they do not own to a parent record that they do own.
+    # Returns the Config singleton, for use in the configure DSL.
     #
-    # This option will be removed in Mongoid 10, and the only behavior will be
-    # as if this option were set to false.
-    option :allow_reparenting_via_nested_attributes, default: false
+    # @return [ self ] The Config singleton.
+    def config
+      self
+    end
 
     # Has Mongoid been configured? This is checking that at least a valid
     # client config exists.
@@ -308,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.
@@ -380,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)
@@ -447,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/aggregable/memory.rb

@@ -1,13 +1,10 @@
 # frozen_string_literal: true
 
-require 'mongoid/field_readable'
-
 module Mongoid
   module Contextual
     module Aggregable
       # Contains behavior for aggregating values in memory.
       module Memory
-        include FieldReadable
 
         # Get all the aggregate values for the provided field.
         # Provided for interface consistency with Aggregable::Mongo.
@@ -32,7 +29,7 @@ module Mongoid
         #
         # @return [ Numeric ] The average.
         def avg(field)
-          total = count { |doc| !read_field_value(doc, field).nil? }
+          total = count { |doc| !doc.send(field).nil? }
           return nil unless total > 0
 
           total = total.to_f if total.is_a?(Integer)
@@ -117,7 +114,7 @@ module Mongoid
         def aggregate_by(field, method)
           return nil unless any?
 
-          map { |doc| read_field_value(doc, field) }.compact.public_send(method)
+          map { |doc| doc.public_send(field) }.compact.public_send(method)
         end
       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.