mongoid 7.1.1 → 8.1.0

data/lib/mongoid/interceptable.rb

@@ -1,11 +1,8 @@
 # frozen_string_literal: true
-# encoding: utf-8
 
 module Mongoid
 
   # This module contains all the callback hooks for Mongoid.
-  #
-  # @since 4.0.0
   module Interceptable
     extend ActiveSupport::Concern
 
@@ -30,7 +27,7 @@ module Mongoid
       :before_save,
       :before_update,
       :before_upsert,
-      :before_validation
+      :before_validation,
     ].freeze
 
     included do
@@ -40,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
 
@@ -50,9 +53,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 +66,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 +79,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 +96,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 +115,77 @@ 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.
+    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 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)
+      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(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
@@ -148,9 +196,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 +209,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 +236,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 +255,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?
@@ -234,9 +274,9 @@ module Mongoid
     #   document.halted_callback_hook(filter)
     #
     # @param [ Symbol ] filter The callback that halted.
-    #
-    # @since 3.0.3
-    def halted_callback_hook(filter)
+    # @param [ Symbol ] name The name of the callback that was halted
+    #   (requires Rails 6.1+)
+    def halted_callback_hook(filter, name = nil)
       @before_callback_halted = true
     end
 
@@ -250,8 +290,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)

data/lib/mongoid/loggable.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# encoding: utf-8
 
 module Mongoid
 
@@ -15,8 +14,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 +27,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 +41,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 +55,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,54 +1,12 @@
 # frozen_string_literal: true
-# encoding: utf-8
-
-require "mongoid/matchable/default"
-require "mongoid/matchable/all"
-require "mongoid/matchable/and"
-require "mongoid/matchable/elem_match"
-require "mongoid/matchable/eq"
-require "mongoid/matchable/exists"
-require "mongoid/matchable/gt"
-require "mongoid/matchable/gte"
-require "mongoid/matchable/in"
-require "mongoid/matchable/lt"
-require "mongoid/matchable/lte"
-require "mongoid/matchable/ne"
-require "mongoid/matchable/nin"
-require "mongoid/matchable/nor"
-require "mongoid/matchable/or"
-require "mongoid/matchable/regexp"
-require "mongoid/matchable/size"
 
 module Mongoid
 
   # This module contains all the behavior for Ruby implementations of MongoDB
   # selectors.
-  #
-  # @since 4.0.0
   module Matchable
     extend ActiveSupport::Concern
 
-    # Hash lookup for the matcher for a specific operation.
-    #
-    # @since 1.0.0
-    MATCHERS = {
-      "$all" => All,
-      "$and" => And,
-      "$elemMatch" => ElemMatch,
-      "$eq" => Eq,
-      "$exists" => Exists,
-      "$gt" => Gt,
-      "$gte" => Gte,
-      "$in" => In,
-      "$lt" => Lt,
-      "$lte" => Lte,
-      "$ne" => Ne,
-      "$nin" => Nin,
-      "$nor" => Nor,
-      "$or" => Or,
-      "$size" => Size,
-    }.with_indifferent_access.freeze
-
     # Determines if this document has the attributes to match the supplied
     # MongoDB selector. Used for matching on embedded associations.
     #
