mongoid 8.0.13 → 8.1.0

data/lib/mongoid/findable.rb

@@ -22,18 +22,24 @@ module Mongoid
       :each,
       :each_with_index,
       :extras,
+      :fifth,
+      :fifth!,
       :find_one_and_delete,
       :find_one_and_replace,
       :find_one_and_update,
       :find_or_create_by,
       :find_or_create_by!,
       :find_or_initialize_by,
+      :first!,
       :first_or_create,
       :first_or_create!,
       :first_or_initialize,
       :for_js,
+      :fourth,
+      :fourth!,
       :geo_near,
       :includes,
+      :last!,
       :map_reduce,
       :max,
       :min,
@@ -41,11 +47,19 @@ module Mongoid
       :pick,
       :pluck,
       :read,
+      :second,
+      :second!,
+      :second_to_last,
+      :second_to_last!,
       :sum,
       :take,
       :take!,
       :tally,
       :text_search,
+      :third,
+      :third!,
+      :third_to_last,
+      :third_to_last!,
       :update,
       :update_all,
 
@@ -87,9 +101,19 @@ module Mongoid
     # @example Do any documents exist for the conditions?
     #   Person.exists?
     #
+    # @example Do any documents exist for given _id.
+    #   Person.exists?(BSON::ObjectId(...))
+    #
+    # @example Do any documents exist for given conditions.
+    #   Person.exists?(name: "...")
+    #
+    # @param [ Hash | Object | false ] id_or_conditions an _id to
+    #   search for, a hash of conditions, nil or false.
+    #
     # @return [ true | false ] If any documents exist for the conditions.
-    def exists?
-      with_default_scope.exists?
+    #   Always false if passed nil or false.
+    def exists?(id_or_conditions = :none)
+      with_default_scope.exists?(id_or_conditions)
     end
 
     # Finds a +Document+ or multiple documents by their _id values.
@@ -135,7 +159,7 @@ module Mongoid
     # @note Each argument can be an individual id, an array of ids or
     #   a nested array. Each array will be flattened.
     #
-    # @param [ Object | Array<Object> ] *args The _id value(s) to find.
+    # @param [ [ Object | Array<Object> ]... ] *args The id(s) to find.
     #
     # @return [ Document | Array<Document> | nil ] A document or matching documents.
     #

data/lib/mongoid/interceptable.rb

@@ -140,32 +140,6 @@ module Mongoid
     #
     # @api private
     def _mongoid_run_child_callbacks(kind, children: nil, &block)
-      if Mongoid::Config.around_callbacks_for_embeds
-        _mongoid_run_child_callbacks_with_around(kind,
-                                                 children: children,
-                                                 &block)
-      else
-        _mongoid_run_child_callbacks_without_around(kind,
-                                                    children: children,
-                                                    &block)
-      end
-    end
-
-    # Execute the callbacks of given kind for embedded documents including
-    # around callbacks.
-    #
-    # @note This method is prone to stack overflow errors if the document
-    #   has a large number of embedded documents. It is recommended to avoid
-    #   using around callbacks for embedded documents until a proper solution
-    #   is implemented.
-    #
-    # @param [ Symbol ] kind The type of callback to execute.
-    # @param [ Array<Document> ] children Children to execute callbacks on. If
-    #  nil, callbacks will be executed on all cascadable children of
-    #  the document.
-    #
-    #  @api private
-    def _mongoid_run_child_callbacks_with_around(kind, children: nil, &block)
       child, *tail = (children || cascadable_children(kind))
       with_children = !Mongoid::Config.prevent_multiple_calls_of_embedded_callbacks
       if child.nil?
@@ -179,83 +153,18 @@ module Mongoid
       end
     end
 
