mongoid 7.2.1 → 9.0.0

data/lib/mongoid/interceptable.rb

@@ -1,11 +1,9 @@
 # frozen_string_literal: true
-# encoding: utf-8
+# rubocop:todo all
 
 module Mongoid
 
   # This module contains all the callback hooks for Mongoid.
-  #
-  # @since 4.0.0
   module Interceptable
     extend ActiveSupport::Concern
 
@@ -30,7 +28,7 @@ module Mongoid
       :before_save,
       :before_update,
       :before_upsert,
-      :before_validation
+      :before_validation,
     ].freeze
 
     included do
@@ -40,6 +38,16 @@ 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
+
+      define_callbacks :commit, :rollback,
+                       only: :after,
+                       scope: [:kind, :name]
+
       attr_accessor :before_callback_halted
     end
 
@@ -50,9 +58,7 @@ module Mongoid
     #
     # @param [ Symbol ] kind The type of callback.
     #
-    # @return [ true, false ] If the callback can be executed.
-    #
-    # @since 3.0.6
+    # @return [ true | false ] If the callback can be executed.
     def callback_executable?(kind)
       respond_to?("_#{kind}_callbacks")
     end
@@ -65,9 +71,7 @@ module Mongoid
     #
     # @param [ Symbol ] kind The callback kind.
     #
-    # @return [ true, false ] If the document is in a callback state.
-    #
-    # @since 3.1.0
+    # @return [ true | false ] If the document is in a callback state.
     def in_callback_state?(kind)
       [ :create, :destroy ].include?(kind) || new_record? || flagged_for_destroy? || changed?
     end
@@ -80,11 +84,9 @@ module Mongoid
     # @example Run only the after save callbacks.
     #   model.run_after_callbacks(:save)
     #
-    # @param [ Array<Symbol> ] kinds The events that are occurring.
+    # @param [ Symbol... ] *kinds The events that are occurring.
     #
     # @return [ Object ] The result of the chain executing.
-    #
-    # @since 3.0.0
     def run_after_callbacks(*kinds)
       kinds.each do |kind|
         run_targeted_callbacks(:after, kind)
@@ -99,11 +101,9 @@ module Mongoid
     # @example Run only the before save callbacks.
     #   model.run_before_callbacks(:save, :create)
     #
-    # @param [ Array<Symbol> ] kinds The events that are occurring.
+    # @param [ Symbol... ] *kinds The events that are occurring.
     #
     # @return [ Object ] The result of the chain executing.
-    #
-    # @since 3.0.0
     def run_before_callbacks(*kinds)
       kinds.each do |kind|
         run_targeted_callbacks(:before, kind)
@@ -120,24 +120,173 @@ module Mongoid
     #   end
     #
     # @param [ Symbol ] kind The type of callback to execute.
-    # @param [ Array ] args Any options.
-    #
-    # @return [ Document ] The document
-    #
-    # @since 2.3.0
-    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.
+    # @param [ Proc | nil ] skip_if If this proc returns true, the callbacks
+    #   will not be triggered, while the given block will be still called.
+    def run_callbacks(kind, with_children: true, skip_if: nil, &block)
+      if skip_if&.call
+        return block&.call
+      end
+      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 execute 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)
+      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?
+        block&.call
+      elsif tail.empty?
+        child.run_callbacks(child_callback_type(kind, child), with_children: with_children, &block)
+      else
+        child.run_callbacks(child_callback_type(kind, child), with_children: with_children) do
+          _mongoid_run_child_callbacks_with_around(kind, children: tail, &block)
+        end
+      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]
+        if (grandchildren = child.send(:cascadable_children, kind))
+          _mongoid_run_child_before_callbacks(kind, children: grandchildren, callback_list: callback_list)
+        end
+      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.
+    #
+    # @return [ Array<Symbol> ] Method symbols of the stored 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
+    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
@@ -148,9 +297,7 @@ module Mongoid
     # @example Was a before callback halted?
     #   document.before_callback_halted?
     #
-    # @return [ true, false ] If a before callback was halted.
-    #
-    # @since 3.0.3
+    # @return [ true | false ] If a before callback was halted.
     def before_callback_halted?
       !!@before_callback_halted
     end
@@ -163,8 +310,6 @@ module Mongoid
     # @param [ Symbol ] kind The type of callback.
     #
     # @return [ Array<Document> ] The children.