@@ -57,120 +15,9 @@ 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)
-      selector.each_pair do |key, value|
-        if value.is_a?(Hash)
-          value.each do |item|
-            if item[0].to_s == "$not".freeze
-              item = item[1]
-              return false if matcher(key, item)._matches?(item)
-            else
-              return false unless matcher(key, Hash[*item])._matches?(Hash[*item])
-            end
-          end
-        else
-          return false unless matcher(key, value)._matches?(value)
-        end
-      end
-      true
-    end
-
-    private
-
-    # Get the matcher for the supplied key and value. Will determine the class
-    # name from the key.
-    #
-    # @example Get the matcher.
-    #   document.matcher(:title, { "$in" => [ "test" ] })
-    #
-    # @param [ Symbol, String ] key The field name.
-    # @param [ Object, Hash ] value The value or selector.
-    #
-    # @return [ Matcher ] The matcher.
-    #
-    # @since 2.0.0.rc.7
-    # @api private
-    def matcher(key, value)
-      Matchable.matcher(self, key, value)
-    end
-
-    class << self
-
-      # Get the matcher for the supplied key and value. Will determine the class
-      # name from the key.
-      #
-      # @api private
-      #
-      # @example Get the matcher.
-      #   Matchable.matcher(document, :title, { "$in" => [ "test" ] })
-      #
-      # @param [ Document ] document The document to check.
-      # @param [ Symbol, String ] key The field name.
-      # @param [ Object, Hash ] value The value or selector.
-      #
-      # @return [ Matcher ] The matcher.
-      #
-      # @since 2.0.0.rc.7
-      def matcher(document, key, value)
-        if value.is_a?(Hash)
-          matcher = MATCHERS[value.keys.first]
-          if matcher
-            matcher.new(extract_attribute(document, key))
-          else
-            Default.new(extract_attribute(document, key))
-          end
-        elsif value.regexp?
-          Regexp.new(extract_attribute(document, key))
-        else
-          case key.to_s
-            when "$or" then Or.new(value, document)
-            when "$and" then And.new(value, document)
-            when "$nor" then Nor.new(value, document)
-            else Default.new(extract_attribute(document, key))
-          end
-        end
-      end
-
-      private
-
-      # Extract the attribute from the key, being smarter about dot notation.
-      #
-      # @api private
-      #
-      # @example Extract the attribute.
-      #   strategy.extract_attribute(doc, "info.field")
-      #
-      # @param [ Document ] document The document.
-      # @param [ String ] key The key.
-      #
-      # @return [ Object ] The value of the attribute.
-      #
-      # @since 2.2.1
-      # @api private
-      def extract_attribute(document, key)
-        if (key_string = key.to_s) =~ /.+\..+/
-          key_string.split('.').inject(document.send(:as_attributes)) do |_attribs, _key|
-            if _attribs.is_a?(::Array)
-              if _key =~ /\A\d+\z/ && _attribs.none? {|doc| doc.is_a?(Hash)}
-                _attribs.try(:[], _key.to_i)
-              else
-                _attribs.map { |doc| doc.try(:[], _key) }
-              end
-            else
-              _attribs.try(:[], _key)
-            end
-          end
-        else
-          if document.is_a?(Hash)
-            document[key_string]
-          else
-            document.attributes[key_string]
-          end
-        end
-      end
+      Matcher::Expression.matches?(self, selector)
     end
   end
 end

data/lib/mongoid/matcher/all.rb

@@ -0,0 +1,22 @@
+module Mongoid
+  module Matcher
+
+    # @api private
+    module All
+      module_function def matches?(exists, value, condition)
+        unless Array === condition
+          raise Errors::InvalidQuery, "$all argument must be an array: #{Errors::InvalidQuery.truncate_expr(condition)}"
+        end
+
+        !condition.empty? && condition.all? do |c|
+          case c
+          when ::Regexp, BSON::Regexp::Raw
+            Regex.matches_array_or_scalar?(value, c)
+          else
+            EqImpl.matches?(true, value, c, '$all')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/matcher/and.rb

@@ -0,0 +1,21 @@
+module Mongoid
+  module Matcher
+
+    # @api private
+    module And
+      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)}"
+        end
+
+        if expr.empty?
+          raise Errors::InvalidQuery, "$and argument must be a non-empty array: #{Errors::InvalidQuery.truncate_expr(expr)}"
+        end
+
+        expr.all? do |sub_expr|
+          Expression.matches?(document, sub_expr)
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/matcher/bits.rb

