MONGOID-5222 always return nil on mongoize

Author: neilshweky

docs/reference/configuration.txt

@@ -434,11 +434,6 @@ for details on driver options.
       # (default: false)
       use_utc: false
 
-      # Raise an error on the assignment of a value that cannot be cast to
-      # the assigning field type. If this flag is off, no error will be raised
-      # and nil will be written.
-      validate_attribute_types: true
-
       # (Deprecated) In MongoDB 4.0 and earlier, set whether to create
       # indexes in the background by default. (default: false)
       background_indexing: false

docs/reference/fields.txt

@@ -847,14 +847,13 @@ coerced to the type of the field. For example:
   User.new(name: [ "hello" ])
 
 Assigning an array to a field of type Integer doesn't work since an array can't
-be coerced to an Integer. To deal with this case, Mongoid has introduced the
-``validate_attribute_types`` flag.
+be coerced to an Integer. The assignment of uncastable values to a field will
+cause a ``nil`` to be written:
 
-When the ``validate_attribute_types`` flag is turned on, the assignment of uncastable
-values to a field will cause a ``Mongoid::Errors::InvalidValue`` exception being raised.
+.. code::
 
-When the ``validate_attribute_types`` flag is turned off, the assignment of uncastable
-values to a field will cause a ``nil`` to be written.
+  User.new(name: [ "hello" ])
+  # => #<User _id: 62b222d43282a47bf73e3264, name: nil>
 
 
 .. _customizing-field-behavior:
@@ -1009,11 +1008,9 @@ setter methods for fields of your custom type.
 
 .. note::
 
-  The ``mongoize`` method should raise a ``Mongoid::Errors::InvalidValue`` on values that
-  are uncastable to your custom type. Mongoid will handle rescuing that error
-  and writing ``nil`` if the ``validate_attribute_types`` flag is turned off.
-  See the secion on :ref:`Uncastable Values <uncastable-values>` for more
-  details.
+  The ``mongoize`` method should return ``nil`` on values that are uncastable to
+  your custom type. See the secion on :ref:`Uncastable Values <uncastable-values>`
+  for more details.
 
 The class method ``demongoize`` does the inverse of ``mongoize``. It takes the raw object
 from the MongoDB Ruby driver and converts it to an instance of your custom type.

docs/release-notes/mongoid-8.0.txt

@@ -57,14 +57,12 @@ changed in Mongoid 8.0:
 Please refer to :ref:`configuration option <configuration-options>` for
 the description and effects of each of these options.
 
-Storing Uncastable Types and the ``validate_attribute_types`` Flag
-------------------------------------------------------------------
+Storing Uncastable Value
+------------------------
 
-In Mongoid 8, Mongoid deals with "uncastable values" based on the values of the
-``validates_attribute_types`` flag. If the ``validates_attribute_types`` flag
-is set to true, a ``Mongoid:Errors::InvalidValue`` exception is raised, and if it is set to false
-a ``nil`` is written. See the secion on :ref:`Uncastable Values <uncastable-values>`
-for more details.
+In Mongoid 8, Mongoid standardizes the storing of "uncastable values." On
+attempting to write an uncastable value, a ``nil`` is written instead. See the
+secion on :ref:`Uncastable Values <uncastable-values>` for more details.
 
 Some ``mongoize`` methods were also changed to perform consistently with rails
 and the other mongoize methods. The following is a table of the changes in
@@ -73,18 +71,18 @@ functionality:
 +--------------+------------------------+------------------------+-------------------+
 | Field Type   | Situation              | Previous Functionality | New Functionality |
 +==============+========================+========================+===================+
-| Boolean      | When a non-boolean     | return ``false``       | return ``nil`` or |
-|              | string is assigned:    |                        | raise             |
-|              | "bogus value"          |                        | ``InvalidError``  |
+| Boolean      | When a non-boolean     | return ``false``       | return ``nil``    |
+|              | string is assigned:    |                        |                   |
+|              | "bogus value"          |                        |                   |
 +--------------+------------------------+------------------------+-------------------+
-| Symbol       | When a value that does | return ``nil``         | return ``nil`` or |
-|              | not respond to         |                        | raise             |
-|              | ``to_sym`` is          |                        | ``InvalidError``  |
+| Symbol       | When a value that does | return ``nil``         | return ``nil``    |
+|              | not respond to         |                        |                   |
+|              | ``to_sym`` is          |                        |                   |
 |              | assigned: ``[]``       |                        |                   |
 +--------------+------------------------+------------------------+-------------------+
