mongoid 7.2.1 → 9.0.0

data/lib/mongoid/extensions/time.rb

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
-# encoding: utf-8
+# rubocop:todo all
 
 module Mongoid
   module Extensions
+
+    # Adds type-casting behavior to Time class.
     module Time
 
       # Mongoizes a Time into a time.
@@ -11,46 +13,23 @@ module Mongoid
       # (which are themselves).
       #
       # @return [ Time ] self.
-      #
-      # @since 3.0.0
       def __mongoize_time__
         self
       end
 
-      # Constant for epoch - used when passing invalid times.
-      #
-      # @deprecated No longer used as a return value from #mongoize passed
-      #   an invalid time string.
-      EPOCH = ::Time.utc(1970, 1, 1, 0, 0, 0)
-
       # Turn the object from the ruby type we deal with to a Mongo friendly
       # type.
       #
       # @example Mongoize the object.
       #   time.mongoize
       #
-      # @return [ Time ] The object mongoized.
-      #
-      # @since 3.0.0
+      # @return [ Time | nil ] The object mongoized or nil.
       def mongoize
         ::Time.mongoize(self)
       end
 
       module ClassMethods
 
-        # Get the configured time to use when converting - either the time zone
-        # or the time.
-        #
-        # @example Get the configured time.
-        #   ::Time.configured
-        #
-        # @return [ Time ] The configured time.
-        #
-        # @since 3.0.0
-        def configured
-          Mongoid.use_activesupport_time_zone? ? (::Time.zone || ::Time) : ::Time
-        end
-
         # Convert the object from its mongo friendly ruby type to this type.
         #
         # @example Demongoize the object.
@@ -58,16 +37,26 @@ module Mongoid
         #
         # @param [ Time ] object The time from Mongo.
         #
-        # @return [ Time ] The object as a date.
-        #
-        # @since 3.0.0
+        # @return [ Time | nil ] The object as a time.
         def demongoize(object)
-          return nil if object.blank?
-          object = object.getlocal unless Mongoid::Config.use_utc?
-          if Mongoid::Config.use_activesupport_time_zone?
-            object = object.in_time_zone(Mongoid.time_zone)
+          return if object.blank?
+          time = if object.acts_like?(:time)
+            Mongoid::Config.use_utc? ? object : object.getlocal
+          elsif object.acts_like?(:date)
+            ::Date.demongoize(object).to_time
+          elsif object.is_a?(String)
+            begin
+              object.__mongoize_time__
+            rescue ArgumentError
+              nil
+            end
+          elsif object.is_a?(BSON::Timestamp)
+            ::Time.at(object.seconds)
           end
-          object
+
+          return if time.nil?
+
+          time.in_time_zone(Mongoid.time_zone)
         end
 
         # Turn the object from the ruby type we deal with to a Mongo friendly
@@ -78,13 +67,16 @@ module Mongoid
         #
         # @param [ Object ] object The object to mongoize.
         #
-        # @return [ Time ] The object mongoized.
-        #
-        # @since 3.0.0
+        # @return [ Time | nil ] The object mongoized or nil.
         def mongoize(object)
-          return nil if object.blank?
+          return if object.blank?
           begin
-            time = object.__mongoize_time__
+            time = object.respond_to?(:__mongoize_time__) ? object.__mongoize_time__ : nil
+          rescue ArgumentError
+            return
+          end
+
+          if time.acts_like?(:time)
             if object.respond_to?(:sec_fraction)
               ::Time.at(time.to_i, object.sec_fraction * 10**6).utc
             elsif time.respond_to?(:subsec)
@@ -92,8 +84,6 @@ module Mongoid
             else
               ::Time.at(time.to_i, time.usec).utc
             end
-          rescue ArgumentError
-            nil
           end
         end
       end

data/lib/mongoid/extensions/time_with_zone.rb

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
-# encoding: utf-8
+# rubocop:todo all
 
 module Mongoid
   module Extensions
+
+    # Adds type-casting behavior to ActiveSupport::TimeWithZone class.
     module TimeWithZone
 
       # Mongoizes an ActiveSupport::TimeWithZone into a time.
@@ -11,8 +13,6 @@ module Mongoid
       # (which are themselves).
       #
       # @return [ ActiveSupport::TimeWithZone ] self.
-      #
-      # @since 3.0.0
       def __mongoize_time__
         self
       end
@@ -24,12 +24,24 @@ module Mongoid
       #   date_time.mongoize
       #
       # @return [ Time ] The object mongoized.
-      #
-      # @since 3.0.0
       def mongoize
         ::ActiveSupport::TimeWithZone.mongoize(self)
       end
 
