activemodel 6.1.7.9 → 7.0.0.alpha1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4d30f31843a753d66aa59e2193e761f339225429fe5b9ccb1994361e0a435002
-  data.tar.gz: 89019d414c794903f0cb967fcccdcb4286a961717f656054c5f58c384a8bc61a
+  metadata.gz: 03bc5c9c2ea021d9c3e3a3a47bf160adc73738341c6e488e85de66a38de111ac
+  data.tar.gz: a6c81f5be5dbc43a7086563d786221aadfe1d9392c2ff1fc483ee433ffab4230
 SHA512:
-  metadata.gz: c254a43080c2674eff955f3bed3bd8e4dd8d2fa76ec8672aabebd010a29b7b05d81c76f4005fdba81122e95892cb67780fdfa321058c36d5152cf1128f582cab
-  data.tar.gz: 1d13831996c3ff67bb789009155b74f5068c035fd1b0f3bef373a537d7d29e91759c9318f9edfb5043cea89b69d38bc7e9c34d9a0c0dd80a0d404bccf2fa7fd1
+  metadata.gz: 3c7f97c5745ee6074629c8e546a738fbb8616581db954e78630df9a361bd3ae098bca8bec4afcc3891db83addc77e61349a6dcca2040844b715bed7b4a27c803
+  data.tar.gz: 143fbb8f40593fe72a1d3465d18affdf9ca3d30e11189d7a35f899af0b5f090b6c1209cf7294361a7dd3c1c5376b92555ee00e3afc92fc2715b26b63c51c7529

data/CHANGELOG.md

@@ -1,247 +1,55 @@
-## Rails 6.1.7.9 (October 15, 2024) ##
+## Rails 7.0.0.alpha1 (September 15, 2021) ##
 
-*   No changes.
+*   Introduce `ActiveModel::API`.
 
+    Make `ActiveModel::API` the minimum API to talk with Action Pack and Action View.
+    This will allow adding more functionality to `ActiveModel::Model`.
 
-## Rails 6.1.7.8 (June 04, 2024) ##
+    *Petrik de Heus*, *Nathaniel Watts*
 
-*   No changes.
+*   Fix dirty check for Float::NaN and BigDecimal::NaN.
 
