mongoid 7.6.2 → 8.0.1

data/lib/mongoid/findable.rb

@@ -38,6 +38,7 @@ module Mongoid
       :max,
       :min,
       :none,
+      :pick,
       :pluck,
       :read,
       :sum,
@@ -121,6 +122,13 @@ module Mongoid
     # strings will be transparently converted to +BSON::ObjectId+ instances
     # during query construction.
     #
+    # If this method is given a block, it delegates to +Enumerable#find+ and
+    # returns the first document of those found by the current Crieria object
+    # for which the block returns a truthy value. If both a block and ids are
+    # given, the block is ignored and the documents for the given ids are
+    # returned. If a block and a Proc are given, the method delegates to
+    # +Enumerable#find+ and uses the proc as the default.
+    #
     # The +find+ method takes into account the default scope defined on the
     # model class, if any.
     #
@@ -131,8 +139,13 @@ module Mongoid
     #
     # @raise Errors::DocumentNotFound If not all documents are found and
     #   the +raise_not_found_error+ Mongoid configuration option is truthy.
-    def find(*args)
-      with_default_scope.find(*args)
+    def find(*args, &block)
+      empty_or_proc = args.empty? || (args.length == 1 && args.first.is_a?(Proc))
+      if block_given? && empty_or_proc
+        with_default_scope.find(*args, &block)
+      else
+        with_default_scope.find(*args)
+      end
     end
 
     # Find the first +Document+ given the conditions.
@@ -182,15 +195,11 @@ module Mongoid
     # @example Find the first document.
     #   Person.first
     #
-    # @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 matching document.
-    def first(limit_or_opts = nil)
-      with_default_scope.first(limit_or_opts)
+    def first(limit = nil)
+      with_default_scope.first(limit)
     end
     alias :one :first
 
@@ -199,15 +208,11 @@ module Mongoid
     # @example Find the last document.
     #   Person.last
     #
-    # @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 last matching document.
-    def last(limit_or_opts = nil)
-      with_default_scope.last(limit_or_opts)
+    def last(limit = nil)
+      with_default_scope.last(limit)
     end
   end
 end

data/lib/mongoid/indexable/specification.rb

@@ -86,7 +86,7 @@ module Mongoid
       # @api private
       #
       # @example Normalize the index options.
-      #   specification.normalize_options(drop_dups: true)
+      #   specification.normalize_options(unique: true)
       #
       # @param [ Hash ] opts The index options.
       #

data/lib/mongoid/indexable/validators/options.rb

@@ -13,7 +13,6 @@ module Mongoid
           :database,
           :default_language,
           :language_override,
-          :drop_dups,
           :name,
           :sparse,
           :unique,
@@ -98,6 +97,10 @@ module Mongoid
             unless VALID_TYPES.include?(value)
               raise Errors::InvalidIndex.new(klass, spec, options)
             end
+
+            if value == "geoHaystack"
+              Mongoid::Warnings.warn_geo_haystack_deprecated
+            end
           end
         end
       end

data/lib/mongoid/interceptable.rb

@@ -27,7 +27,7 @@ module Mongoid
       :before_save,
       :before_update,
       :before_upsert,
-      :before_validation
+      :before_validation,
     ].freeze
 
     included do
@@ -37,6 +37,12 @@ module Mongoid
       define_model_callbacks :build, :find, :initialize, :touch, only: :after
       define_model_callbacks :create, :destroy, :save, :update, :upsert
 
+      # This callback is used internally by Mongoid to save association
+      # targets for referenced associations after the parent model is persisted.
+      #
+      # @api private
+      define_model_callbacks :persist_parent
+
       attr_accessor :before_callback_halted
     end
 
@@ -109,22 +115,76 @@ module Mongoid
     #   end
     #
     # @param [ Symbol ] kind The type of callback to execute.
-    # @param [ Array ] args Any options.
-    #
-    # @return [ Document ] The document
-    ruby2_keywords def run_callbacks(kind, *args, &block)
-      cascadable_children(kind).each do |child|
-        if child.run_callbacks(child_callback_type(kind, child), *args) == false
-          return false
+    # @param [ true | false ] with_children Flag specifies whether callbacks of embedded document should be run.
+    def run_callbacks(kind, with_children: true, &block)
+      if with_children
+        cascadable_children(kind).each do |child|
+          if child.run_callbacks(child_callback_type(kind, child), with_children: with_children) == false
+            return false
+          end
         end
       end
       if callback_executable?(kind)
-        super(kind, *args, &block)
+        super(kind, &block)
       else
         true
       end
     end
 
