mongoid 3.1.5 → 8.0.2

data/lib/mongoid/interceptable.rb

@@ -0,0 +1,312 @@
+# frozen_string_literal: true
+
+module Mongoid
+
+  # This module contains all the callback hooks for Mongoid.
+  module Interceptable
+    extend ActiveSupport::Concern
+
+    CALLBACKS = [
+      :after_build,
+      :after_create,
+      :after_destroy,
+      :after_find,
+      :after_initialize,
+      :after_save,
+      :after_touch,
+      :after_update,
+      :after_upsert,
+      :after_validation,
+      :around_create,
+      :around_destroy,
+      :around_save,
+      :around_update,
+      :around_upsert,
+      :before_create,
+      :before_destroy,
+      :before_save,
+      :before_update,
+      :before_upsert,
+      :before_validation,
+    ].freeze
+
+    included do
+      extend ActiveModel::Callbacks
+      include ActiveModel::Validations::Callbacks
+
+      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
+
+    # Is the provided type of callback executable by this document?
+    #
+    # @example Is the callback executable?
+    #   document.callback_executable?(:save)
+    #
+    # @param [ Symbol ] kind The type of callback.
+    #
+    # @return [ true | false ] If the callback can be executed.
+    def callback_executable?(kind)
+      respond_to?("_#{kind}_callbacks")
+    end
+
+    # Is the document currently in a state that could potentially require
+    # callbacks to be executed?
+    #
+    # @example Is the document in a callback state?
+    #   document.in_callback_state?(:update)
+    #
+    # @param [ Symbol ] kind The callback kind.
+    #
+    # @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
+
+    # Run only the after callbacks for the specific event.
+    #
+    # @note ActiveSupport does not allow this type of behavior by default, so
+    #   Mongoid has to get around it and implement itself.
+    #
+    # @example Run only the after save callbacks.
+    #   model.run_after_callbacks(:save)
+    #
+    # @param [ Array<Symbol> ] kinds The events that are occurring.
+    #
+    # @return [ Object ] The result of the chain executing.
+    def run_after_callbacks(*kinds)
+      kinds.each do |kind|
+        run_targeted_callbacks(:after, kind)
+      end
+    end
+
+    # Run only the before callbacks for the specific event.
+    #
+    # @note ActiveSupport does not allow this type of behavior by default, so
+    #   Mongoid has to get around it and implement itself.
+    #
+    # @example Run only the before save callbacks.
+    #   model.run_before_callbacks(:save, :create)
+    #
+    # @param [ Array<Symbol> ] kinds The events that are occurring.
+    #
+    # @return [ Object ] The result of the chain executing.
+    def run_before_callbacks(*kinds)
+      kinds.each do |kind|
+        run_targeted_callbacks(:before, kind)
+      end
+    end
+
+    # Run the callbacks for the document. This overrides active support's
+    # functionality to cascade callbacks to embedded documents that have been
+    # flagged as such.
+    #
+    # @example Run the callbacks.
+    #   run_callbacks :save do
+    #     save!
+    #   end
+    #
+    # @param [ Symbol ] kind The type of callback to execute.
+    # @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, &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
+    # the before callbacks were halted.
+    #
+    # @api private
+    #
+    # @example Was a before callback halted?
+    #   document.before_callback_halted?
+    #
+    # @return [ true | false ] If a before callback was halted.
+    def before_callback_halted?
+      !!@before_callback_halted
+    end
+
+    # Get all the child embedded documents that are flagged as cascadable.
+    #
+    # @example Get all the cascading children.
+    #   document.cascadable_children(:update)
+    #
+    # @param [ Symbol ] kind The type of callback.
+    #
+    # @return [ Array<Document> ] The children.
+    def cascadable_children(kind, children = Set.new)
+      embedded_relations.each_pair do |name, association|
+        next unless association.cascading_callbacks?
+        without_autobuild do
+          delayed_pulls = delayed_atomic_pulls[name]
+          delayed_unsets = delayed_atomic_unsets[name]
+          children.merge(delayed_pulls) if delayed_pulls
+          children.merge(delayed_unsets) if delayed_unsets
+          relation = send(name)
+          Array.wrap(relation).each do |child|
+            next if children.include?(child)
+            children.add(child) if cascadable_child?(kind, child, association)
+            child.send(:cascadable_children, kind, children)
+          end
+        end
+      end
+      children.to_a
+    end
+
+    # Determine if the child should fire the callback.
+    #
+    # @example Should the child fire the callback?
+    #   document.cascadable_child?(:update, doc)
+    #
+    # @param [ Symbol ] kind The type of callback.
+    # @param [ Document ] child The child document.
+    #
+    # @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?
+      child.callback_executable?(kind) ? child.in_callback_state?(kind) : false
+    end
+
+    # Get the name of the callback that the child should fire. This changes
+    # depending on whether or not the child is new. A persisted parent with a
+    # new child would fire :update from the parent, but needs to fire :create
+    # on the child.
+    #
+    # @example Get the callback type.
+    #   document.child_callback_type(:update, doc)
+    #
+    # @param [ Symbol ] kind The type of callback.
+    # @param [ Document ] child The child document
+    #
+    # @return [ Symbol ] The name of the callback.
+    def child_callback_type(kind, child)
+      if kind == :update
+        return :create if child.new_record?
+        return :destroy if child.flagged_for_destroy?
+        kind
+      else
+        kind
+      end
+    end
+
+    # We need to hook into this for autosave, since we don't want it firing if
+    # the before callbacks were halted.
+    #
+    # @api private
+    #
+    # @example Hook into the halt.
+    #   document.halted_callback_hook(filter)
+    #
+    # @param [ Symbol ] filter The callback that halted.
+    # @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
+
+    # Run only the callbacks for the target location (before, after, around)
+    # and kind (save, update, create).
+    #
+    # @example Run the targeted callbacks.
+    #   model.run_targeted_callbacks(:before, :save)
+    #
+    # @param [ Symbol ] place The time to run, :before, :after, :around.
+    # @param [ Symbol ] kind The type of callback, :save, :create, :update.
+    #
+    # @return [ Object ] The result of the chain execution.
+    def run_targeted_callbacks(place, kind)
+      name = "_run__#{place}__#{kind}__callbacks"
+      unless respond_to?(name)
+        chain = ActiveSupport::Callbacks::CallbackChain.new(name, {})
+        send("_#{kind}_callbacks").each do |callback|
+          chain.append(callback) if callback.kind == place
+        end
+        self.class.send :define_method, name do
+          env = ActiveSupport::Callbacks::Filters::Environment.new(self, false, nil)
+          sequence = chain.compile
+          sequence.invoke_before(env)
+          env.value = !env.halted
+          sequence.invoke_after(env)
+          env.value
+        end
+        self.class.send :protected, name
+      end
+      send(name)
+    end
+  end
+end