+    Float::NaN and BigDecimal::NaN in Ruby are [special values](https://bugs.ruby-lang.org/issues/1720) 
+    and can't be compared with `==`.
 
-## Rails 6.1.7.7 (February 21, 2024) ##
-
-*   No changes.
-
-
-## Rails 6.1.7.6 (August 22, 2023) ##
-
-*   No changes.
-
-
-## Rails 6.1.7.5 (August 22, 2023) ##
-
-*   No changes.
-
-
-## Rails 6.1.7.4 (June 26, 2023) ##
-
-*   No changes.
-
-
-## Rails 6.1.7.3 (March 13, 2023) ##
-
-*   No changes.
-
-
-## Rails 6.1.7.2 (January 24, 2023) ##
-
-*   No changes.
-
-
-## Rails 6.1.7.1 (January 17, 2023) ##
-
-*   No changes.
-
-
-## Rails 6.1.7 (September 09, 2022) ##
-
-*   No changes.
-
-
-## Rails 6.1.6.1 (July 12, 2022) ##
-
-*   No changes.
-
-
-## Rails 6.1.6 (May 09, 2022) ##
-
-*   No changes.
-
-
-## Rails 6.1.5.1 (April 26, 2022) ##
-
-*   No changes.
-
-
-## Rails 6.1.5 (March 09, 2022) ##
-
-*   Clear secure password cache if password is set to `nil`
-
-    Before:
-
-       user.password = 'something'
-       user.password = nil
-
-       user.password # => 'something'
-
-    Now:
-
-       user.password = 'something'
-       user.password = nil
-
-       user.password # => nil
-
-    *Markus Doits*
-
-*   Fix delegation in `ActiveModel::Type::Registry#lookup` and `ActiveModel::Type.lookup`
-
-    Passing a last positional argument `{}` would be incorrectly considered as keyword argument.
-
-    *Benoit Daloze*
-
-*   Fix `to_json` after `changes_applied` for `ActiveModel::Dirty` object.
-
-    *Ryuta Kamizono*
-
-
-## Rails 6.1.4.7 (March 08, 2022) ##
-
-*   No changes.
-
-
-## Rails 6.1.4.6 (February 11, 2022) ##
-
-*   No changes.
-
-
-## Rails 6.1.4.5 (February 11, 2022) ##
-
-*   No changes.
-
-
-## Rails 6.1.4.4 (December 15, 2021) ##
-
-*   No changes.
-
-
-## Rails 6.1.4.3 (December 14, 2021) ##
-
-*   No changes.
-
-
-## Rails 6.1.4.2 (December 14, 2021) ##
-
-*   No changes.
-
-
-## Rails 6.1.4.1 (August 19, 2021) ##
-
-*   No changes.
-
-
-## Rails 6.1.4 (June 24, 2021) ##
+    *Marcelo Lauxen*
 
 *   Fix `to_json` for `ActiveModel::Dirty` object.
 
-    Exclude +mutations_from_database+ attribute from json as it lead to recursion.
+    Exclude `mutations_from_database` attribute from json as it lead to recursion.
 
     *Anil Maurya*
 
+*   Add `ActiveModel::AttributeSet#values_for_database`.
 
-## Rails 6.1.3.2 (May 05, 2021) ##
-
-*   No changes.
-
-
-## Rails 6.1.3.1 (March 26, 2021) ##
-
-*   No changes.
-
-
-## Rails 6.1.3 (February 17, 2021) ##
+    Returns attributes with values for assignment to the database.
 
-*   No changes.
+    *Chris Salzberg*
 
+*   Fix delegation in ActiveModel::Type::Registry#lookup and ActiveModel::Type.lookup.
 
-## Rails 6.1.2.1 (February 10, 2021) ##
-
-*   No changes.
-
-
-## Rails 6.1.2 (February 09, 2021) ##
-
-*   No changes.
-
-
-## Rails 6.1.1 (January 07, 2021) ##
-
-*   No changes.
-
-
-## Rails 6.1.0 (December 09, 2020) ##
-
-*   Pass in `base` instead of `base_class` to Error.human_attribute_name
-
-    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.
-
-    *Filipe Sabella*
-
-*   Deprecate marshalling load from legacy attributes format.
-
-    *Ryuta Kamizono*
-
-*   `*_previously_changed?` accepts `:from` and `:to` keyword arguments like `*_changed?`.
-
-        topic.update!(status: :archived)
-        topic.status_previously_changed?(from: "active", to: "archived")
-        # => true
-
-    *George Claghorn*
-
-*   Raise FrozenError when trying to write attributes that aren't backed by the database on an object that is frozen:
-
-        class Animal
-          include ActiveModel::Attributes
-          attribute :age
-        end
-
-        animal = Animal.new
-        animal.freeze
-        animal.age = 25 # => FrozenError, "can't modify a frozen Animal"
-
-    *Josh Brody*
-
-*   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*
 
-    * `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.
+*   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-2022 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
@@ -18,3 +18,4 @@ 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::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|
+        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
@@ -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,7 +358,37 @@ module ActiveModel
       end
 
       private
-        class CodeGenerator
+        class CodeGenerator # :nodoc:
+          class MethodSet
+            METHOD_CACHES = Hash.new { |h, k| h[k] = Module.new }
+
+            def initialize(namespace)
+              @cache = METHOD_CACHES[namespace]
+              @sources = []
+              @methods = {}
+            end
+
+            def define_cached_method(name, as: name)
+              name = name.to_sym
+              as = as.to_sym
+              @methods.fetch(name) do
+                unless @cache.method_defined?(as)
+                  yield @sources
+                end
+                @methods[name] = as
+              end
+            end
+
+            def apply(owner, path, line)
+              unless @sources.empty?
+                @cache.module_eval("# frozen_string_literal: true\n" + @sources.join(";"), path, line)
+              end
+              @methods.each do |name, as|
+                owner.define_method(name, @cache.instance_method(as))
+              end
+            end
+          end
+
           class << self
             def batch(owner, path, line)
               if owner.is_a?(CodeGenerator)
@@ -353,23 +406,16 @@ module ActiveModel
             @owner = owner
             @path = path
             @line = line
-            @sources = ["# frozen_string_literal: true\n"]
-            @renames = {}
-          end
-
-          def <<(source_line)
-            @sources << source_line
+            @namespaces = Hash.new { |h, k| h[k] = MethodSet.new(k) }
           end
 
-          def rename_method(old_name, new_name)
-            @renames[old_name] = new_name
+          def define_cached_method(name, namespace:, as: name, &block)
+            @namespaces[namespace].define_cached_method(name, as: as, &block)
           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
+            @namespaces.each_value do |method_set|
+              method_set.apply(@owner, @path, @line - 1)
             end
           end
         end
@@ -398,42 +444,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 +521,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 +572,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 +595,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