activemodel 7.0.4 → 6.1.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 630260cc44166916794fb7e43002e72a303ff43b834e82e530cff1f13f25ee7f
-  data.tar.gz: f136cec57987c03ab4aa3fba2b65fe2964b010a326e28cdc0d32f755b45612f1
+  metadata.gz: d2706dba9ce622452b7e50ce891f67af2eb27717b37ed0279148ad064ef1c6ce
+  data.tar.gz: 16856f088c941213ab4647ec5041995c8eaadf1ff230e76a98eb4ddd34ce0856
 SHA512:
-  metadata.gz: 9b16a3dd6f96bf2ec1bfa5e3abba2e513567b12035e34e8ea30c24fb8a08ca70089d394f5daa0f40fdc4e14fb63470593904a5a335f864782983c719cf0d57d2
-  data.tar.gz: 66f3f86fcf4b90ffbab8ea82777ac2df48f1774f7ff528d44ec81e12ea47cb2050309b5535e9e960757eb8f9350efa9c6a128754c3b117fdedef3e3c42a43765
+  metadata.gz: 8b234b3e5a18c9831af5d029ee72d91481c4a82f539f4184ca9d274c0d3d13529e8fa3e71ac34a2caaa614b74db98da21432914e2d04212a9232b61b6e585ee7
+  data.tar.gz: 10c2d8a7571fa6340749ccfef90e1f54b423a6f1c259adf6961c0043ccfea04e5400e7f76b733e8d0a0f4d81dfe3c233895aeddc444a28cd87fa01a4ec6e1894

data/CHANGELOG.md

@@ -1,209 +1,207 @@
-## Rails 7.0.4 (September 09, 2022) ##
+## Rails 6.1.7.1 (January 17, 2023) ##
 
-*   Handle name clashes in attribute methods code generation cache.
-
-    When two distinct attribute methods would generate similar names,
-    the first implementation would be incorrectly re-used.
-
-    ```ruby
-    class A
-      attribute_method_suffix "_changed?"
-      define_attribute_methods :x
-    end
-
-    class B
-      attribute_method_suffix "?"
-      define_attribute_methods :x_changed
-    end
-    ```
+*   No changes.
 
-    *Jean Boussier*
 
-## Rails 7.0.3.1 (July 12, 2022) ##
+## Rails 6.1.7 (September 09, 2022) ##
 
 *   No changes.
 
 
-## Rails 7.0.3 (May 09, 2022) ##
+## Rails 6.1.6.1 (July 12, 2022) ##
 
 *   No changes.
 
 
-## Rails 7.0.2.4 (April 26, 2022) ##
+## Rails 6.1.6 (May 09, 2022) ##
 
 *   No changes.
 
 
-## Rails 7.0.2.3 (March 08, 2022) ##
+## Rails 6.1.5.1 (April 26, 2022) ##
 
 *   No changes.
 
 
-## Rails 7.0.2.2 (February 11, 2022) ##
+## Rails 6.1.5 (March 09, 2022) ##
 
-*   No changes.
+*   Clear secure password cache if password is set to `nil`
 
+    Before:
+
+       user.password = 'something'
+       user.password = nil
 
-## Rails 7.0.2.1 (February 11, 2022) ##
+       user.password # => 'something'
 
-*   No changes.
+    Now:
 
+       user.password = 'something'
+       user.password = nil
 
-## Rails 7.0.2 (February 08, 2022) ##
+       user.password # => nil
 
-*   Use different cache namespace for proxy calls
+    *Markus Doits*
 
-    Models can currently have different attribute bodies for the same method
-    names, leading to conflicts. Adding a new namespace `:active_model_proxy`
-    fixes the issue.
+*   Fix delegation in `ActiveModel::Type::Registry#lookup` and `ActiveModel::Type.lookup`
 
-    *Chris Salzberg*
+    Passing a last positional argument `{}` would be incorrectly considered as keyword argument.
 
+    *Benoit Daloze*
 