+      # This code is copied from Time class extension in bson-ruby gem. It
+      # should be removed from here when the minimum BSON version is 5+.
+      # See https://jira.mongodb.org/browse/MONGOID-5491.
+      def _bson_to_i
+        return super if defined?(super)
+        # Workaround for JRuby's #to_i rounding negative timestamps up
+        # rather than down (https://github.com/jruby/jruby/issues/6104)
+        if BSON::Environment.jruby?
+          (self - usec.to_r/1000000).to_i
+        else
+          to_i
+        end
+      end
+
       module ClassMethods
 
         # Convert the object from its mongo friendly ruby type to this type.
@@ -40,11 +52,8 @@ module Mongoid
         # @param [ Time ] object The time from Mongo.
         #
         # @return [ TimeWithZone ] The object as a date.
-        #
-        # @since 3.0.0
         def demongoize(object)
-          return nil if object.blank?
-          ::Time.demongoize(object).in_time_zone
+          ::Time.demongoize(object).try(:in_time_zone)
         end
 
         # Turn the object from the ruby type we deal with to a Mongo friendly
@@ -56,8 +65,6 @@ module Mongoid
         # @param [ Object ] object The object to convert.
         #
         # @return [ Time ] The object mongoized.
-        #
-        # @since 3.0.0
         def mongoize(object)
           ::Time.mongoize(object)
         end

data/lib/mongoid/extensions/true_class.rb

@@ -1,21 +1,21 @@
 # frozen_string_literal: true
-# encoding: utf-8
+# rubocop:todo all
 
 module Mongoid
   module Extensions
+    # Adds type-casting behavior to TrueClass
     module TrueClass
-
-      # Get the value of the object as a mongo friendy sort value.
+      # Get the value of the object as a mongo friendly sort value.
       #
       # @example Get the object as sort criteria.
       #   object.__sortable__
       #
       # @return [ Integer ] 1.
-      #
-      # @since 3.0.0
+      # @deprecated
       def __sortable__
         1
       end
+      Mongoid.deprecate(self, :__sortable__)
 
       # Is the passed value a boolean?
       #
@@ -24,11 +24,9 @@ module Mongoid
       #
       # @param [ Class ] other The class to check.
       #
-      # @return [ true, false ] If the other is a boolean.
-      #
-      # @since 1.0.0
+      # @return [ true | false ] If the other is a boolean.
       def is_a?(other)
-        if other == ::Boolean || other.class == ::Boolean
+        if other == Mongoid::Boolean || other.class == Mongoid::Boolean
           return true
         end
         super(other)
@@ -37,4 +35,4 @@ module Mongoid
   end
 end
 
-::TrueClass.__send__(:include, Mongoid::Extensions::TrueClass)
+TrueClass.include Mongoid::Extensions::TrueClass

data/lib/mongoid/extensions.rb

@@ -1,27 +1,9 @@
 # frozen_string_literal: true
-# encoding: utf-8
-
-class BSON::ObjectId
-  def as_json(options = nil)
-    { "$oid" => to_s }
-  end
-end
-
-class BSON::Document
-  # We need to override this as ActiveSupport creates a new Object, instead of a new Hash
-  # see https://github.com/rails/rails/commit/f1bad130d0c9bd77c94e43b696adca56c46a66aa
-  def transform_keys
-    return enum_for(:transform_keys) unless block_given?
-    result = {}
-    each_key do |key|
-      result[yield(key)] = self[key]
-    end
-    result
-  end
-end
+# rubocop:todo all
 
 require "mongoid/extensions/array"
 require "mongoid/extensions/big_decimal"
+require "mongoid/extensions/binary"
 require "mongoid/extensions/boolean"
 require "mongoid/extensions/date"
 require "mongoid/extensions/date_time"
@@ -35,6 +17,7 @@ require "mongoid/extensions/nil_class"
 require "mongoid/extensions/object"
 require "mongoid/extensions/object_id"
 require "mongoid/extensions/range"
+require "mongoid/extensions/raw_value"
 require "mongoid/extensions/regexp"
 require "mongoid/extensions/set"
 require "mongoid/extensions/string"

data/lib/mongoid/factory.rb

@@ -1,18 +1,140 @@
 # frozen_string_literal: true
-# encoding: utf-8
 
 module Mongoid
-
   # Instantiates documents that came from the database.
   module Factory
     extend self
 