+    # Run the callbacks for embedded documents.
+    #
+    # @param [ Symbol ] kind The type of callback to execute.
+    # @param [ Array<Document> ] children Children to exeute callbacks on. If
+    #   nil, callbacks will be executed on all cascadable children of
+    #   the document.
+    #
+    # @api private
+    def _mongoid_run_child_callbacks(kind, children: nil, &block)
+      child, *tail = (children || cascadable_children(kind))
+      if child.nil?
+        return block&.call
+      elsif tail.empty?
+        return child.run_callbacks(child_callback_type(kind, child), &block)
+      else
+        return child.run_callbacks(child_callback_type(kind, child)) do
+          _mongoid_run_child_callbacks(kind, children: tail, &block)
+        end
+      end
+    end
+
+    # 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> ] an array of symbols that represent the pending callbacks.
+    #
+    # @api private
+    def pending_callbacks
+      @pending_callbacks ||= [].to_set
+    end
+
+    # @api private
+    def pending_callbacks=(value)
+      @pending_callbacks = value
+    end
+
+    # Run the pending callbacks. If the callback is :apply_defaults, we will apply
+    # the defaults for this document. Otherwise, the callback is passed to the
+    # run_callbacks function.
+    #
+    # @api private
+    def run_pending_callbacks
+      pending_callbacks.each do |cb|
+        if [:apply_defaults, :apply_post_processed_defaults].include?(cb)
+          send(cb)
+        else
+          self.run_callbacks(cb, with_children: false)
+        end
+      end
+      pending_callbacks.clear
+    end
+
     private
 
     # We need to hook into this for autosave, since we don't want it firing if

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_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.rb

@@ -104,7 +104,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

@@ -102,13 +102,22 @@ module Mongoid
       def prepare_insert(options = {})
         return self if performing_validations?(options) &&
           invalid?(options[:context] || :create)
-        result = run_callbacks(:save) do
-          run_callbacks(:create) do
-            yield(self)
-            post_process_insert
+        run_callbacks(:save, with_children: false) do
+          run_callbacks(:create, with_children: false) do
+            run_callbacks(:persist_parent, with_children: false) do
+              _mongoid_run_child_callbacks(:save) do
+                _mongoid_run_child_callbacks(:create) do
+                  result = yield(self)
+                  if !result.is_a?(Document) || result.errors.empty?
+                    post_process_insert
+                    post_process_persist(result, options)
+                  end
+                end
+              end
+            end
           end
         end
-        post_process_persist(result, options) and self
+        self
       end
 
       module ClassMethods

data/lib/mongoid/persistable/updatable.rb

@@ -96,13 +96,20 @@ module Mongoid
         return false if performing_validations?(options) &&
           invalid?(options[:context] || :update)
         process_flagged_destroys
-        result = run_callbacks(:save) do
-          run_callbacks(:update) do
-            yield(self)
-            true
+        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
+                  result = yield(self)
+                  self.previously_new_record = false
+                  post_process_persist(result, options)
+                  true
+                end
+              end
+            end
           end
         end
-        post_process_persist(result, options) and result
       end
 
       # Update the document in the database.

data/lib/mongoid/persistence_context.rb

@@ -57,7 +57,9 @@ module Mongoid
     # @return [ Mongo::Collection ] The collection for this persistence
     #   context.
     def collection(parent = nil)
-      parent ? parent.collection.with(client_options) : client[collection_name.to_sym]
+      parent ?
+        parent.collection.with(client_options.except(:database, "database")) :
+        client[collection_name.to_sym]
     end
 
     # Get the collection name for this persistence context.
@@ -187,7 +189,8 @@ module Mongoid
       #
       # @return [ Mongoid::PersistenceContext ] The persistence context for the object.
       def set(object, options_or_context)
-        existing_context = get_context(object)
+        key = "[mongoid][#{object.object_id}]:context"
+        existing_context = Thread.current[key]
         existing_options = if existing_context
           existing_context.options
         else
@@ -198,7 +201,7 @@ module Mongoid
         end
         new_options = existing_options.merge(options_or_context)
         context = PersistenceContext.new(object, new_options)
-        store_context(object, context)
+        Thread.current[key] = context
       end
 
       # Get the persistence context for a particular class or model instance.
@@ -210,7 +213,7 @@ module Mongoid
       #
       # @return [ Mongoid::PersistenceContext ] The persistence context for the object.
       def get(object)
-        get_context(object)
+        Thread.current["[mongoid][#{object.object_id}]:context"]
       end
 
       # Clear the persistence context for a particular class or model instance.
@@ -229,44 +232,7 @@ module Mongoid
           end
         end
       ensure
-        store_context(object, original_context)
-      end
-
-      private
-
-      # Key to store persistence contexts in the thread local storage.
-      #
-      # @api private
-      PERSISTENCE_CONTEXT_KEY = :"[mongoid]:persistence_context"
-
-      # Get the persistence context for a given object from the thread local
-      #   storage.
-      #
-      # @param [ Object ] object Object to get the persistance context for.
-      #
-      # @return [ Mongoid::PersistenceContext | nil ] The persistence context
-      #   for the object if previously stored, otherwise nil.
-      #
-      # @api private
-      def get_context(object)
-        Thread.current[PERSISTENCE_CONTEXT_KEY] ||= {}
-        Thread.current[PERSISTENCE_CONTEXT_KEY][object.object_id]
-      end
-
-      # Store persistence context for a given object in the thread local
-      #   storage.
-      #
-      # @param [ Object ] object Object to store the persistance context for.
-      # @param [ Mongoid::PersistenceContext ] context Context to store
-      #
-      # @api private
-      def store_context(object, context)
-        if context.nil?
-          Thread.current[PERSISTENCE_CONTEXT_KEY]&.delete(object.object_id)
-        else
-          Thread.current[PERSISTENCE_CONTEXT_KEY] ||= {}
-          Thread.current[PERSISTENCE_CONTEXT_KEY][object.object_id] = context
-        end
+        Thread.current["[mongoid][#{object.object_id}]:context"] = original_context
       end
     end
   end