Proof of concept of evolve raw value and "strict" field option

johnnyshields · johnnyshields · commit e9d314b9567c · 2022-07-31T17:42:08.000+09:00
diff --git a/docs/release-notes/mongoid-8.1.txt b/docs/release-notes/mongoid-8.1.txt
@@ -116,3 +116,21 @@ from the ``_translations`` hash:
 
 See the section on :ref:`Localize :present Field Option <present-fields>` for
 more details on how these are used.
+
+
+Support for Passing Raw Values into Queries
+-------------------------------------------
+
+When performing queries, it is now possible skip Mongoid's type coercion logic
+using the ``Mongoid::RawValue`` wrapper class. This can be useful when legacy
+data in the database is of a different type than the field definition.
+
+.. code-block:: ruby
+
+   class Person
+     include Mongoid::Document
+     field :age, type: Integer
+   end
+
+   # Query for the string "42", not the integer 42
+   Person.where(age: Mongoid::RawValue("42"))
diff --git a/lib/mongoid/attributes.rb b/lib/mongoid/attributes.rb
@@ -170,6 +170,8 @@ def write_attribute(name, value)
 
       if attribute_writable?(field_name)
         _assigning do
+          # TODO: remove this
+          # validate_attribute_value(field_name, value)
           localized = fields[field_name].try(:localized?)
           attributes_before_type_cast[name.to_s] = value
           typed_value = typed_value_for(field_name, value)
@@ -358,6 +360,31 @@ def unalias_attribute(name)
 
     private
 
+    # Validates an attribute value as being assignable to the specified field.
+    #
+    # For now, only Hash and Array fields are validated, and the value is
+    # being checked to be of an appropriate type (i.e. either Hash or Array,
+    # respectively, or nil).
+    #
+    # This method takes the name of the field as stored in the document
+    # in the database, not (necessarily) the Ruby method name used to read/write
+    # the said field.
+    #
+    # @param [ String, Symbol ] field_name The name of the field.
+    # @param [ Object ] value The value to be validated.
+    # TODO: remove this
+    # def validate_attribute_value(field_name, value)
+    #   return if value.nil?
+    #   field = fields[field_name]
+    #   return unless field
+    #   validatable_types = [ Hash, Array ]
+    #   if validatable_types.include?(field.type)
+    #     unless value.is_a?(field.type)
+    #       raise Mongoid::Errors::InvalidValue.new(field.type, value.class)
+    #     end
+    #   end
+    # end
+
     def lookup_attribute_presence(name, value)
       if localized_fields.has_key?(name) && value
         value = localized_fields[name].send(:lookup, value)
diff --git a/lib/mongoid/config.rb b/lib/mongoid/config.rb
@@ -70,6 +70,14 @@ module Config
     # existing method.
     option :scope_overwrite_exception, default: false
 
+    # Indicates whether or not to raise an error when attempting
+    # to assign an incompatible type to a field.
+    option :strict_type_assignment, default: false
+
+    # Indicates whether uncastable values from the database should
+    # be returned wrapped by Mongoid::RawValue class.
+    option :wrap_uncastable_values_from_database, default: false
+
     # Use ActiveSupport's time zone in time operations instead of the
     # Ruby default time zone.
     option :use_activesupport_time_zone, default: true
diff --git a/lib/mongoid/criteria/queryable/extensions/array.rb b/lib/mongoid/criteria/queryable/extensions/array.rb
@@ -137,7 +137,7 @@ def evolve(object)
               when ::Array, ::Set
                 object.map { |obj| obj.class.evolve(obj) }
               else
-                object
+                Mongoid::RawValue(object, 'Array')
               end
             end
           end
diff --git a/lib/mongoid/criteria/queryable/selector.rb b/lib/mongoid/criteria/queryable/selector.rb
@@ -150,16 +150,20 @@ def evolve_multi(specs)
         #
         # @return [ Object ] The serialized object.
         def evolve(serializer, value)