-    # Execute the callbacks of given kind for embedded documents without
-    # around callbacks.
-    #
-    # @param [ Symbol ] kind The type of callback to execute.
-    # @param [ Array<Document> ] children Children to execute callbacks on. If
-    #   nil, callbacks will be executed on all cascadable children of
-    #   the document.
-    #
-    # @api private
-    def _mongoid_run_child_callbacks_without_around(kind, children: nil, &block)
-      children = (children || cascadable_children(kind))
-      callback_list = _mongoid_run_child_before_callbacks(kind, children: children)
-      return false if callback_list == false
-      value = block&.call
-      callback_list.each do |_next_sequence, env|
-        env.value &&= value
-      end
-      return false if _mongoid_run_child_after_callbacks(callback_list: callback_list) == false
-
-      value
-    end
-
-    # Execute the before callbacks of given kind for embedded documents.
-    #
-    # @param [ Symbol ] kind The type of callback to execute.
-    # @param [ Array<Document> ] children Children to execute callbacks on.
-    # @param [ Array<ActiveSupport::Callbacks::CallbackSequence, ActiveSupport::Callbacks::Filters::Environment> ] callback_list List of
-    #   pairs of callback sequence and environment. This list will be later used
-    #   to execute after callbacks in reverse order.
-    #
-    # @api private
-    def _mongoid_run_child_before_callbacks(kind, children: [], callback_list: [])
-      children.each do |child|
-        chain = child.__callbacks[child_callback_type(kind, child)]
-        env = ActiveSupport::Callbacks::Filters::Environment.new(child, false, nil)
-        next_sequence = compile_callbacks(chain)
-        unless next_sequence.final?
-          Mongoid.logger.warn("Around callbacks are disabled for embedded documents. Skipping around callbacks for #{child.class.name}.")
-          Mongoid.logger.warn("To enable around callbacks for embedded documents, set Mongoid::Config.around_callbacks_for_embeds to true.")
-        end
-        next_sequence.invoke_before(env)
-        return false if env.halted
-        env.value = !env.halted
-        callback_list << [next_sequence, env]
-      end
-      callback_list
-    end
-
-    # Execute the after callbacks.
-    #
-    # @param [ Array<ActiveSupport::Callbacks::CallbackSequence, ActiveSupport::Callbacks::Filters::Environment> ] callback_list List of
-    #   pairs of callback sequence and environment.
-    def _mongoid_run_child_after_callbacks(callback_list: [])
-      callback_list.reverse_each do |next_sequence, env|
-        next_sequence.invoke_after(env)
-        return false if env.halted
-      end
-    end
-
-    # Returns the stored callbacks to be executed later.
+    # This is used to store callbacks to be executed later. A good use case for
+    # this is delaying the after_find and after_initialize callbacks until the
+    # associations are set on the document. This can also be used to delay
+    # applying the defaults on a document.
     #
-    # @return [ Array<Symbol> ] Method symbols of the stored pending callbacks.
+    # @return [ Array<Symbol> ] an array of symbols that represent the pending callbacks.
     #
     # @api private
     def pending_callbacks
       @pending_callbacks ||= [].to_set
     end
 
-    # Stores callbacks to be executed later. A good use case for
-    # this is delaying the after_find and after_initialize callbacks until the
-    # associations are set on the document. This can also be used to delay
-    # applying the defaults on a document.
-    #
-    # @param [ Array<Symbol> ] value Method symbols of the pending callbacks to store.
-    #
-    # @return [ Array<Symbol> ] Method symbols of the stored pending callbacks.
-    #
     # @api private
     def pending_callbacks=(value)
       @pending_callbacks = value
@@ -390,7 +299,7 @@ module Mongoid
         end
         self.class.send :define_method, name do
           env = ActiveSupport::Callbacks::Filters::Environment.new(self, false, nil)
-          sequence = compile_callbacks(chain)
+          sequence = chain.compile
           sequence.invoke_before(env)
           env.value = !env.halted
           sequence.invoke_after(env)
@@ -400,24 +309,5 @@ module Mongoid
       end
       send(name)
     end
-
-    # Compile the callback chain.
-    #
-    # This method hides the differences between ActiveSupport implementations
-    # before and after 7.1.
-    #
-    # @param [ ActiveSupport::Callbacks::CallbackChain ] chain The callback chain.
-    # @param [ Symbol | nil ] type The type of callback chain to compile.
-    #
-    # @return [ ActiveSupport::Callbacks::CallbackSequence ] The compiled callback sequence.
-    def compile_callbacks(chain, type = nil)
-      if chain.method(:compile).arity == 0
-        # ActiveSupport < 7.1
-        chain.compile
-      else
-        # ActiveSupport >= 7.1
-        chain.compile(type)
-      end
-    end
   end
 end

