activemodel 7.0.3.1 → 6.1.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2845eb500d658cf1e666a48cbba3e2e96894a92cec97a1dfaff8cf4883f3909a
-  data.tar.gz: 0c6f8b7de47368da12af30e2c0a03c7b0022ae08a40a316a018899481801804c
+  metadata.gz: d2706dba9ce622452b7e50ce891f67af2eb27717b37ed0279148ad064ef1c6ce
+  data.tar.gz: 16856f088c941213ab4647ec5041995c8eaadf1ff230e76a98eb4ddd34ce0856
 SHA512:
-  metadata.gz: 4f23d0bc2105d523983d1b72915adf3ff5ec3cd7bbd690bb15c51bfb048d6b2f14c4e5760ca3a0eaae409be1ac5c643411d5a60ada8812d8116ae16d540ca249
-  data.tar.gz: bfa2d89dc9f7674eeb49112b427bebd8e1d72f5f316b7103905f426ebf7c4901c9682db5c7851d495b88721182e71a9c4b4ec6898a352fb253fcd4d2c1dbbe3b
+  metadata.gz: 8b234b3e5a18c9831af5d029ee72d91481c4a82f539f4184ca9d274c0d3d13529e8fa3e71ac34a2caaa614b74db98da21432914e2d04212a9232b61b6e585ee7
+  data.tar.gz: 10c2d8a7571fa6340749ccfef90e1f54b423a6f1c259adf6961c0043ccfea04e5400e7f76b733e8d0a0f4d81dfe3c233895aeddc444a28cd87fa01a4ec6e1894

data/CHANGELOG.md

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