-          case value
-          when Hash
-            evolve_hash(serializer, value)
-          when Array
-            evolve_array(serializer, value)
-          when Range
-            value.__evolve_range__(serializer: serializer)
-          else
-            (serializer || value.class).evolve(value)
-          end
+          _value = case value
+                   when Hash
+                     evolve_hash(serializer, value)
+                   when Array
+                     evolve_array(serializer, value)
+                   when Range
+                     value.__evolve_range__(serializer: serializer)
+                   when Mongoid::RawValue
+                     value
+                   else
+                     (serializer || value.class).evolve(value)
+                   end
+          _value = _value.raw_value if _value.is_a?(Mongoid::RawValue)
+          _value
         end
 
         # Evolve a single key selection with array values.
diff --git a/lib/mongoid/extensions.rb b/lib/mongoid/extensions.rb
@@ -48,6 +48,7 @@ def transform_keys
 require "mongoid/extensions/object"
 require "mongoid/extensions/object_id"
 require "mongoid/extensions/range"
+require "mongoid/raw_value"
 require "mongoid/extensions/regexp"
 require "mongoid/extensions/set"
 require "mongoid/extensions/string"
diff --git a/lib/mongoid/extensions/array.rb b/lib/mongoid/extensions/array.rb
@@ -150,6 +150,8 @@ def mongoize(object)
           case object
           when ::Array, ::Set
             object.map(&:mongoize)
+          else
+            Mongoid::RawValue(object, 'Array')
           end
         end
 
diff --git a/lib/mongoid/extensions/big_decimal.rb b/lib/mongoid/extensions/big_decimal.rb
@@ -72,10 +72,14 @@ def mongoize(object)
               BSON::Decimal128.new(object)
             elsif object.numeric?
               BSON::Decimal128.new(object.to_s)
+            else
+              Mongoid::RawValue(object, 'BigDecimal')
             end
           else
             if object.is_a?(BSON::Decimal128) || object.numeric?
               object.to_s
+            else
+              Mongoid::RawValue(object, 'BigDecimal')
             end
           end
         end
diff --git a/lib/mongoid/extensions/binary.rb b/lib/mongoid/extensions/binary.rb
@@ -30,6 +30,7 @@ def mongoize(object)
           case object
           when BSON::Binary then object
           when String, Symbol then BSON::Binary.new(object.to_s)
+          else Mongoid::RawValue(object, 'BSON::Binary')
           end
         end
         alias :demongoize :mongoize
diff --git a/lib/mongoid/extensions/boolean.rb b/lib/mongoid/extensions/boolean.rb
@@ -18,6 +18,8 @@ def mongoize(object)
           true
         elsif object.to_s =~ (/\A(false|f|no|n|off|0|0.0)\z/i)
           false
+        else
+          Mongoid::RawValue(object, 'Boolean')
         end
       end
       alias :demongoize :mongoize
diff --git a/lib/mongoid/extensions/date.rb b/lib/mongoid/extensions/date.rb
@@ -71,12 +71,13 @@ def mongoize(object)
             else
               time = object.__mongoize_time__
             end
+
+            if time.acts_like?(:time)
+              return ::Time.utc(time.year, time.month, time.day)
+            end
           rescue ArgumentError
-            nil
-          end
-          if time.acts_like?(:time)
-            ::Time.utc(time.year, time.month, time.day)
           end
+          Mongoid::RawValue(object, 'Date')
         end
       end
     end
diff --git a/lib/mongoid/extensions/float.rb b/lib/mongoid/extensions/float.rb
@@ -37,9 +37,8 @@ module ClassMethods
         # @return [ Float | nil ] The object mongoized or nil.
         def mongoize(object)
           return if object.blank?
-          if object.numeric?
-            object.to_f
-          end
+          return object.to_f if object.numeric?
+          Mongoid::RawValue(object, 'Date')
         end
         alias :demongoize :mongoize
       end