-## Rails 7.0.1 (January 06, 2022) ##
+*   Fix `to_json` after `changes_applied` for `ActiveModel::Dirty` object.
 
-*   No changes.
+    *Ryuta Kamizono*
 
 
-## Rails 7.0.0 (December 15, 2021) ##
+## Rails 6.1.4.7 (March 08, 2022) ##
 
 *   No changes.
 
 
-## Rails 7.0.0.rc3 (December 14, 2021) ##
+## Rails 6.1.4.6 (February 11, 2022) ##
 
 *   No changes.
 
 
-## Rails 7.0.0.rc2 (December 14, 2021) ##
+## Rails 6.1.4.5 (February 11, 2022) ##
 
 *   No changes.
 
-## Rails 7.0.0.rc1 (December 06, 2021) ##
 
-*   Remove support to Marshal load Rails 5.x `ActiveModel::AttributeSet` format.
+## Rails 6.1.4.4 (December 15, 2021) ##
 
-    *Rafael Mendonça França*
+*   No changes.
 
-*   Remove support to Marshal and YAML load Rails 5.x error format.
 
-    *Rafael Mendonça França*
+## Rails 6.1.4.3 (December 14, 2021) ##
 
-*   Remove deprecated support to use `[]=` in `ActiveModel::Errors#messages`.
+*   No changes.
 
-    *Rafael Mendonça França*
 
-*   Remove deprecated support to `delete` errors from `ActiveModel::Errors#messages`.
+## Rails 6.1.4.2 (December 14, 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.4.1 (August 19, 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.4 (June 24, 2021) ##
 
-    *Rafael Mendonça França*
+*   Fix `to_json` for `ActiveModel::Dirty` object.
 
-*   Remove deprecated `ActiveModel::Errors#keys`.
+    Exclude +mutations_from_database+ attribute from json as it lead to recursion.
 
-    *Rafael Mendonça França*
+    *Anil Maurya*
 
-*   Remove deprecated `ActiveModel::Errors#values`.
 
-    *Rafael Mendonça França*
+## Rails 6.1.3.2 (May 05, 2021) ##
 
-*   Remove deprecated `ActiveModel::Errors#slice!`.
+*   No changes.
 
-    *Rafael Mendonça França*
 
-*   Remove deprecated `ActiveModel::Errors#to_h`.
+## Rails 6.1.3.1 (March 26, 2021) ##
 
-    *Rafael Mendonça França*
+*   No changes.
 
-*   Remove deprecated enumeration of `ActiveModel::Errors` instances as a Hash.
 
-    *Rafael Mendonça França*
+## Rails 6.1.3 (February 17, 2021) ##
 
-*   Clear secure password cache if password is set to `nil`
+*   No changes.
 
-    Before:
 
-       user.password = 'something'
-       user.password = nil
+## Rails 6.1.2.1 (February 10, 2021) ##
 
-       user.password # => 'something'
+*   No changes.
 
-    Now:
 
-       user.password = 'something'
-       user.password = nil
+## Rails 6.1.2 (February 09, 2021) ##
 
-       user.password # => nil
+*   No changes.
 
-    *Markus Doits*
 
-## Rails 7.0.0.alpha2 (September 15, 2021) ##
+## Rails 6.1.1 (January 07, 2021) ##
 
 *   No changes.
 
 
-## Rails 7.0.0.alpha1 (September 15, 2021) ##
+## Rails 6.1.0 (December 09, 2020) ##
 
-*   Introduce `ActiveModel::API`.
+*   Pass in `base` instead of `base_class` to Error.human_attribute_name
 
-    Make `ActiveModel::API` the minimum API to talk with Action Pack and Action View.
-    This will allow adding more functionality to `ActiveModel::Model`.
+    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.
 
-    *Petrik de Heus*, *Nathaniel Watts*
+    *Filipe Sabella*
 
-*   Fix dirty check for Float::NaN and BigDecimal::NaN.
+*   Deprecate marshalling load from legacy attributes format.
 