data/lib/mongoid/matchable.rb

@@ -17,12 +17,7 @@ module Mongoid
     #
     # @return [ true | false ] True if matches, false if not.
     def _matches?(selector)
-      # Opens a regexp budget for this document only. Callers that match many
-      # documents against one selector open a budget of their own first, and
-      # this one joins it rather than giving every document a fresh limit.
-      Matcher::RegexpBudget.open(selector) do
-        Matcher::Expression.matches?(self, selector)
-      end
+      Matcher::Expression.matches?(self, selector)
     end
   end
 end

data/lib/mongoid/matcher/eq_impl.rb

@@ -46,7 +46,7 @@ module Mongoid
         end
       end
 
-      # Per https://docs.mongodb.com/ruby-driver/current/tutorials/bson-v4/#time-instances,
+      # Per https://www.mongodb.com/docs/ruby-driver/current/tutorials/bson-v4/#time-instances,
       # > Times in BSON (and MongoDB) can only have millisecond precision. When Ruby Time instances
       # are serialized to BSON or Extended JSON, the times are floored to the nearest millisecond.
       #

data/lib/mongoid/matcher/eq_impl_with_regexp.rb

@@ -6,10 +6,12 @@ module Mongoid
     #
     # @api private
     module EqImplWithRegexp
-      module_function def matches?(_original_operator, value, condition)
+      module_function def matches?(original_operator, value, condition)
         case condition
-        when Regexp, ::BSON::Regexp::Raw
-          value.respond_to?(:=~) && RegexpBudget.match?(value, condition)
+        when Regexp
+          value =~ condition
+        when ::BSON::Regexp::Raw
+          value =~ condition.compile
         else
           if Mongoid.compare_time_by_ms &&
             value.kind_of?(Time) && condition.kind_of?(Time)

data/lib/mongoid/matcher/regex.rb

@@ -3,24 +3,25 @@ module Mongoid
 
     # @api private
     module Regex
-      module_function def matches?(_exists, value, condition)
-        unless condition.is_a?(Regexp) || condition.is_a?(BSON::Regexp::Raw)
+      module_function def matches?(exists, value, condition)
+        condition = case condition
+        when Regexp
+          condition
+        when BSON::Regexp::Raw
+          condition.compile
+        else
           # Note that strings must have been converted to a regular expression
           # instance already (with $options taken into account, if provided).
           raise Errors::InvalidQuery, "$regex requires a regular expression argument: #{Errors::InvalidQuery.truncate_expr(condition)}"
         end
 
-        # The condition is compiled by RegexpBudget rather than here, so that
-        # the budget's timeout can be baked into the pattern.
         case value
         when Array
-          # Object#=~ is gone as of Ruby 3.2, so an element that cannot be
-          # matched against has to be rejected rather than passed to =~.
           value.any? do |v|
-            v.respond_to?(:=~) && RegexpBudget.match?(v, condition)
+            v =~ condition
           end
         when String
-          RegexpBudget.match?(value, condition)
+          value =~ condition
         else
           false
         end

data/lib/mongoid/matcher/type.rb

@@ -1,7 +1,7 @@
 module Mongoid
   module Matcher
 
-    # @see https://docs.mongodb.com/manual/reference/operator/query/type/
+    # @see https://www.mongodb.com/docs/manual/reference/operator/query/type/
     #
     # @api private
     module Type

data/lib/mongoid/matcher.rb

@@ -124,7 +124,6 @@ require 'mongoid/matcher/nor'
 require 'mongoid/matcher/not'
 require 'mongoid/matcher/or'
 require 'mongoid/matcher/regex'
-require 'mongoid/matcher/regexp_budget'
 require 'mongoid/matcher/size'
 require 'mongoid/matcher/type'
 require 'mongoid/matcher/expression_operator'

data/lib/mongoid/persistable/creatable.rb

@@ -100,6 +100,7 @@ module Mongoid
       #
       # @return [ Document ] The document.
       def prepare_insert(options = {})