data/lib/mongoid/loggable.rb

@@ -1,20 +1,19 @@
-# encoding: utf-8
+# frozen_string_literal: true
+
 module Mongoid
 
-  # Contains logging behaviour.
+  # Contains logging behavior.
   module Loggable
 
     # Get the logger.
     #
     # @note Will try to grab Rails' logger first before creating a new logger
-    #   with stdout.
+    #   with stderr.
     #
     # @example Get the logger.
     #   Loggable.logger
     #
     # @return [ Logger ] The logger.
-    #
-    # @since 3.0.0
     def logger
       return @logger if defined?(@logger)
       @logger = rails_logger || default_logger
@@ -23,20 +22,18 @@ module Mongoid
     # Set the logger.
     #
     # @example Set the logger.
-    #   Loggable.logger = Logger.new($stdout)
+    #   Loggable.logger = Logger.new(STDERR)
     #
-    # @param [ Logger ] The logger to set.
+    # @param [ Logger ] logger The logger to set.
     #
     # @return [ Logger ] The new logger.
-    #
-    # @since 3.0.0
     def logger=(logger)
       @logger = logger
     end
 
     private
 
-    # Gets the default Mongoid logger - stdout.
+    # Gets the default Mongoid logger - stderr.
     #
     # @api private
     #
@@ -44,15 +41,13 @@ module Mongoid
     #   Loggable.default_logger
     #
     # @return [ Logger ] The default logger.
-    #
-    # @since 3.0.0
     def default_logger
-      logger = Logger.new($stdout)
-      logger.level = Logger::INFO
+      logger = Logger.new(STDERR)
+      logger.level = Mongoid::Config.log_level
       logger
     end
 
-    # Get the Rails logger if it's defined.
+    # Get the Rails logger if loaded in a Rails application, otherwise nil.
     #
     # @api private
     #
@@ -60,10 +55,12 @@ module Mongoid
     #   Loggable.rails_logger
     #
     # @return [ Logger ] The Rails logger.
-    #
-    # @since 3.0.0
     def rails_logger
-      defined?(::Rails) && ::Rails.respond_to?(:logger) && ::Rails.logger
+      if defined?(::Rails)
+        ::Rails.logger
+      else
+        nil
+      end
     end
   end
 end

data/lib/mongoid/matchable.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Mongoid
+
+  # This module contains all the behavior for Ruby implementations of MongoDB
+  # selectors.
+  module Matchable
+    extend ActiveSupport::Concern
+
+    # Determines if this document has the attributes to match the supplied
+    # MongoDB selector. Used for matching on embedded associations.
+    #
+    # @example Does the document match?
+    #   document._matches?(:title => { "$in" => [ "test" ] })
+    #
+    # @param [ Hash ] selector The MongoDB selector.
+    #
+    # @return [ true | false ] True if matches, false if not.
+    def _matches?(selector)
+      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