@@ -0,0 +1,41 @@
+module Mongoid
+  module Matcher
+
+    # @api private
+    module Bits
+      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
+
+      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,20 @@
+module Mongoid
+  module Matcher
+
+    # @api private
+    module BitsAllClear
+      include Bits
+      extend self
+
+      def array_matches?(value, condition)
+        condition.all? do |c|
+          value & (1<<c) == 0
+        end
+      end
+
+      def int_matches?(value, condition)
+        value & condition == 0
+      end
+    end
+  end
+end

data/lib/mongoid/matcher/bits_all_set.rb

@@ -0,0 +1,20 @@
+module Mongoid
+  module Matcher
+
+    # @api private
+    module BitsAllSet
+      include Bits
+      extend self
+
+      def array_matches?(value, condition)
+        condition.all? do |c|
+          value & (1<<c) > 0
+        end
+      end
+
+      def int_matches?(value, condition)
+        value & condition == condition
+      end
+    end
+  end
+end

data/lib/mongoid/matcher/bits_any_clear.rb

@@ -0,0 +1,20 @@
+module Mongoid
+  module Matcher
+
+    # @api private
+    module BitsAnyClear
+      include Bits
+      extend self
+
+      def array_matches?(value, condition)
+        condition.any? do |c|
+          value & (1<<c) == 0
+        end
+      end
+
+      def int_matches?(value, condition)
+        value & condition < condition
+      end
+    end
+  end
+end

data/lib/mongoid/matcher/bits_any_set.rb

@@ -0,0 +1,20 @@
+module Mongoid
+  module Matcher
+
+    # @api private
+    module BitsAnySet
+      include Bits
+      extend self
+
+      def array_matches?(value, condition)
+        condition.any? do |c|
+          value & (1<<c) > 0
+        end
+      end
+
+      def int_matches?(value, condition)
+        value & condition > 0
+      end
+    end
+  end
+end

data/lib/mongoid/matcher/elem_match.rb

@@ -0,0 +1,36 @@
+module Mongoid
+  module Matcher
+
+    # @api private
+    module ElemMatch
+      module_function def matches?(exists, value, condition)
+        unless Hash === condition
+          raise Errors::InvalidQuery, "$elemMatch requires a Hash operand: #{Errors::InvalidQuery.truncate_expr(condition)}"
+        end
+        if Array === value && !value.empty?
+          value.any? do |v|
+            ElemMatchExpression.matches?(v, condition)
+          end
+        else
+          # Validate the condition is valid, even though we will never attempt
+          # matching it.
+          condition.each do |k, v|
+            k = k.to_s
+            if k.start_with?('$')
+              begin
+                ExpressionOperator.get(k)
+              rescue Mongoid::Errors::InvalidExpressionOperator
+                begin
+                  FieldOperator.get(k)
+                rescue Mongoid::Errors::InvalidFieldOperator => exc
+                  raise Mongoid::Errors::InvalidElemMatchOperator.new(exc.operator)
+                end
+              end
+            end
+          end
+          false
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/matcher/elem_match_expression.rb

@@ -0,0 +1,20 @@
+module Mongoid
+  module Matcher
+
+    # $elemMatch argument can be a top-level expression and some specific
+    # operator combinations like $not with a regular expression.
+    #
+    # @api private
+    module ElemMatchExpression
+      module_function def matches?(document, expr)
+        Expression.matches?(document, expr)
+      rescue Mongoid::Errors::InvalidExpressionOperator
+        begin
+          FieldExpression.matches?(true, document, expr)
+        rescue Mongoid::Errors::InvalidFieldOperator => exc
+          raise Mongoid::Errors::InvalidElemMatchOperator.new(exc.operator)
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/matcher/eq.rb

@@ -0,0 +1,11 @@
+module Mongoid
+  module Matcher
+
+    # @api private
+    module Eq
+      module_function def matches?(exists, value, condition)
+        EqImpl.matches?(exists, value, condition, '$eq')
+      end
+    end
+  end
+end