+        raise Errors::ReadonlyDocument.new(self.class) if readonly? && !Mongoid.legacy_readonly
         return self if performing_validations?(options) &&
           invalid?(options[:context] || :create)
         run_callbacks(:save, with_children: false) do

data/lib/mongoid/persistable/deletable.rb

@@ -16,7 +16,6 @@ module Mongoid
       #
       # @return [ TrueClass ] True.
       def delete(options = {})
-        raise Errors::ReadonlyDocument.new(self.class) if readonly?
         prepare_delete do
           unless options[:persist] == false
             if embedded?
@@ -102,6 +101,7 @@ module Mongoid
       #
       # @return [ Object ] The result of the block.
       def prepare_delete
+        raise Errors::ReadonlyDocument.new(self.class) if readonly?
         yield(self)
         freeze
         self.destroyed = true

data/lib/mongoid/persistable/savable.rb

@@ -14,7 +14,13 @@ module Mongoid
       #
       # @param [ Hash ] options Options to pass to the save.
       #
-      # @return [ true | false ] True is success, false if not.
+      # @option options [ true | false ] :touch Whether or not the updated_at
+      #   attribute will be updated with the current time. When this option is
+      #   false, none of the embedded documents will be touched. This option is
+      #   ignored when saving a new document, and the created_at and updated_at
+      #   will be set to the current time.
+      #
+      # @return [ true | false ] True if success, false if not.
       def save(options = {})
         if new_record?
           !insert(options).new_record?
@@ -31,6 +37,12 @@ module Mongoid
       #
       # @param [ Hash ] options Options to pass to the save.
       #
+      # @option options [ true | false ] :touch Whether or not the updated_at
+      #   attribute will be updated with the current time. When this option is
+      #   false, none of the embedded documents will be touched.This option is
+      #   ignored when saving a new document, and the created_at and updated_at
+      #   will be set to the current time.
+      #
       # @raise [ Errors::Validations ] If validation failed.
       # @raise [ Errors::Callback ] If a callback returns false.
       #

data/lib/mongoid/persistable/unsettable.rb

@@ -13,8 +13,8 @@ module Mongoid
       # @example Unset the values.
       #   document.unset(:first_name, :last_name, :middle)
       #
-      # @param [ Array<String | Symbol> ] fields The names of the fields to
-      #   unset.
+      # @param [ [ String | Symbol | Array<String | Symbol>]... ] *fields
+      #   The names of the field(s) to unset.
       #
       # @return [ Document ] The document.
       def unset(*fields)

data/lib/mongoid/persistable/updatable.rb

@@ -91,16 +91,23 @@ module Mongoid
       #
       # @param [ Hash ] options The options.
       #
+      # @option options [ true | false ] :touch Whether or not the updated_at
+      #   attribute will be updated with the current time.
+      #
       # @return [ true | false ] The result of the update.
       def prepare_update(options = {})
+        raise Errors::ReadonlyDocument.new(self.class) if readonly? && !Mongoid.legacy_readonly
+        enforce_immutability_of_id_field!
         return false if performing_validations?(options) &&
           invalid?(options[:context] || :update)
         process_flagged_destroys
+        update_children = cascadable_children(:update)
+        process_touch_option(options, update_children)
         run_callbacks(:save, with_children: false) do
           run_callbacks(:update, with_children: false) do
             run_callbacks(:persist_parent, with_children: false) do
               _mongoid_run_child_callbacks(:save) do
-                _mongoid_run_child_callbacks(:update) do
+                _mongoid_run_child_callbacks(:update, children: update_children) do
                   result = yield(self)
                   self.previously_new_record = false
                   post_process_persist(result, options)
@@ -160,6 +167,49 @@ module Mongoid
           end
         end
       end
