activemodel 6.1.4.1 → 7.0.0.rc2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 62a6b320265b9ce1fe4dd2857f6cf0075d4d7c5bce68abb1141886e051742794
-  data.tar.gz: 2f289a20c36b6aa3de45bbbb7dafb2a954571960b2737b3846f388d34f407778
+  metadata.gz: 9079e5f5b6e97cb434d3d881df63a462deaa5d76f4a903404a80a6fb352a4a34
+  data.tar.gz: 324766119f9caa91770f1948700d4085aad8a9814a2265d0a19a12a65ba040ec
 SHA512:
-  metadata.gz: 187066c2525c7a9b8d79194171296ec0a6c1e7094d9773a682b53807b92b024a53fc9814fff4470bdf6443519b969855bff0477a8b2f9bc246a24fbfe2beb8a6
-  data.tar.gz: 3edb340b99eb9a61623c38fe7d924c8629f4b477ef52c708b383debda325ad7130a9243b4e078d61a48864d70ecad095ad3265e8fbc1e6314db82e6d97a7c889
+  metadata.gz: 00dd34e112e676941a1c7a25d615dba688803f35dcd2c1fd71fc094490e26081d978728acb309d5cf588be6bcfaa22502017a2f058d33d83a09a35ac7f09d475
+  data.tar.gz: 24b905c955a57deb86c34ba76527f5f9ba7bc1b262825613db904b3d5abf189e463d131219217bbff3ce5ff452b60642886df6c50c8e4f11a3149cf3ebcac5df

data/CHANGELOG.md

@@ -1,117 +1,128 @@
-## Rails 6.1.4.1 (August 19, 2021) ##
+## Rails 7.0.0.rc2 (December 14, 2021) ##
 
-*   No changes.
+*   Remove support to Marshal load Rails 5.x `ActiveModel::AttributeSet` format.
 
+    *Rafael Mendonça França*
 
-## Rails 6.1.4 (June 24, 2021) ##
+*   Remove support to Marshal and YAML load Rails 5.x error format.
 
-*   Fix `to_json` for `ActiveModel::Dirty` object.
+    *Rafael Mendonça França*
 
-    Exclude +mutations_from_database+ attribute from json as it lead to recursion.
+*   Remove deprecated support to use `[]=` in `ActiveModel::Errors#messages`.
 
-    *Anil Maurya*
+    *Rafael Mendonça França*
 
+*   Remove deprecated support to `delete` errors from `ActiveModel::Errors#messages`.
 
-## Rails 6.1.3.2 (May 05, 2021) ##
+    *Rafael Mendonça França*
 
-*   No changes.
+*   Remove deprecated support to `clear` errors from `ActiveModel::Errors#messages`.
 
+    *Rafael Mendonça França*
 
-## Rails 6.1.3.1 (March 26, 2021) ##
+*   Remove deprecated support concat errors to `ActiveModel::Errors#messages`.
 
-*   No changes.
+    *Rafael Mendonça França*
 
+*   Remove deprecated `ActiveModel::Errors#to_xml`.
 
-## Rails 6.1.3 (February 17, 2021) ##
+    *Rafael Mendonça França*
 
-*   No changes.
+*   Remove deprecated `ActiveModel::Errors#keys`.
 
+    *Rafael Mendonça França*
 
-## Rails 6.1.2.1 (February 10, 2021) ##
+*   Remove deprecated `ActiveModel::Errors#values`.
 
-*   No changes.
+    *Rafael Mendonça França*
 
+*   Remove deprecated `ActiveModel::Errors#slice!`.
 
-## Rails 6.1.2 (February 09, 2021) ##
+    *Rafael Mendonça França*
 
-*   No changes.
+*   Remove deprecated `ActiveModel::Errors#to_h`.
+
+    *Rafael Mendonça França*
+
+*   Remove deprecated enumeration of `ActiveModel::Errors` instances as a Hash.
+
+    *Rafael Mendonça França*
+
+*   Clear secure password cache if password is set to `nil`
 
+    Before:
 
-## Rails 6.1.1 (January 07, 2021) ##
+       user.password = 'something'
+       user.password = nil
+
+       user.password # => 'something'
+
+    Now:
+
+       user.password = 'something'
+       user.password = nil
+
+       user.password # => nil
+
+    *Markus Doits*
+
+## Rails 7.0.0.alpha2 (September 15, 2021) ##
 
 *   No changes.
 
 