-    #
-    # @since 2.3.0
     def cascadable_children(kind, children = Set.new)
       embedded_relations.each_pair do |name, association|
         next unless association.cascading_callbacks?
@@ -192,9 +337,7 @@ module Mongoid
     # @param [ Symbol ] kind The type of callback.
     # @param [ Document ] child The child document.
     #
-    # @return [ true, false ] If the child should fire the callback.
-    #
-    # @since 2.3.0
+    # @return [ true | false ] If the child should fire the callback.
     def cascadable_child?(kind, child, association)
       return false if kind == :initialize || kind == :find || kind == :touch
       return false if kind == :validate && association.validate?
@@ -213,8 +356,6 @@ module Mongoid
     # @param [ Document ] child The child document
     #
     # @return [ Symbol ] The name of the callback.
-    #
-    # @since 2.3.0
     def child_callback_type(kind, child)
       if kind == :update
         return :create if child.new_record?
@@ -236,8 +377,6 @@ module Mongoid
     # @param [ Symbol ] filter The callback that halted.
     # @param [ Symbol ] name The name of the callback that was halted
     #   (requires Rails 6.1+)
-    #
-    # @since 3.0.3
     def halted_callback_hook(filter, name = nil)
       @before_callback_halted = true
     end
@@ -252,8 +391,6 @@ module Mongoid
     # @param [ Symbol ] kind The type of callback, :save, :create, :update.
     #
     # @return [ Object ] The result of the chain execution.
-    #
-    # @since 3.0.0
     def run_targeted_callbacks(place, kind)
       name = "_run__#{place}__#{kind}__callbacks"
       unless respond_to?(name)
@@ -263,7 +400,7 @@ module Mongoid
         end
         self.class.send :define_method, name do
           env = ActiveSupport::Callbacks::Filters::Environment.new(self, false, nil)
-          sequence = chain.compile
+          sequence = compile_callbacks(chain)
           sequence.invoke_before(env)
           env.value = !env.halted
           sequence.invoke_after(env)