-| All Other    | When an uncastable     | undefined behavior,    | return ``nil`` or |
-| Types        | value is assigned      | occasionally raises    | raise             |
-|              |                        | ``NoMethodError``      | ``InvalidError``  |
+| All Other    | When an uncastable     | undefined behavior,    | return ``nil``    |
+| Types        | value is assigned      | occasionally raises    |                   |
+|              |                        | ``NoMethodError``      |                   |
 +--------------+------------------------+------------------------+-------------------+
 
 

lib/config/locales/en.yml

@@ -375,8 +375,7 @@ en:
         invalid_value:
           message: "The value %{value} cannot be written to a field of type %{field_class}."
           summary: "The value %{value} could not be coerced to type %{field_class}."
-          resolution: "Verify that the value to be set corresponds to the field definition,
-            or turn off the Mongoid.validate_attribute_types flag to have nil written."
+          resolution: "Verify that the value to be set corresponds to the field definition."
         mixed_relations:
           message: "Referencing a(n) %{embedded} document from the %{root}
             document via a non-embedded association is not allowed since the

lib/mongoid/attributes.rb

@@ -172,17 +172,7 @@ def write_attribute(name, value)
         _assigning do
           localized = fields[field_name].try(:localized?)
           attributes_before_type_cast[name.to_s] = value
-
-          typed_value = if Mongoid.validate_attribute_types
-            typed_value_for(field_name, value)
-          else
-            begin
-              typed_value_for(field_name, value)
-            rescue Errors::InvalidValue
-              nil
-            end
-          end
-
+          typed_value = typed_value_for(field_name, value)
           unless attributes[field_name] == typed_value || attribute_changed?(field_name)
             attribute_will_change!(field_name)
           end

lib/mongoid/config.rb

@@ -125,13 +125,6 @@ module Config
     # always return a Hash.
     option :legacy_attributes, default: false
 
-    # When this flag is true, Mongoid will validate the type of the value
-    # assigned to a field, such that it can be coerced to a value of the field
-    # type. If it is "uncastable," an InvalidValue error will be raised. If this
-    # feature flag is off, nil will be written to the attribute and the database
-    # on save.
-    option :validate_attribute_types, default: true
-
     # Has Mongoid been configured? This is checking that at least a valid
     # client config exists.
     #

lib/mongoid/extensions/array.rb

@@ -144,15 +144,11 @@ def __mongoize_fk__(association, object)
         #
         # @param [ Object ] object The object to mongoize.
         #
-        # @raise [ Errors::InvalidValue ] if the value is uncastable.
-        #
         # @return [ Array | nil ] The object mongoized or nil.
         def mongoize(object)
           return if object.nil?
           if object.is_a?(::Array)
             evolve(object).collect{ |obj| obj.class.mongoize(obj) }
-          else
-            raise Errors::InvalidValue.new(self, object)
           end
         end
 

lib/mongoid/extensions/big_decimal.rb

@@ -62,8 +62,6 @@ def demongoize(object)
         #
         # @param [ Object ] object The object to Mongoize
         #
-        # @raise [ Errors::InvalidValue ] if the value is uncastable.
-        #
         # @return [ String | BSON::Decimal128 | nil ] A String or Decimal128
         #   representing the object or nil. String if Mongoid.map_big_decimal_to_decimal128
         #   is false, BSON::Decimal128 otherwise.
@@ -84,10 +82,6 @@ def mongoize(object)
             elsif object.numeric?
               object.to_d.to_s
             end
-          end.tap do |res|
-            if res.nil?
-              raise Errors::InvalidValue.new(self, object)
-            end
           end
         end
       end

lib/mongoid/extensions/binary.rb

@@ -24,15 +24,12 @@ module ClassMethods
         #
         # @param [ Object ] object The object to Mongoize
         #
-        # @raise [ Errors::InvalidValue ] if the value is uncastable.
-        #
         # @return [ BSON::Binary | nil ] A Binary representing the object or nil.
         def mongoize(object)
           return if object.nil?
           case object
           when BSON::Binary then object
           when String, Symbol then BSON::Binary.new(object.to_s)
-          else raise Errors::InvalidValue.new(self, object)
           end
         end
       end

lib/mongoid/extensions/boolean.rb

@@ -11,17 +11,13 @@ class << self
       # @example Mongoize the object.
       #   Boolean.mongoize("123.11")
       #
-      # @raise [ Errors::InvalidValue ] if the value is uncastable.
-      #
       # @return [ true | false | nil ] The object mongoized or nil.
       def mongoize(object)
         return if object.nil?
         if object.to_s =~ (/\A(true|t|yes|y|on|1|1.0)\z/i)
           true
         elsif object.to_s =~ (/\A(false|f|no|n|off|0|0.0)\z/i)
           false
-        else
-          raise Errors::InvalidValue.new(self, object)
         end
       end
     end