-## Rails 6.1.0 (December 09, 2020) ##
+## Rails 7.0.0.alpha1 (September 15, 2021) ##
 
-*   Pass in `base` instead of `base_class` to Error.human_attribute_name
+*   Introduce `ActiveModel::API`.
 
-    This is useful in cases where the `human_attribute_name` method depends
-    on other attributes' values of the class under validation to derive what the
-    attribute name should be.
+    Make `ActiveModel::API` the minimum API to talk with Action Pack and Action View.
+    This will allow adding more functionality to `ActiveModel::Model`.
 
-    *Filipe Sabella*
+    *Petrik de Heus*, *Nathaniel Watts*
 
-*   Deprecate marshalling load from legacy attributes format.
+*   Fix dirty check for Float::NaN and BigDecimal::NaN.
 
-    *Ryuta Kamizono*
+    Float::NaN and BigDecimal::NaN in Ruby are [special values](https://bugs.ruby-lang.org/issues/1720)
+    and can't be compared with `==`.
 
-*   `*_previously_changed?` accepts `:from` and `:to` keyword arguments like `*_changed?`.
+    *Marcelo Lauxen*
 
-        topic.update!(status: :archived)
-        topic.status_previously_changed?(from: "active", to: "archived")
-        # => true
+*   Fix `to_json` for `ActiveModel::Dirty` object.
 
-    *George Claghorn*
+    Exclude `mutations_from_database` attribute from json as it lead to recursion.
 
-*   Raise FrozenError when trying to write attributes that aren't backed by the database on an object that is frozen:
+    *Anil Maurya*
 
-        class Animal
-          include ActiveModel::Attributes
-          attribute :age
-        end
+*   Add `ActiveModel::AttributeSet#values_for_database`.
 
-        animal = Animal.new
-        animal.freeze
-        animal.age = 25 # => FrozenError, "can't modify a frozen Animal"
+    Returns attributes with values for assignment to the database.
 
-    *Josh Brody*
+    *Chris Salzberg*
 
-*   Add `*_previously_was` attribute methods when dirty tracking. Example:
+*   Fix delegation in ActiveModel::Type::Registry#lookup and ActiveModel::Type.lookup.
 
-        pirate.update(catchphrase: "Ahoy!")
-        pirate.previous_changes["catchphrase"] # => ["Thar She Blows!", "Ahoy!"]
-        pirate.catchphrase_previously_was # => "Thar She Blows!"
+    Passing a last positional argument `{}` would be incorrectly considered as keyword argument.
 
-    *DHH*
+    *Benoit Daloze*
 
-*   Encapsulate each validation error as an Error object.
+*   Cache and re-use generated attribute methods.
 
-    The `ActiveModel`’s `errors` collection is now an array of these Error
-    objects, instead of messages/details hash.
+    Generated methods with identical implementations will now share their instruction sequences
+    leading to reduced memory retention, and slightly faster load time.
 
-    For each of these `Error` object, its `message` and `full_message` methods
-    are for generating error messages. Its `details` method would return error’s
-    extra parameters, found in the original `details` hash.
+    *Jean Boussier*
 
-    The change tries its best at maintaining backward compatibility, however
-    some edge cases won’t be covered, like `errors#first` will return `ActiveModel::Error` and manipulating
-    `errors.messages` and `errors.details` hashes directly will have no effect. Moving forward,
-    please convert those direct manipulations to use provided API methods instead.
+*   Add `in: range`  parameter to `numericality` validator.
 
-    The list of deprecated methods and their planned future behavioral changes at the next major release are:
+    *Michal Papis*
 
-    * `errors#slice!` will be removed.
-    * `errors#each` with the `key, value` two-arguments block will stop working, while the `error` single-argument block would return `Error` object.
-    * `errors#values` will be removed.
-    * `errors#keys` will be removed.
-    * `errors#to_xml` will be removed.
-    * `errors#to_h` will be removed, and can be replaced with `errors#to_hash`.
-    * Manipulating `errors` itself as a hash will have no effect (e.g. `errors[:foo] = 'bar'`).
-    * Manipulating the hash returned by `errors#messages` (e.g. `errors.messages[:foo] = 'bar'`) will have no effect.
-    * Manipulating the hash returned by `errors#details` (e.g. `errors.details[:foo].clear`) will have no effect.
+*   Add `locale` argument to `ActiveModel::Name#initialize` to be used to generate the `singular`,
+   `plural`, `route_key` and `singular_route_key` values.
 
-    *lulalala*
+    *Lukas Pokorny*
 
+*   Make ActiveModel::Errors#inspect slimmer for readability
+
+    *lulalala*
 
-Please check [6-0-stable](https://github.com/rails/rails/blob/6-0-stable/activemodel/CHANGELOG.md) for previous changes.
+Please check [6-1-stable](https://github.com/rails/rails/blob/6-1-stable/activemodel/CHANGELOG.md) for previous changes.

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2004-2020 David Heinemeier Hansson
+Copyright (c) 2004-2021 David Heinemeier Hansson
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.rdoc

@@ -16,10 +16,10 @@ Model solves this by defining an explicit API. You can read more about the
 API in <tt>ActiveModel::Lint::Tests</tt>.
 
 Active Model provides a default module that implements the basic API required
-to integrate with Action Pack out of the box: <tt>ActiveModel::Model</tt>.
+to integrate with Action Pack out of the box: <tt>ActiveModel::API</tt>.
 
     class Person
-      include ActiveModel::Model
+      include ActiveModel::API
 
       attr_accessor :name, :age
       validates_presence_of :name
@@ -32,7 +32,7 @@ to integrate with Action Pack out of the box: <tt>ActiveModel::Model</tt>.
 
 It includes model name introspections, conversions, translations and
 validations, resulting in a class suitable to be used with Action Pack.
-See <tt>ActiveModel::Model</tt> for more examples.
+See <tt>ActiveModel::API</tt> for more examples.
 
 Active Model also provides the following functionality to have ORM-like
 behavior out of the box:

data/lib/active_model/api.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module ActiveModel
+  # == Active \Model \API
+  #
+  # Includes the required interface for an object to interact with
+  # Action Pack and Action View, using different Active Model modules.
+  # It includes model name introspections, conversions, translations and
+  # validations. Besides that, it allows you to initialize the object with a
+  # hash of attributes, pretty much like Active Record does.
+  #
+  # A minimal implementation could be:
+  #
+  #   class Person
+  #     include ActiveModel::API
+  #     attr_accessor :name, :age
+  #   end
+  #
+  #   person = Person.new(name: 'bob', age: '18')
+  #   person.name # => "bob"
+  #   person.age  # => "18"
+  #
+  # Note that, by default, <tt>ActiveModel::API</tt> implements <tt>persisted?</tt>
+  # to return +false+, which is the most common case. You may want to override
+  # it in your class to simulate a different scenario:
+  #
+  #   class Person
+  #     include ActiveModel::API
+  #     attr_accessor :id, :name
+  #
+  #     def persisted?
+  #       self.id.present?
+  #     end
+  #   end
+  #
+  #   person = Person.new(id: 1, name: 'bob')
+  #   person.persisted? # => true
+  #
+  # Also, if for some reason you need to run code on <tt>initialize</tt>, make
+  # sure you call +super+ if you want the attributes hash initialization to
+  # happen.
+  #
+  #   class Person
+  #     include ActiveModel::API
+  #     attr_accessor :id, :name, :omg
+  #
+  #     def initialize(attributes={})
+  #       super
+  #       @omg ||= true
+  #     end
+  #   end
+  #
+  #   person = Person.new(id: 1, name: 'bob')
+  #   person.omg # => true
+  #
+  # For more detailed information on other functionalities available, please
+  # refer to the specific modules included in <tt>ActiveModel::API</tt>
+  # (see below).
+  module API
+    extend ActiveSupport::Concern
+    include ActiveModel::AttributeAssignment
+    include ActiveModel::Validations
+    include ActiveModel::Conversion
+
+    included do
+      extend ActiveModel::Naming
+      extend ActiveModel::Translation
+    end
+
+    # Initializes a new model with the given +params+.
+    #
+    #   class Person
+    #     include ActiveModel::API
+    #     attr_accessor :name, :age
+    #   end
+    #
+    #   person = Person.new(name: 'bob', age: '18')
+    #   person.name # => "bob"
+    #   person.age  # => "18"
+    def initialize(attributes = {})
+      assign_attributes(attributes) if attributes
+
+      super()
+    end
+
+    # Indicates if the model is persisted. Default is +false+.
+    #
+    #  class Person
+    #    include ActiveModel::API
+    #    attr_accessor :id, :name
+    #  end
+    #
+    #  person = Person.new(id: 1, name: 'bob')
+    #  person.persisted? # => false
+    def persisted?
+      false
+    end
+  end
+end

data/lib/active_model/attribute.rb

@@ -56,6 +56,10 @@ module ActiveModel
       type.serialize(value)
     end
 
+    def serializable?(&block)
+      type.serializable?(value, &block)
+    end
+
     def changed?
       changed_from_assignment? || changed_in_place?
     end

data/lib/active_model/attribute_methods.rb

@@ -67,6 +67,7 @@ module ActiveModel
 
     NAME_COMPILABLE_REGEXP = /\A[a-zA-Z_]\w*[!?=]?\z/
     CALL_COMPILABLE_REGEXP = /\A[a-zA-Z_]\w*[!?]?\z/
+    FORWARD_PARAMETERS = "*args"
 
     included do
       class_attribute :attribute_aliases, instance_writer: false, default: {}
@@ -105,8 +106,8 @@ module ActiveModel
       #   person.name          # => "Bob"
       #   person.clear_name
       #   person.name          # => nil
-      def attribute_method_prefix(*prefixes)
-        self.attribute_method_matchers += prefixes.map! { |prefix| AttributeMethodMatcher.new prefix: prefix }
+      def attribute_method_prefix(*prefixes, parameters: nil)
+        self.attribute_method_matchers += prefixes.map! { |prefix| AttributeMethodMatcher.new(prefix: prefix, parameters: parameters) }
         undefine_attribute_methods
       end
 
@@ -140,8 +141,8 @@ module ActiveModel
       #   person.name = 'Bob'
       #   person.name          # => "Bob"
       #   person.name_short?   # => true
-      def attribute_method_suffix(*suffixes)
-        self.attribute_method_matchers += suffixes.map! { |suffix| AttributeMethodMatcher.new suffix: suffix }
+      def attribute_method_suffix(*suffixes, parameters: nil)
+        self.attribute_method_matchers += suffixes.map! { |suffix| AttributeMethodMatcher.new(suffix: suffix, parameters: parameters) }
         undefine_attribute_methods
       end
 
@@ -177,7 +178,7 @@ module ActiveModel
       #   person.reset_name_to_default!
       #   person.name                         # => 'Default Name'
       def attribute_method_affix(*affixes)
-        self.attribute_method_matchers += affixes.map! { |affix| AttributeMethodMatcher.new prefix: affix[:prefix], suffix: affix[:suffix] }
+        self.attribute_method_matchers += affixes.map! { |affix| AttributeMethodMatcher.new(**affix) }
         undefine_attribute_methods
       end
 
@@ -207,11 +208,33 @@ module ActiveModel
       #   person.nickname_short? # => true
       def alias_attribute(new_name, old_name)
         self.attribute_aliases = attribute_aliases.merge(new_name.to_s => old_name.to_s)
-        CodeGenerator.batch(self, __FILE__, __LINE__) do |owner|
+        ActiveSupport::CodeGenerator.batch(self, __FILE__, __LINE__) do |code_generator|
           attribute_method_matchers.each do |matcher|
-            matcher_new = matcher.method_name(new_name).to_s
-            matcher_old = matcher.method_name(old_name).to_s
-            define_proxy_call false, owner, matcher_new, matcher_old
+            method_name = matcher.method_name(new_name).to_s
+            target_name = matcher.method_name(old_name).to_s
+            parameters = matcher.parameters
+
+            mangled_name = target_name
+            unless NAME_COMPILABLE_REGEXP.match?(target_name)
+              mangled_name = "__temp__#{target_name.unpack1("h*")}"
+            end
+
+            code_generator.define_cached_method(method_name, as: mangled_name, namespace: :alias_attribute) do |batch|
+              body = if CALL_COMPILABLE_REGEXP.match?(target_name)
+                "self.#{target_name}(#{parameters || ''})"
+              else
+                call_args = [":'#{target_name}'"]
+                call_args << parameters if parameters
+                "send(#{call_args.join(", ")})"
+              end
+
+              modifier = matcher.parameters == FORWARD_PARAMETERS ? "ruby2_keywords " : ""
+
+              batch <<
+                "#{modifier}def #{mangled_name}(#{parameters || ''})" <<
+                body <<
+                "end"
+            end
           end
         end
       end
@@ -251,7 +274,7 @@ module ActiveModel
       #     end
       #   end
       def define_attribute_methods(*attr_names)
-        CodeGenerator.batch(generated_attribute_methods, __FILE__, __LINE__) do |owner|
+        ActiveSupport::CodeGenerator.batch(generated_attribute_methods, __FILE__, __LINE__) do |owner|
           attr_names.flatten.each { |attr_name| define_attribute_method(attr_name, _owner: owner) }
         end
       end
@@ -286,7 +309,7 @@ module ActiveModel
       #   person.name        # => "Bob"
       #   person.name_short? # => true
       def define_attribute_method(attr_name, _owner: generated_attribute_methods)
-        CodeGenerator.batch(_owner, __FILE__, __LINE__) do |owner|
+        ActiveSupport::CodeGenerator.batch(_owner, __FILE__, __LINE__) do |owner|
           attribute_method_matchers.each do |matcher|
             method_name = matcher.method_name(attr_name)
 
@@ -296,7 +319,7 @@ module ActiveModel
               if respond_to?(generate_method, true)
                 send(generate_method, attr_name.to_s, owner: owner)
               else
-                define_proxy_call true, owner, method_name, matcher.target, attr_name.to_s
+                define_proxy_call(owner, method_name, matcher.target, matcher.parameters, attr_name.to_s, namespace: :active_model)
               end
             end
           end
@@ -335,46 +358,6 @@ module ActiveModel
       end
 
       private
-        class CodeGenerator
-          class << self
-            def batch(owner, path, line)
-              if owner.is_a?(CodeGenerator)
-                yield owner
-              else
-                instance = new(owner, path, line)
-                result = yield instance
-                instance.execute
-                result
-              end
-            end
-          end
-
-          def initialize(owner, path, line)
-            @owner = owner
-            @path = path
-            @line = line
-            @sources = ["# frozen_string_literal: true\n"]
-            @renames = {}
-          end
-
-          def <<(source_line)
-            @sources << source_line
-          end
-
-          def rename_method(old_name, new_name)
-            @renames[old_name] = new_name
-          end
-
-          def execute
-            @owner.module_eval(@sources.join(";"), @path, @line - 1)
-            @renames.each do |old_name, new_name|
-              @owner.alias_method new_name, old_name
-              @owner.undef_method old_name
-            end
-          end
-        end
-        private_constant :CodeGenerator
-
         def generated_attribute_methods
           @generated_attribute_methods ||= Module.new.tap { |mod| include mod }
         end
@@ -398,42 +381,48 @@ module ActiveModel
 
         def attribute_method_matchers_matching(method_name)
           attribute_method_matchers_cache.compute_if_absent(method_name) do
-            attribute_method_matchers.map { |matcher| matcher.match(method_name) }.compact
+            attribute_method_matchers.filter_map { |matcher| matcher.match(method_name) }
           end
         end
 
         # Define a method `name` in `mod` that dispatches to `send`
-        # using the given `extra` args. This falls back on `define_method`
-        # and `send` if the given names cannot be compiled.
-        def define_proxy_call(include_private, code_generator, name, target, *extra)
-          defn = if NAME_COMPILABLE_REGEXP.match?(name)
-            "def #{name}(*args)"
-          else
-            "define_method(:'#{name}') do |*args|"
+        # using the given `extra` args. This falls back on `send`
+        # if the called name cannot be compiled.
+        def define_proxy_call(code_generator, name, target, parameters, *call_args, namespace:)
+          mangled_name = name
+          unless NAME_COMPILABLE_REGEXP.match?(name)
+            mangled_name = "__temp__#{name.unpack1("h*")}"
           end
 
-          extra = (extra.map!(&:inspect) << "*args").join(", ")
+          code_generator.define_cached_method(name, as: mangled_name, namespace: namespace) do |batch|
+            call_args.map!(&:inspect)
+            call_args << parameters if parameters
 
-          body = if CALL_COMPILABLE_REGEXP.match?(target)
-            "#{"self." unless include_private}#{target}(#{extra})"
-          else
-            "send(:'#{target}', #{extra})"
-          end
+            body = if CALL_COMPILABLE_REGEXP.match?(target)
+              "self.#{target}(#{call_args.join(", ")})"
+            else
+              call_args.unshift(":'#{target}'")
+              "send(#{call_args.join(", ")})"
+            end
+
+            modifier = parameters == FORWARD_PARAMETERS ? "ruby2_keywords " : ""
 
-          code_generator <<
-            defn <<
-            body <<
-            "end" <<
-            "ruby2_keywords(:'#{name}') if respond_to?(:ruby2_keywords, true)"
+            batch <<
+              "#{modifier}def #{mangled_name}(#{parameters || ''})" <<
+              body <<
+              "end"
+          end
         end
 
-        class AttributeMethodMatcher #:nodoc:
-          attr_reader :prefix, :suffix, :target
+        class AttributeMethodMatcher # :nodoc:
+          attr_reader :prefix, :suffix, :target, :parameters
 
           AttributeMethodMatch = Struct.new(:target, :attr_name)
 
-          def initialize(options = {})
-            @prefix, @suffix = options.fetch(:prefix, ""), options.fetch(:suffix, "")
+          def initialize(prefix: "", suffix: "", parameters: nil)
+            @prefix = prefix
+            @suffix = suffix
+            @parameters = parameters.nil? ? FORWARD_PARAMETERS : parameters
             @regex = /^(?:#{Regexp.escape(@prefix)})(.*)(?:#{Regexp.escape(@suffix)})$/
             @target = "#{@prefix}attribute#{@suffix}"
             @method_name = "#{prefix}%s#{suffix}"
@@ -469,7 +458,7 @@ module ActiveModel
         match ? attribute_missing(match, *args, &block) : super
       end
     end
-    ruby2_keywords(:method_missing) if respond_to?(:ruby2_keywords, true)
+    ruby2_keywords(:method_missing)
 
     # +attribute_missing+ is like +method_missing+, but for attributes. When
     # +method_missing+ is called we check to see if there is a matching
@@ -520,10 +509,6 @@ module ActiveModel
 
         # We want to generate the methods via module_eval rather than
         # define_method, because define_method is slower on dispatch.
-        # Evaluating many similar methods may use more memory as the instruction
-        # sequences are duplicated and cached (in MRI).  define_method may
-        # be slower on dispatch, but if you're careful about the closure
-        # created, then define_method will consume much less memory.
         #
         # But sometimes the database might return columns with
         # characters that are not allowed in normal method names (like
@@ -547,7 +532,6 @@ module ActiveModel
             temp_method_name = "__temp__#{safe_name}#{'=' if writer}"
             attr_name_expr = "::ActiveModel::AttributeMethods::AttrNames::#{const_name}"
             yield temp_method_name, attr_name_expr
-            owner.rename_method(temp_method_name, method_name)
           end
         end
       end

data/lib/active_model/attribute_set/builder.rb

@@ -144,16 +144,7 @@ module ActiveModel
     end
 
     def marshal_load(values)
-      if values.is_a?(Hash)
-        ActiveSupport::Deprecation.warn(<<~MSG)
-          Marshalling load from legacy attributes format is deprecated and will be removed in Rails 6.2.
-        MSG
-        empty_hash = {}.freeze
-        initialize(empty_hash, empty_hash, empty_hash, empty_hash, values)
-        @materialized = true
-      else
-        initialize(*values)
-      end
+      initialize(*values)
     end
 
     protected

data/lib/active_model/attribute_set.rb

@@ -25,6 +25,10 @@ module ActiveModel
       attributes.transform_values(&:value_before_type_cast)
     end
 
+    def values_for_database
+      attributes.transform_values(&:value_for_database)
+    end
+
     def to_hash
       keys.index_with { |name| self[name].value }
     end
@@ -54,7 +58,6 @@ module ActiveModel
 
     def write_cast_value(name, value)
       @attributes[name] = self[name].with_cast_value(value)
-      value
     end
 
     def freeze