diff --git a/lib/mongoid/extensions/hash.rb b/lib/mongoid/extensions/hash.rb
@@ -220,12 +220,11 @@ module ClassMethods
         # @return [ Hash | nil ] The object mongoized or nil.
         def mongoize(object)
           return if object.nil?
-          if object.is_a?(Hash)
-            # Need to use transform_values! which maintains the BSON::Document
-            # instead of transform_values which always returns a hash. To do this,
-            # we first need to dup the hash.
-            object.dup.transform_values!(&:mongoize)
-          end
+          # Need to use transform_values! which maintains the BSON::Document
+          # instead of transform_values which always returns a hash. To do this,
+          # we first need to dup the hash.
+          return object.dup.transform_values!(&:mongoize) if object.is_a?(Hash)
+          Mongoid::RawValue(object, 'Hash')
         end
 
         # Can the size of this object change?
diff --git a/lib/mongoid/extensions/integer.rb b/lib/mongoid/extensions/integer.rb
@@ -45,9 +45,8 @@ module ClassMethods
         # @return [ Integer | nil ] The object mongoized or nil.
         def mongoize(object)
           return if object.blank?
-          if object.numeric?
-            object.to_i
-          end
+          return object.to_i if object.numeric?
+          Mongoid::RawValue(object, 'Integer')
         end
         alias :demongoize :mongoize
       end
diff --git a/lib/mongoid/extensions/range.rb b/lib/mongoid/extensions/range.rb
@@ -77,6 +77,7 @@ def mongoize(object)
           case object
           when Hash then __mongoize_hash__(object)
           when Range then __mongoize_range__(object)
+          else Mongoid::RawValue(object, 'Range')
           end
         end
 
diff --git a/lib/mongoid/extensions/regexp.rb b/lib/mongoid/extensions/regexp.rb
@@ -17,13 +17,15 @@ module ClassMethods
         # @return [ Regexp | nil ] The object mongoized or nil.
         def mongoize(object)
           return if object.nil?
-          case object
-          when String then ::Regexp.new(object)
-          when ::Regexp then object
-          when BSON::Regexp::Raw then object.compile
+          begin
+            case object
+            when String then ::Regexp.new(object)
+            when ::Regexp then object
+            when BSON::Regexp::Raw then object.compile
+            end
+          rescue RegexpError
           end
-        rescue RegexpError
-          nil
+          Mongoid::RawValue(object, 'Regexp')
         end
         alias :demongoize :mongoize
       end
diff --git a/lib/mongoid/extensions/set.rb b/lib/mongoid/extensions/set.rb
@@ -46,6 +46,7 @@ def mongoize(object)
           case object
           when ::Set then ::Array.mongoize(object.to_a).uniq
           when ::Array then ::Array.mongoize(object).uniq
+          else Mongoid::RawValue(object, 'Set')
           end
         end
       end
diff --git a/lib/mongoid/extensions/string.rb b/lib/mongoid/extensions/string.rb
@@ -159,7 +159,9 @@ module ClassMethods
         #
         # @return [ String ] The object mongoized.
         def mongoize(object)
-          object.try(:to_s)
+          return if object.nil?
+          return object.to_s if object.respond_to?(:to_s)
+          Mongoid::RawValue.new(object, 'String')
         end
         alias :demongoize :mongoize
       end
diff --git a/lib/mongoid/extensions/symbol.rb b/lib/mongoid/extensions/symbol.rb
@@ -26,7 +26,9 @@ module ClassMethods
         #
         # @return [ Symbol | nil ] The object mongoized or nil.
         def mongoize(object)
-          object.try(:to_sym)
+          return if object.nil?
+          return object.to_sym if object.respond_to?(:to_sym)
+          Mongoid::RawValue.new(object, 'Symbol')
         end
         alias :demongoize :mongoize
       end