+
+      # If there is a touch option and it is false, this method will call the
+      # timeless method so that the updated_at attribute is not updated. It
+      # will call the timeless method on all of the cascadable children as
+      # well. Note that timeless is cleared in the before_update callback.
+      #
+      # @param [ Hash ] options The options.
+      # @param [ Array<Document> ] children The children that the :update
+      #   callbacks will be executed on.
+      #
+      # @option options [ true | false ] :touch Whether or not the updated_at
+      #   attribute will be updated with the current time.
+      def process_touch_option(options, children)
+        unless options.fetch(:touch, true)
+          timeless
+          children.each(&:timeless)
+        end
+      end
+
+      # Checks to see if the _id field has been modified. If it has, and if
+      # the document has already been persisted, this is an error. Otherwise,
+      # returns without side-effects.
+      #
+      # Note that if `Mongoid::Config.immutable_ids` is false, this will do
+      # nothing.
+      #
+      # @raise [ Errors::ImmutableAttribute ] if _id has changed, and document
+      #   has been persisted.
+      def enforce_immutability_of_id_field!
+        # special case here: we *do* allow the _id to be mutated if it was
+        # previously nil. This addresses an odd case exposed in
+        # has_one/proxy_spec.rb where `person.create_address` would
+        # (somehow?) create the address with a nil _id first, before then
+        # saving it *again* with the correct _id.
+
+        if _id_changed? && !_id_was.nil? && persisted?
+          if Mongoid::Config.immutable_ids
+            raise Errors::ImmutableAttribute.new(:_id, _id)
+          else
+            Mongoid::Warnings.warn_mutable_ids
+          end
+        end
+      end
     end
   end
 end

data/lib/mongoid/persistable/upsertable.rb

@@ -10,16 +10,32 @@ module Mongoid
       # database, then Mongo will insert a new one, otherwise the fields will get
       # overwritten with new values on the existing document.
       #
+      # If the replace option is true, unspecified attributes will be dropped,
+      # and if it is false, unspecified attributes will be maintained. The
+      # replace option defaults to true in Mongoid 8.1 and earlier. The default
+      # will be flipped to false in Mongoid 9.
+      #
       # @example Upsert the document.
       #   document.upsert
       #
+      # @example Upsert the document without replace.
+      #   document.upsert(replace: false)
+      #
       # @param [ Hash ] options The validation options.
       #
+      # @option options [ true | false ] :validate Whether or not to validate.
+      # @option options [ true | false ] :replace Whether or not to replace the document on upsert.
+      #
       # @return [ true ] True.
       def upsert(options = {})
         prepare_upsert(options) do