-    # @deprecated
-    TYPE = "_type".freeze
+    # A helper class for instantiating a model using either it's type
+    # class directly, or via a type class specified via a discriminator
+    # key.
+    #
+    # @api private
+    class Instantiator
+      # @return [ Mongoid::Document ] The primary model class being referenced
+      attr_reader :klass
+
+      # @return [ Hash | nil ] The Hash of attributes to use when
+      #   instantiating the model.
+      attr_reader :attributes
+
+      # @return [ Mongoid::Criteria | nil ] The criteria object to
+      #   use as a secondary source for the selected fields; also used when
+      #   setting the inverse association.
+      attr_reader :criteria
+
+      # @return [ Array | nil ] The list of field names that should
+      #   be explicitly (and exclusively) included in the new record.
+      attr_reader :selected_fields
+
+      # @return [ String | nil ] The identifier of the class that
+      #   should be loaded and instantiated, in the case of a polymorphic
+      #   class specification.
+      attr_reader :type
+
+      # Creates a new Factory::Initiator.
+      #
+      # @param klass [ Mongoid::Document ] The primary class to reference when
+      #   instantiating the model.
+      # @param attributes [ Hash | nil ] (Optional) The hash of attributes to
+      #   use when instantiating the model.
+      # @param criteria [ Mongoid::Criteria | nil ] (Optional) The criteria
+      #   object to use as a secondary source for the selected fields; also
+      #   used when setting the inverse association.
+      # @param selected_fields [ Array | nil ] The list of field names that
+      #   should be explicitly (and exclusively) included in the new record.
+      def initialize(klass, attributes, criteria, selected_fields)
+        @klass = klass
+        @attributes = attributes
+        @criteria = criteria
+        @selected_fields = selected_fields ||
+                           (criteria && criteria.options[:fields])
+        @type = attributes && attributes[klass.discriminator_key]
+      end
+
+      # Builds and returns a new instance of the requested class.
+      #
+      # @param execute_callbacks [ true | false ] Whether or not the Document
+      #   callbacks should be invoked with the new instance.
+      #
+      # @raise [ Errors::UnknownModel ] when the requested type does not exist,
+      #   or if it does not respond to the `instantiate` method.
+      #
+      # @return [ Mongoid::Document ] The new document instance.
+      def instance(execute_callbacks: Threaded.execute_callbacks?)
+        if type.blank?
+          instantiate_without_type(execute_callbacks)
+        else
+          instantiate_with_type(execute_callbacks)
+        end
+      end
+
+      private
+
+      # Instantiate the given class without any given subclass.
+      #
+      # @param [ true | false ] execute_callbacks Whether this method should
+      #   invoke document callbacks.
+      #
+      # @return [ Document ] The instantiated document.
+      def instantiate_without_type(execute_callbacks)
+        klass.instantiate_document(attributes, selected_fields, execute_callbacks: execute_callbacks).tap do |obj|
+          if criteria&.association && criteria&.parent_document
+            obj.set_relation(criteria.association.inverse, criteria.parent_document)
+          end
+        end
+      end
+
+      # Instantiate the given `type`, which must map to another Mongoid::Document
+      # model.
+      #
+      # @param [ true | false ] execute_callbacks Whether this method should
+      #   invoke document callbacks.
+      #
+      # @return [ Document ] The instantiated document.
+      def instantiate_with_type(execute_callbacks)
+        constantized_type.instantiate_document(
+          attributes, selected_fields,
+          execute_callbacks: execute_callbacks
+        )
+      end
+
+      # Retreive the `Class` instance of the requested type, either by finding it
+      # in the `klass` discriminator mapping, or by otherwise finding a
+      # Document model with the given name.
+      #
+      # @return [ Mongoid::Document ] the requested Document model
+      def constantized_type
+        @constantized_type ||= begin
+          constantized = klass.get_discriminator_mapping(type) || constantize(type)
+
+          # Check if the class is a Document class
+          raise Errors::UnknownModel.new(camelized, type) unless constantized.respond_to?(:instantiate)
+
+          constantized
+        end
+      end
+
+      # Attempts to convert the argument into a Class object by camelizing
+      # it and treating the result as the name of a constant.
+      #
+      # @param type [ String ] The name of the type to constantize
+      #
+      # @raise [ Errors::UnknownModel ] if the argument does not correspond to
+      #   an existing constant.
+      #
+      # @return [ Class ] the Class that the type resolves to
+      def constantize(type)
+        camelized = type.camelize
+        camelized.constantize
+      rescue NameError
+        raise Errors::UnknownModel.new(camelized, type)
+      end
+    end
 
     # Builds a new +Document+ from the supplied attributes.
     #
-    # This method either instantiats klass or a descendant of klass if the attributes include
+    # This method either instantiates klass or a descendant of klass if the attributes include
     # klass' discriminator key.
     #
     # If the attributes contain the discriminator key (which is _type by default) and the
@@ -25,15 +147,39 @@ module Mongoid
     # @param [ Class ] klass The class to instantiate from if _type is not present.
     # @param [ Hash ] attributes The document attributes.
     #
+    # @option options [ true | false ] :execute_callbacks Flag specifies whether callbacks
+    #   should be run.
+    #
     # @return [ Document ] The instantiated document.
     def build(klass, attributes = nil)