-    Float::NaN and BigDecimal::NaN in Ruby are [special values](https://bugs.ruby-lang.org/issues/1720)
-    and can't be compared with `==`.
+    *Ryuta Kamizono*
 
-    *Marcelo Lauxen*
+*   `*_previously_changed?` accepts `:from` and `:to` keyword arguments like `*_changed?`.
 
-*   Fix `to_json` for `ActiveModel::Dirty` object.
+        topic.update!(status: :archived)
+        topic.status_previously_changed?(from: "active", to: "archived")
+        # => true
 
-    Exclude `mutations_from_database` attribute from json as it lead to recursion.
+    *George Claghorn*
 
-    *Anil Maurya*
+*   Raise FrozenError when trying to write attributes that aren't backed by the database on an object that is frozen:
 
-*   Add `ActiveModel::AttributeSet#values_for_database`.
+        class Animal
+          include ActiveModel::Attributes
+          attribute :age
+        end
 
-    Returns attributes with values for assignment to the database.
+        animal = Animal.new
+        animal.freeze
+        animal.age = 25 # => FrozenError, "can't modify a frozen Animal"
 
-    *Chris Salzberg*
+    *Josh Brody*
 
-*   Fix delegation in ActiveModel::Type::Registry#lookup and ActiveModel::Type.lookup.
+*   Add `*_previously_was` attribute methods when dirty tracking. Example:
 
-    Passing a last positional argument `{}` would be incorrectly considered as keyword argument.
+        pirate.update(catchphrase: "Ahoy!")
+        pirate.previous_changes["catchphrase"] # => ["Thar She Blows!", "Ahoy!"]
+        pirate.catchphrase_previously_was # => "Thar She Blows!"
 
-    *Benoit Daloze*
+    *DHH*
 
-*   Cache and re-use generated attribute methods.
+*   Encapsulate each validation error as an Error object.
 
-    Generated methods with identical implementations will now share their instruction sequences
-    leading to reduced memory retention, and slightly faster load time.
+    The `ActiveModel`’s `errors` collection is now an array of these Error
+    objects, instead of messages/details hash.
 
-    *Jean Boussier*
+    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.
 
-*   Add `in: range`  parameter to `numericality` validator.
+    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.
+    Please note that `errors#add` now accepts `options` as keyword arguments instead of `Hash` which
+    introduced a change in Ruby 3 to [keyword arguments][kwargs-ann].
 
-    *Michal Papis*
+    [kwargs-ann]: https://www.ruby-lang.org/en/news/2019/12/12/separation-of-positional-and-keyword-arguments-in-ruby-3-0/
 
-*   Add `locale` argument to `ActiveModel::Name#initialize` to be used to generate the `singular`,
-   `plural`, `route_key` and `singular_route_key` values.
+    The list of deprecated methods and their planned future behavioral changes at the next major release are:
 
-    *Lukas Pokorny*
-
-*   Make ActiveModel::Errors#inspect slimmer for readability
+    * `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.
 
     *lulalala*
 
-Please check [6-1-stable](https://github.com/rails/rails/blob/6-1-stable/activemodel/CHANGELOG.md) for previous changes.
+
+Please check [6-0-stable](https://github.com/rails/rails/blob/6-0-stable/activemodel/CHANGELOG.md) for previous changes.

data/MIT-LICENSE

@@ -18,4 +18,3 @@ NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
 LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-

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::API</tt>.
+to integrate with Action Pack out of the box: <tt>ActiveModel::Model</tt>.
 
     class Person
-      include ActiveModel::API
+      include ActiveModel::Model
 
       attr_accessor :name, :age
       validates_presence_of :name
@@ -32,7 +32,7 @@ to integrate with Action Pack out of the box: <tt>ActiveModel::API</tt>.
 
 It includes model name introspections, conversions, translations and
 validations, resulting in a class suitable to be used with Action Pack.
-See <tt>ActiveModel::API</tt> for more examples.
+See <tt>ActiveModel::Model</tt> for more examples.
 
 Active Model also provides the following functionality to have ORM-like
 behavior out of the box:

data/lib/active_model/attribute.rb

@@ -56,10 +56,6 @@ 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,7 +67,6 @@ 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: {}
@@ -106,8 +105,8 @@ module ActiveModel
       #   person.name          # => "Bob"
       #   person.clear_name
       #   person.name          # => nil
-      def attribute_method_prefix(*prefixes, parameters: nil)
-        self.attribute_method_matchers += prefixes.map! { |prefix| AttributeMethodMatcher.new(prefix: prefix, parameters: parameters) }
+      def attribute_method_prefix(*prefixes)
+        self.attribute_method_matchers += prefixes.map! { |prefix| AttributeMethodMatcher.new prefix: prefix }
         undefine_attribute_methods
       end
 
@@ -141,8 +140,8 @@ module ActiveModel
       #   person.name = 'Bob'
       #   person.name          # => "Bob"
       #   person.name_short?   # => true
-      def attribute_method_suffix(*suffixes, parameters: nil)
-        self.attribute_method_matchers += suffixes.map! { |suffix| AttributeMethodMatcher.new(suffix: suffix, parameters: parameters) }
+      def attribute_method_suffix(*suffixes)
+        self.attribute_method_matchers += suffixes.map! { |suffix| AttributeMethodMatcher.new suffix: suffix }
         undefine_attribute_methods
       end
 
@@ -178,7 +177,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(**affix) }
+        self.attribute_method_matchers += affixes.map! { |affix| AttributeMethodMatcher.new prefix: affix[:prefix], suffix: affix[:suffix] }
         undefine_attribute_methods
       end
 
@@ -208,33 +207,11 @@ 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)
-        ActiveSupport::CodeGenerator.batch(self, __FILE__, __LINE__) do |code_generator|
+        CodeGenerator.batch(self, __FILE__, __LINE__) do |owner|
           attribute_method_matchers.each do |matcher|
-            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
+            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
           end
         end
       end
@@ -253,7 +230,7 @@ module ActiveModel
       # <tt>ActiveModel::AttributeMethods</tt>.
       #
       # To use, pass attribute names (as strings or symbols). Be sure to declare
-      # +define_attribute_methods+ after you define any prefix, suffix, or affix
+      # +define_attribute_methods+ after you define any prefix, suffix or affix
       # methods, or they will not hook in.
       #
       #   class Person
@@ -274,7 +251,7 @@ module ActiveModel
       #     end
       #   end
       def define_attribute_methods(*attr_names)
-        ActiveSupport::CodeGenerator.batch(generated_attribute_methods, __FILE__, __LINE__) do |owner|
+        CodeGenerator.batch(generated_attribute_methods, __FILE__, __LINE__) do |owner|
           attr_names.flatten.each { |attr_name| define_attribute_method(attr_name, _owner: owner) }
         end
       end
@@ -309,7 +286,7 @@ module ActiveModel
       #   person.name        # => "Bob"
       #   person.name_short? # => true
       def define_attribute_method(attr_name, _owner: generated_attribute_methods)
-        ActiveSupport::CodeGenerator.batch(_owner, __FILE__, __LINE__) do |owner|
+        CodeGenerator.batch(_owner, __FILE__, __LINE__) do |owner|
           attribute_method_matchers.each do |matcher|
             method_name = matcher.method_name(attr_name)
 
@@ -319,7 +296,7 @@ module ActiveModel
               if respond_to?(generate_method, true)
                 send(generate_method, attr_name.to_s, owner: owner)
               else
-                define_proxy_call(owner, method_name, matcher.target, matcher.parameters, attr_name.to_s, namespace: :active_model_proxy)
+                define_proxy_call true, owner, method_name, matcher.target, attr_name.to_s
               end
             end
           end
@@ -358,6 +335,46 @@ 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
@@ -381,48 +398,42 @@ module ActiveModel
 
         def attribute_method_matchers_matching(method_name)
           attribute_method_matchers_cache.compute_if_absent(method_name) do
-            attribute_method_matchers.filter_map { |matcher| matcher.match(method_name) }
+            attribute_method_matchers.map { |matcher| matcher.match(method_name) }.compact
           end
         end
 
         # Define a method `name` in `mod` that dispatches to `send`
-        # 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*")}"
+        # 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|"
           end
 
-          code_generator.define_cached_method(name, as: mangled_name, namespace: :"#{namespace}_#{target}") do |batch|
-            call_args.map!(&:inspect)
-            call_args << parameters if parameters
-
-            body = if CALL_COMPILABLE_REGEXP.match?(target)
-              "self.#{target}(#{call_args.join(", ")})"
-            else
-              call_args.unshift(":'#{target}'")
-              "send(#{call_args.join(", ")})"
-            end
+          extra = (extra.map!(&:inspect) << "*args").join(", ")
 
-            modifier = parameters == FORWARD_PARAMETERS ? "ruby2_keywords " : ""
-
-            batch <<
-              "#{modifier}def #{mangled_name}(#{parameters || ''})" <<
-              body <<
-              "end"
+          body = if CALL_COMPILABLE_REGEXP.match?(target)
+            "#{"self." unless include_private}#{target}(#{extra})"
+          else
+            "send(:'#{target}', #{extra})"
           end
+
+          code_generator <<
+            defn <<
+            body <<
+            "end" <<
+            "ruby2_keywords(:'#{name}') if respond_to?(:ruby2_keywords, true)"
         end
 
-        class AttributeMethodMatcher # :nodoc:
-          attr_reader :prefix, :suffix, :target, :parameters
+        class AttributeMethodMatcher #:nodoc:
+          attr_reader :prefix, :suffix, :target
 
           AttributeMethodMatch = Struct.new(:target, :attr_name)
 
-          def initialize(prefix: "", suffix: "", parameters: nil)
-            @prefix = prefix
-            @suffix = suffix
-            @parameters = parameters.nil? ? FORWARD_PARAMETERS : parameters
+          def initialize(options = {})
+            @prefix, @suffix = options.fetch(:prefix, ""), options.fetch(:suffix, "")
             @regex = /^(?:#{Regexp.escape(@prefix)})(.*)(?:#{Regexp.escape(@suffix)})$/
             @target = "#{@prefix}attribute#{@suffix}"
             @method_name = "#{prefix}%s#{suffix}"
@@ -458,7 +469,7 @@ module ActiveModel
         match ? attribute_missing(match, *args, &block) : super
       end
     end
-    ruby2_keywords(:method_missing)
+    ruby2_keywords(:method_missing) if respond_to?(:ruby2_keywords, true)
 
     # +attribute_missing+ is like +method_missing+, but for attributes. When
     # +method_missing+ is called we check to see if there is a matching
@@ -467,7 +478,6 @@ module ActiveModel
     def attribute_missing(match, *args, &block)
       __send__(match.target, match.attr_name, *args, &block)
     end
-    ruby2_keywords(:attribute_missing)
 
     # A +Person+ instance with a +name+ attribute can ask
     # <tt>person.respond_to?(:name)</tt>, <tt>person.respond_to?(:name=)</tt>,
@@ -510,6 +520,10 @@ 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
@@ -533,6 +547,7 @@ 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,7 +144,16 @@ module ActiveModel
     end
 
     def marshal_load(values)
-      initialize(*values)
+      if values.is_a?(Hash)
+        ActiveSupport::Deprecation.warn(<<~MSG)
+          Marshalling load from legacy attributes format is deprecated and will be removed in Rails 7.0.
+        MSG
+        empty_hash = {}.freeze
+        initialize(empty_hash, empty_hash, empty_hash, empty_hash, values)
+        @materialized = true
+      else
+        initialize(*values)
+      end
     end
 
     protected

data/lib/active_model/attribute_set.rb

@@ -25,10 +25,6 @@ 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
@@ -58,6 +54,7 @@ module ActiveModel
 
     def write_cast_value(name, value)
       @attributes[name] = self[name].with_cast_value(value)
+      value
     end
 
     def freeze