-          collection.find(atomic_selector).replace_one(
+          if options.fetch(:replace, true)
+            collection.find(atomic_selector).replace_one(
               as_attributes, upsert: true, session: _session)
+          else
+            collection.find(atomic_selector).update_one(
+              { "$set" => as_attributes }, upsert: true, session: _session)
+          end
         end
       end
 
@@ -36,8 +52,11 @@ module Mongoid
       #
       # @param [ Hash ] options The options hash.
       #
+      # @option options [ true | false ] :validate Whether or not to validate.
+      #
       # @return [ true | false ] If the operation succeeded.
       def prepare_upsert(options = {})
+        raise Errors::ReadonlyDocument.new(self.class) if readonly? && !Mongoid.legacy_readonly
         return false if performing_validations?(options) && invalid?(:upsert)
         result = run_callbacks(:upsert) do
           yield(self)

data/lib/mongoid/persistable.rb

@@ -161,6 +161,8 @@ module Mongoid
     # @param [ Object ] result The result of the operation.
     # @param [ Hash ] options The options.
     #
+    # @option options [ true | false ] :validate Whether or not to validate.
+    #
     # @return [ true ] true.
     def post_process_persist(result, options = {})
       post_persist unless result == false
@@ -180,6 +182,7 @@ module Mongoid
     #
     # @return [ Object ] The result of the operation.
     def prepare_atomic_operation
+      raise Errors::ReadonlyDocument.new(self.class) if readonly? && !Mongoid.legacy_readonly
       operations = yield({})
       persist_or_delay_atomic_operation(operations)
       self

data/lib/mongoid/query_cache.rb

@@ -14,6 +14,7 @@ module Mongoid
       #
       # @return [ nil ] Always nil.
       def clear_cache
+        Mongoid::Warnings.warn_mongoid_query_cache_clear
         Mongo::QueryCache.clear
       end
 
@@ -24,6 +25,7 @@ module Mongoid
       #
       # @param [ true | false ] value The enabled value.
       def enabled=(value)
+        Mongoid::Warnings.warn_mongoid_query_cache
         Mongo::QueryCache.enabled = value
       end
 
@@ -34,6 +36,7 @@ module Mongoid
       #
       # @return [ true | false ] If the cache is enabled.
       def enabled?
+        Mongoid::Warnings.warn_mongoid_query_cache
         Mongo::QueryCache.enabled?
       end
 
@@ -44,6 +47,7 @@ module Mongoid
       #
       # @return [ Object ] The result of the block.
       def cache(&block)
+        Mongoid::Warnings.warn_mongoid_query_cache
         Mongo::QueryCache.cache(&block)
       end
 
@@ -54,6 +58,7 @@ module Mongoid
       #
       # @return [ Object ] The result of the block.
       def uncached(&block)
+        Mongoid::Warnings.warn_mongoid_query_cache
         Mongo::QueryCache.uncached(&block)
       end
     end
@@ -61,4 +66,3 @@ module Mongoid
     Middleware = Mongo::QueryCache::Middleware
   end
 end
-

data/lib/mongoid/railties/database.rake

@@ -25,7 +25,7 @@ namespace :db do
 
   unless Rake::Task.task_defined?("db:setup")
     desc "Create the database, and initialize with the seed data"
-    task :setup => [ "db:create", "mongoid:create_indexes", "db:seed" ]
+    task :setup => [ "db:create", "mongoid:create_collections", "mongoid:create_indexes", "db:seed" ]
   end
 
   unless Rake::Task.task_defined?("db:reset")
@@ -55,10 +55,15 @@ namespace :db do
 
   unless Rake::Task.task_defined?("db:test:prepare")
     namespace :test do
-      task :prepare => "mongoid:create_indexes"
+      task :prepare => ["mongoid:create_collections", "mongoid:create_indexes"]
     end
   end
 
+  unless Rake::Task.task_defined?("db:create_collections")
+    desc "Create collections specified in Mongoid models"
+    task :create_collections => "mongoid:create_collections"
+  end
+
   unless Rake::Task.task_defined?("db:create_indexes")
     desc "Create indexes specified in Mongoid models"
     task :create_indexes => "mongoid:create_indexes"

data/lib/mongoid/reloadable.rb

@@ -16,14 +16,16 @@ module Mongoid
     #
     # @return [ Document ] The document, reloaded.
     def reload
+      if @atomic_selector
+        # Clear atomic_selector cache for sharded clusters. MONGOID-5076
+        remove_instance_variable('@atomic_selector')
+      end
+
       reloaded = _reload
       if Mongoid.raise_not_found_error && (reloaded.nil? || reloaded.empty?)
         shard_keys = atomic_selector.with_indifferent_access.slice(*shard_key_fields, :_id)
         raise Errors::DocumentNotFound.new(self.class, _id, shard_keys)
       end
-
-      reset_atomic_updates!
-
       @attributes = reloaded
       @attributes_before_type_cast = @attributes.dup
       @changed_attributes = {}

data/lib/mongoid/stateful.rb

@@ -95,6 +95,23 @@ module Mongoid
         !_parent.delayed_atomic_sets[atomic_path]
     end
 
+    # Flags the document as readonly. Will cause a ReadonlyDocument error to be
+    # raised if the document is attempted to be saved, updated or destroyed.
+    #
+    # @example Flag the document as readonly.
+    #   document.readonly!
+    #
+    # @return [ true | false ] true if the document was successfully marked
+    #   readonly, false otherwise.
+    def readonly!
+      if Mongoid.legacy_readonly
+        Mongoid::Warnings.warn_legacy_readonly
+        false
+      else
+        @readonly = true
+      end
+    end
+
     # Is the document readonly?
     #
     # @example Is the document readonly?
@@ -102,7 +119,11 @@ module Mongoid
     #
     # @return [ true | false ] If the document is readonly.
     def readonly?
-      __selected_fields != nil
+      if Mongoid.legacy_readonly
+        __selected_fields != nil
+      else
+        @readonly ||= false
+      end
     end
 
     # Determine if the document can be set.