+      execute_build(klass, attributes)
+    end
+
+    # Execute the build.
+    #
+    # @param [ Class ] klass The class to instantiate from if _type is not present.
+    # @param [ Hash ] attributes The document attributes.
+    # @param [ Hash ] options The options to use.
+    #
+    # @option options [ true | false ] :execute_callbacks Flag specifies
+    #   whether callbacks should be run.
+    #
+    # @note A Ruby 2.x bug prevents the options hash from being keyword
+    #   arguments. Once we drop support for Ruby 2.x, we can reimplement
+    #   the options hash as keyword arguments.
+    #   See https://bugs.ruby-lang.org/issues/15753
+    #
+    # @return [ Document ] The instantiated document.
+    #
+    # @api private
+    def execute_build(klass, attributes = nil, options = {})
       attributes ||= {}
       dvalue = attributes[klass.discriminator_key] || attributes[klass.discriminator_key.to_sym]
       type = klass.get_discriminator_mapping(dvalue)
       if type
-        type.new(attributes)
+        type.construct_document(attributes, options)
       else
-        klass.new(attributes)
+        klass.construct_document(attributes, options)
       end
     end
 
@@ -64,37 +210,32 @@ module Mongoid
     #
     # @return [ Document ] The instantiated document.
     def from_db(klass, attributes = nil, criteria = nil, selected_fields = nil)
-      if criteria
-        selected_fields ||= criteria.options[:fields]
-      end
-      type = (attributes || {})[klass.discriminator_key]
-      if type.blank?
-        obj = klass.instantiate(attributes, selected_fields)
-        if criteria && criteria.association && criteria.parent_document
-          obj.set_relation(criteria.association.inverse, criteria.parent_document)
-        end
-        obj
-      else
-        constantized = klass.get_discriminator_mapping(type)
-
-        unless constantized
-          camelized = type.camelize
-
-          # Check if the class exists
-          begin
-            constantized = camelized.constantize
-          rescue NameError
-            raise Errors::UnknownModel.new(camelized, type)
-          end
-        end
-
-        # Check if the class is a Document class
-        if !constantized.respond_to?(:instantiate)
-          raise Errors::UnknownModel.new(camelized, type)
-        end
+      execute_from_db(klass, attributes, criteria, selected_fields)
+    end
 
-        constantized.instantiate(attributes, selected_fields)
-      end
+    # Execute from_db.
+    #
+    # @param [ Class ] klass The class to instantiate from if _type is not present.
+    # @param [ Hash ] attributes The document attributes.
+    # @param [ Criteria ] criteria Optional criteria object.
+    # @param [ Hash ] selected_fields Fields which were retrieved via
+    #   #only. If selected_fields are specified, fields not listed in it
+    #   will not be accessible in the returned document.
+    # @param [ true | false ] execute_callbacks Whether this method should
+    #   invoke the callbacks. If true, the callbacks will be invoked normally.
+    #   If false, the callbacks will be stored in the +pending_callbacks+ list
+    #   and caller is responsible for invoking +run_pending_callbacks+ at a
+    #   later time. Use this option to defer callback execution until the
+    #   entire object graph containing embedded associations is constructed.
+    #
+    # @return [ Document ] The instantiated document.
+    #
+    # @api private
+    def execute_from_db(klass, attributes = nil, criteria = nil,
+                        selected_fields = nil,
+                        execute_callbacks: Threaded.execute_callbacks?)
+      Instantiator.new(klass, attributes, criteria, selected_fields)
+                  .instance(execute_callbacks: execute_callbacks)
     end
   end
 end

data/lib/mongoid/fields/encrypted.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+# rubocop:todo all
+
+module Mongoid
+  module Fields
+    # Represents a field that should be encrypted.
+    class Encrypted < Standard
+      def initialize(name, options = {})
+        @encryption_options = if options[:encrypt].is_a?(Hash)
+                                options[:encrypt]
+                              else
+                                {}
+                              end
+        super
+      end
+
+      # @return [ true | false | nil ] Whether the field should be encrypted using a
+      #   deterministic encryption algorithm; if not specified, nil is returned.
+      def deterministic?
+        @encryption_options[:deterministic]
+      end
+
+      # @return [ String | nil ] The key id to use for encryption; if not specified,
+      #   nil is returned.
+      def key_id
+        @encryption_options[:key_id]
+      end
+
+      # @return [ String | nil ] The name of the field that contains the
+      #   key alt name to use for encryption; if not specified, nil is returned.
+      def key_name_field
+        @encryption_options[:key_name_field]
+      end
+
+      # Override the key_id for the field.
+      #
+      # This method is solely for testing purposes and should not be used in
+      # the application code. The schema_map is generated very early in the
+      # application lifecycle, and overriding the key_id after that will not
+      # have any effect.
+      #
+      # @api private
+      def set_key_id(key_id)
+        @encryption_options[:key_id] = key_id
+      end
+    end
+  end
+end