@@ -273,5 +410,24 @@ 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/loadable.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+# rubocop:todo all
+
+module Mongoid
+
+  # Defines how Mongoid can autoload all defined models.
+  module Loadable
+    # The default list of paths where model classes should be looked for. If
+    # Rails is present, the "app/models" paths will be used instead.
+    # (See #model_paths.)
+    DEFAULT_MODEL_PATHS = %w( ./app/models ./lib/models ).freeze
+
+    # Search a list of model paths to get every model and require it, so
+    # that indexing and inheritance work in both development and production
+    # with the same results.
+    #
+    # @example Load all the application models from default model paths.
+    #   Mongoid.load_models
+    #
+    # @example Load all application models from a non-standard set of paths.
+    #   Mongoid.load_models(%w( ./models ./admin/models ))
+    #
+    # @param [ Array ] paths The list of paths that should be looked in
+    #   for model files. These must either be absolute paths, or relative to
+    #   the current working directory.
+    def load_models(paths = model_paths)
+      paths.each do |path|
+        if preload_models.resizable?
+          files = preload_models.map { |model| "#{path}/#{model.underscore}.rb" }
+        else
+          files = Dir.glob("#{path}/**/*.rb")
+        end
+
+        files.sort.each do |file|
+          load_model(file.gsub(/^#{path}\// , "").gsub(/\.rb$/, ""))
+        end
+      end
+    end
+
+    # A convenience method for loading a model's file. If Rails'
+    # `require_dependency` method exists, it will be used; otherwise
+    # `require` will be used.
+    #
+    # @example Load the model.
+    #   Mongoid.load_model("/mongoid/behavior")
+    #
+    # @param [ String ] file The base filename.
+    #
+    # @api private
+    def load_model(file)
+      if defined?(require_dependency)
+        require_dependency(file)
+      else
+        require(file)
+      end
+    end
+
+    # Returns the array of paths where the application's model definitions
+    # are located. If Rails is loaded, this defaults to the configured
+    # "app/models" paths (e.g. `config.paths["app/models"]`); otherwise, it
+    # defaults to `%w(./app/models ./lib/models)`.
+    #
+    # Note that these paths are the *roots* of the directory hierarchies where
+    # the models are located; it is not necessary to indicate every subdirectory,
+    # as long as these root paths are located in `$LOAD_PATH`.
+    #
+    # @return [ Array<String> ] the array of model paths
+    def model_paths
+      @model_paths ||= defined?(Rails) ?
+        Rails.application.config.paths["app/models"].expanded :
+        DEFAULT_MODEL_PATHS
+    end
+
+    # Sets the model paths to the given array of paths. These are the paths
+    # where the application's model definitions are located.
+    #
+    # @param [ Array<String> ] paths The list of model paths
+    def model_paths=(paths)
+      @model_paths = paths
+    end
+  end
+
+end

data/lib/mongoid/loggable.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# encoding: utf-8
+# rubocop:todo all
 
 module Mongoid
 
@@ -15,8 +15,6 @@ module Mongoid
     #   Loggable.logger
     #
     # @return [ Logger ] The logger.
-    #
-    # @since 3.0.0
     def logger
       return @logger if defined?(@logger)
       @logger = rails_logger || default_logger
@@ -30,8 +28,6 @@ module Mongoid
     # @param [ Logger ] logger The logger to set.
     #
     # @return [ Logger ] The new logger.
-    #
-    # @since 3.0.0
     def logger=(logger)
       @logger = logger
     end
@@ -46,8 +42,6 @@ module Mongoid
     #   Loggable.default_logger
     #
     # @return [ Logger ] The default logger.
-    #
-    # @since 3.0.0
     def default_logger
       logger = Logger.new(STDERR)
       logger.level = Mongoid::Config.log_level
@@ -62,8 +56,6 @@ module Mongoid
     #   Loggable.rails_logger
     #
     # @return [ Logger ] The Rails logger.
-    #
-    # @since 3.0.0
     def rails_logger
       if defined?(::Rails)
         ::Rails.logger

data/lib/mongoid/matchable.rb

@@ -1,12 +1,10 @@
 # frozen_string_literal: true
-# encoding: utf-8
+# rubocop:todo all
 
 module Mongoid
 
   # This module contains all the behavior for Ruby implementations of MongoDB
   # selectors.
-  #
-  # @since 4.0.0
   module Matchable
     extend ActiveSupport::Concern
 
@@ -18,9 +16,7 @@ module Mongoid
     #
     # @param [ Hash ] selector The MongoDB selector.
     #
-    # @return [ true, false ] True if matches, false if not.
-    #
-    # @since 1.0.0
+    # @return [ true | false ] True if matches, false if not.
     def _matches?(selector)
       Matcher::Expression.matches?(self, selector)
     end

data/lib/mongoid/matcher/all.rb

@@ -1,8 +1,23 @@
+# rubocop:todo all
 module Mongoid
   module Matcher
 
+    # In-memory matcher for $all expression.
+    #
+    # @see https://www.mongodb.com/docs/manual/reference/operator/query/all/
+    #
     # @api private
     module All
+
+      # Returns whether a value satisfies an $all expression.
+      #
+      # @param [ true | false ] exists Not used.
+      # @param [ Object ] value The value to check.
+      # @param [ Array<Object> ] condition The $all condition predicate.
+      #
+      # @return [ true | false ] Whether the value matches.
+      #
+      # @api private
       module_function def matches?(exists, value, condition)
         unless Array === condition
           raise Errors::InvalidQuery, "$all argument must be an array: #{Errors::InvalidQuery.truncate_expr(condition)}"

data/lib/mongoid/matcher/and.rb

@@ -1,8 +1,22 @@
+# rubocop:todo all
 module Mongoid
   module Matcher
 
+    # In-memory matcher for $and expression.
+    #
+    # @see https://www.mongodb.com/docs/manual/reference/operator/query/and/
+    #
     # @api private
     module And
+
+      # Returns whether a document satisfies an $and expression.
+      #
+      # @param [ Mongoid::Document ] document The document.
+      # @param [ Array<Hash> ] expr The $and conditions.
+      #
+      # @return [ true | false ] Whether the document matches.
+      #
+      # @api private
       module_function def matches?(document, expr)
         unless expr.is_a?(Array)
           raise Errors::InvalidQuery, "$and argument must be an array: #{Errors::InvalidQuery.truncate_expr(expr)}"

data/lib/mongoid/matcher/bits.rb

@@ -0,0 +1,60 @@
+# rubocop:todo all
+module Mongoid
+  module Matcher
+
+    # Mixin module included in bitwise expression matchers.
+    #
+    # @api private
+    module Bits
+
+      # Returns whether a value satisfies a bitwise expression.
+      #
+      # @param [ true | false ] exists Not used.
+      # @param [ Object ] value The value to check.
+      # @param [ Numeric | Array<Numeric> ] condition The expression
+      #   predicate as a bitmask or position list.
+      #
+      # @return [ true | false ] Whether the value matches.
+      #
+      # @api private
+      def matches?(exists, value, condition)
+        case value
+        when BSON::Binary
+          value = value.data.split('').map { |n| '%02x' % n.ord }.join.to_i(16)
+        end
+        case condition
+        when Array
+          array_matches?(value, condition)
+        when BSON::Binary
+          int_cond = condition.data.split('').map { |n| '%02x' % n.ord }.join.to_i(16)
+          int_matches?(value, int_cond)
+        when Integer
+          if condition < 0
+            raise Errors::InvalidQuery, "Invalid value for $#{operator_name} argument: negative integers are not allowed: #{condition}"
+          end
+          int_matches?(value, condition)
+        when Float
+          if (int_cond = condition.to_i).to_f == condition
+            if int_cond < 0
+              raise Errors::InvalidQuery, "Invalid value for $#{operator_name} argument: negative numbers are not allowed: #{condition}"
+            end
+            int_matches?(value, int_cond)
+          else
+            raise Errors::InvalidQuery, "Invalid type for $#{operator_name} argument: not representable as an integer: #{condition}"
+          end
+        else
+          raise Errors::InvalidQuery, "Invalid type for $#{operator_name} argument: #{condition}"
+        end
+      end
+
+      # Returns the name of the expression operator.
+      #
+      # @return [ String ] The operator name.
+      #
+      # @api private
+      module_function def operator_name
+        name.sub(/.*::/, '').sub(/\A(.)/) { |l| l.downcase }
+      end
+    end
+  end
+end

data/lib/mongoid/matcher/bits_all_clear.rb

@@ -0,0 +1,41 @@
+# rubocop:todo all
+module Mongoid
+  module Matcher
+
+    # In-memory matcher for $bitsAllClear expression.
+    #
+    # @see https://www.mongodb.com/docs/manual/reference/operator/query/bitsAllClear/
+    #
+    # @api private
+    module BitsAllClear
+      include Bits
+      extend self
+
+      # Returns whether a position list condition matches a value.
+      #
+      # @param [ Object ] value The value to check.
+      # @param [ Array<Numeric> ] condition The position list condition.
+      #
+      # @return [ true | false ] Whether the value matches.
+      #
+      # @api private
+      def array_matches?(value, condition)
+        condition.all? do |c|
+          value & (1<<c) == 0
+        end
+      end
+
+      # Returns whether a bitmask condition matches a value.
+      #
+      # @param [ Object ] value The value to check.
+      # @param [ Numeric ] condition The bitmask condition.
+      #
+      # @return [ true | false ] Whether the value matches.
+      #
+      # @api private
+      def int_matches?(value, condition)
+        value & condition == 0
+      end
+    end
+  end
+end

data/lib/mongoid/matcher/bits_all_set.rb

@@ -0,0 +1,41 @@
+# rubocop:todo all
+module Mongoid
+  module Matcher
+
+    # In-memory matcher for $bitsAllSet expression.
+    #
+    # @see https://www.mongodb.com/docs/manual/reference/operator/query/bitsAllSet/
+    #
+    # @api private
+    module BitsAllSet
+      include Bits
+      extend self
+
+      # Returns whether a position list condition matches a value.
+      #
+      # @param [ Object ] value The value to check.
+      # @param [ Array<Numeric> ] condition The position list condition.
+      #
+      # @return [ true | false ] Whether the value matches.
+      #
+      # @api private
+      def array_matches?(value, condition)
+        condition.all? do |c|
+          value & (1<<c) > 0
+        end
+      end
+
+      # Returns whether a bitmask condition matches a value.
+      #
+      # @param [ Object ] value The value to check.
+      # @param [ Numeric ] condition The bitmask condition.
+      #
+      # @return [ true | false ] Whether the value matches.
+      #
+      # @api private
+      def int_matches?(value, condition)
+        value & condition == condition
+      end
+    end
+  end
+end