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

Author: johnnyshields

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"))

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)

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

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

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.

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"

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
 

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

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

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