diff --git a/lib/mongoid/extensions/time.rb b/lib/mongoid/extensions/time.rb
@@ -82,19 +82,18 @@ def mongoize(object)
           return if object.blank?
           begin
             time = object.__mongoize_time__
-          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)
-              ::Time.at(time.to_i, time.subsec * 10**6).utc
-            else
-              ::Time.at(time.to_i, time.usec).utc
+            if time.acts_like?(:time)
+              if object.respond_to?(:sec_fraction)
+                return ::Time.at(time.to_i, object.sec_fraction * 10**6).utc
+              elsif time.respond_to?(:subsec)
+                return ::Time.at(time.to_i, time.subsec * 10**6).utc
+              else
+                return ::Time.at(time.to_i, time.usec).utc
+              end
             end
+          rescue ArgumentError
           end
+          Mongoid::RawValue.new(object, 'Time')
         end
       end
     end
diff --git a/lib/mongoid/fields/localized.rb b/lib/mongoid/fields/localized.rb
@@ -48,7 +48,7 @@ def localize_present?
       #
       # @return [ Hash ] The locale with string translation.
       def mongoize(object)
-        { ::I18n.locale.to_s => type.mongoize(object) }
+        { ::I18n.locale.to_s => super(object) }
       end
 
       private
diff --git a/lib/mongoid/fields/standard.rb b/lib/mongoid/fields/standard.rb
@@ -9,7 +9,32 @@ class Standard
       # Set readers for the instance variables.
       attr_accessor :default_val, :label, :name, :options
 
-      def_delegators :type, :demongoize, :evolve, :mongoize
+      # If type.mongoize returns Mongoid::RawValue,
+      # handle according to field or global strict setting
+      def mongoize(object)
+        value = type.mongoize(object)
+        if value.is_a?(Mongoid::RawValue)
+          case strict
+          when :error then value.raise_error!
+          when :warn then value.warn and return nil
+          when :suppress then return nil
+          # when :defer, assign the Mongoid::RawValue and fail when trying to persist.
+          end
+        end
+        value
+      end
+
+      # If type.demongoize returns Mongoid::RawValue,
+      # return the inner value according to Mongoid.wrap_uncastable_values_from_database
+      def demongoize(object)
+        value = type.demongoize(object)
+        if value.is_a?(Mongoid::RawValue) && !Mongoid.wrap_uncastable_values_from_database
+          return value.raw_value
+        end
+        value
+      end
+
+      def_delegators :type, :evolve
 
       # Adds the atomic changes for this type of resizable field.
       #
@@ -107,6 +132,29 @@ def localize_present?
         false
       end
 
+      # Whether or not the field raises an error if a non-castable
+      # type is assignment.
+      #
+      # @example Get the type.
+      #   field.type
+      #
+      # @return [ :error | :warn | :suppress ] The value. True means raise
+      #   an error. False means handle as nil.
+      def strict
+        return @strict if defined?(@strict)
+        if options.key?(:strict)
+          @strict = case options[:strict]
+                    when true, :error then :error
+                    when false, :suppress then :suppress
+                    when :warn then :warn
+                    end
+        end
+        # TODO: add default. Array/Hash should be strict.
+        # Also consider global
+        # Don't memoize default?
+        # Support warn option
+      end
+
       # Get the metadata for the field if its a foreign key.
       #
       # @example Get the metadata.
diff --git a/lib/mongoid/fields/validators/macro.rb b/lib/mongoid/fields/validators/macro.rb
@@ -17,6 +17,7 @@ module Macro
           :fallbacks,
           :association,
           :pre_processed,
+          :strict,
           :subtype,
           :type,
           :overwrite
diff --git a/lib/mongoid/raw_value.rb b/lib/mongoid/raw_value.rb
diff --git a/lib/mongoid/stringified_symbol.rb b/lib/mongoid/stringified_symbol.rb
