activemodel 7.2.2.1 → 8.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7abaeb86e5e7dc3786831b348d5f8deb514f1e3f2b70de2c2c7e7cd79a4c1511
-  data.tar.gz: ecb06547a6de150912b0c81b5296cd68258958f342c9029fb7633a879710e122
+  metadata.gz: 4f299734cfee7396d03d330f92d0be6f335017395937c52f6e6a88ebc894c1b8
+  data.tar.gz: d9ed23ff71d39c9ad9dc0df555413ed5440baef7240d1dc12d6ddc35cdc1c76c
 SHA512:
-  metadata.gz: e2dbf2434ce2471c32f69df40b9ecbec73df015c1100db563bd74ceca953c6feebd94c674ab2fdef7777580f79b9aea1525d976a3ff40aabbc7efa4148b1ac5f
-  data.tar.gz: 0c3605f04d15a6d7b7d97546183d8620b80f38d5d15c5b8e452d862721e9776d5249a3c6cd7f3b0c8b3269800db39bff939d93af92990b9680391afa5ae3e3e4
+  metadata.gz: 9586704ac01c836de27bfc1fdc50deee46f921af37590022fba6c13af2c703c7d4973cb0d50c16b45687afe1bb36eb7c6ea5fb6c04992b93a42dcc3f8f80637d
+  data.tar.gz: 428ad04107455dbb8e62a341192f8f4a093a4d17afca052623d25305ae7e109b21fa0dab8f2aa7581dc9ec1ebfe58bfad1e0008387df1b2cc044f95772895297

data/CHANGELOG.md

@@ -1,66 +1,46 @@
-## Rails 7.2.2.1 (December 10, 2024) ##
+## Rails 8.1.2 (January 08, 2026) ##
 
 *   No changes.
 
 
-## Rails 7.2.2 (October 30, 2024) ##
-
-*   Fix regression in `alias_attribute` to work with user defined methods.
-
-    `alias_attribute` would wrongly assume the attribute accessor was generated by Active Model.
-
-    ```ruby
-    class Person
-      include ActiveModel::AttributeMethods
-
-      define_attribute_methods :name
-      attr_accessor :name
-
-      alias_attribute :full_name, :name
-    end
-
-    person.full_name # => NoMethodError: undefined method `attribute' for an instance of Person
-    ```
-
-    *Jean Boussier*
-
-
-## Rails 7.2.1.2 (October 23, 2024) ##
+## Rails 8.1.1 (October 28, 2025) ##
 
 *   No changes.
 
 
-## Rails 7.2.1.1 (October 15, 2024) ##
+## Rails 8.1.0 (October 22, 2025) ##
 
-*   No changes.
+*   Add `reset_token: { expires_in: ... }` option to `has_secure_password`.
 
+    Allows configuring the expiry duration of password reset tokens (default remains 15 minutes for backwards compatibility).
 
-## Rails 7.2.1 (August 22, 2024) ##
-
-*   No changes.
+    ```ruby
+    has_secure_password reset_token: { expires_in: 1.hour }
+    ```
 
+    *Jevin Sew*, *Abeid Ahmed*
 
-## Rails 7.2.0 (August 09, 2024) ##
+*   Add `except_on:` option for validation callbacks.
 
-*   Fix a bug where type casting of string to `Time` and `DateTime` doesn't
-    calculate minus minute value in TZ offset correctly.
+    *Ben Sheldon*
 
-    *Akira Matsuda*
+*   Backport `ActiveRecord::Normalization` to `ActiveModel::Attributes::Normalization`
 
-*   Port the `type_for_attribute` method to Active Model. Classes that include
-    `ActiveModel::Attributes` will now provide this method. This method behaves
-    the same for Active Model as it does for Active Record.
+    ```ruby
+    class User
+      include ActiveModel::Attributes
+      include ActiveModel::Attributes::Normalization
 
-      ```ruby
-      class MyModel
-        include ActiveModel::Attributes
+      attribute :email, :string
 
-        attribute :my_attribute, :integer
-      end
+      normalizes :email, with: -> email { email.strip.downcase }
+    end
 
-      MyModel.type_for_attribute(:my_attribute) # => #<ActiveModel::Type::Integer ...>
-      ```
+    user = User.new
+    user.email =    " CRUISE-CONTROL@EXAMPLE.COM\n"
+    user.email # => "cruise-control@example.com"
+    ```
 
-    *Jonathan Hefner*
+    *Sean Doyle*
 
-Please check [7-1-stable](https://github.com/rails/rails/blob/7-1-stable/activemodel/CHANGELOG.md) for previous changes.
+Please check [8-0-stable](https://github.com/rails/rails/blob/8-0-stable/activemodel/CHANGELOG.md) for previous changes.

data/README.rdoc

@@ -261,6 +261,6 @@ Bug reports for the Ruby on \Rails project can be filed here:
 
 * https://github.com/rails/rails/issues
 
-Feature requests should be discussed on the rails-core mailing list here:
+Feature requests should be discussed on the rubyonrails-core forum here:
 
 * https://discuss.rubyonrails.org/c/rubyonrails-core

data/lib/active_model/attribute/user_provided_default.rb

@@ -26,6 +26,16 @@ module ActiveModel
         self.class.new(name, user_provided_value, type, original_attribute)
       end
 
+      def dup_or_share # :nodoc:
+        # Can't elide dup when the default is a Proc
+        # See Attribute#dup_or_share
+        if @user_provided_value.is_a?(Proc)
+          dup
+        else
+          super
+        end
+      end
+
       def marshal_dump
         result = [
           name,

data/lib/active_model/attribute.rb

@@ -38,7 +38,7 @@ module ActiveModel
       @value = value unless value.nil?
     end
 
-    def value
+    def value(&)
       # `defined?` is cheaper than `||=` when we get back falsy values
       @value = type_cast(value_before_type_cast) unless defined?(@value)
       @value
@@ -96,6 +96,14 @@ module ActiveModel
       end
     end
 
+    def dup_or_share # :nodoc:
+      if @type.mutable?
+        dup
+      else
+        self # If the underlying type is immutable we can get away with not duping
+      end
+    end
+
     def type_cast(*)
       raise NotImplementedError
     end

data/lib/active_model/attribute_assignment.rb

@@ -36,9 +36,30 @@ module ActiveModel
 
     alias attributes= assign_attributes
 
+    # Like `BasicObject#method_missing`, `#attribute_writer_missing` is invoked
+    # when `#assign_attributes` is passed an unknown attribute name.
+    #
+    # By default, `#attribute_writer_missing` raises an UnknownAttributeError.
+    #
+    #   class Rectangle
+    #     include ActiveModel::AttributeAssignment
+    #
+    #     attr_accessor :length, :width
+    #
+    #     def attribute_writer_missing(name, value)
+    #       Rails.logger.warn "Tried to assign to unknown attribute #{name}"
+    #     end
+    #   end
+    #
+    #   rectangle = Rectangle.new
+    #   rectangle.assign_attributes(height: 10) # => Logs "Tried to assign to unknown attribute 'height'"
+    def attribute_writer_missing(name, value)
+      raise UnknownAttributeError.new(self, name)
+    end
+
     private
       def _assign_attributes(attributes)
-        attributes.each do |k, v|
+        attributes.each_pair do |k, v|
           _assign_attribute(k, v)
         end
       end
@@ -50,7 +71,7 @@ module ActiveModel
         if respond_to?(setter)
           raise
         else
-          raise UnknownAttributeError.new(self, k.to_s)
+          attribute_writer_missing(k.to_s, v)
         end
       end
   end

data/lib/active_model/attribute_methods.rb

@@ -214,7 +214,7 @@ module ActiveModel
         end
       end
 
-      def generate_alias_attribute_methods(code_generator, new_name, old_name)
+      def generate_alias_attribute_methods(code_generator, new_name, old_name) # :nodoc:
         ActiveSupport::CodeGenerator.batch(code_generator, __FILE__, __LINE__) do |owner|
           attribute_method_patterns.each do |pattern|
             alias_attribute_method_definition(code_generator, pattern, new_name, old_name)
@@ -321,8 +321,8 @@ module ActiveModel
         canonical_method_name = pattern.method_name(attr_name)
         public_method_name = pattern.method_name(as)
 
-        # If defining a regular attribute method, we don't override methods that are explictly
-        # defined in parrent classes.
+        # If defining a regular attribute method, we don't override methods that are explicitly
+        # defined in parent classes.
         if instance_method_already_implemented?(public_method_name)
           # However, for `alias_attribute`, we always define the method.
           # We check for override second because `instance_method_already_implemented?`
@@ -373,7 +373,7 @@ module ActiveModel
       #   person.name_short? # => NoMethodError
       #   person.first_name  # => NoMethodError
       def undefine_attribute_methods
-        generated_attribute_methods.module_eval do
+        @generated_attribute_methods&.module_eval do
           undef_method(*instance_methods)
         end
         attribute_method_patterns_cache.clear
@@ -402,7 +402,7 @@ module ActiveModel
         end
 
         def instance_method_already_implemented?(method_name)
-          generated_attribute_methods.method_defined?(method_name)
+          @generated_attribute_methods&.method_defined?(method_name)
         end
 
         # The methods +method_missing+ and +respond_to?+ of this module are

data/lib/active_model/attribute_mutation_tracker.rb

@@ -5,7 +5,7 @@ require "active_support/core_ext/object/duplicable"
 
 module ActiveModel
   class AttributeMutationTracker # :nodoc:
-    OPTION_NOT_GIVEN = Object.new
+    OPTION_NOT_GIVEN = Object.new.freeze
 
     def initialize(attributes)
       @attributes = attributes
@@ -16,17 +16,17 @@ module ActiveModel
     end
 
     def changed_values
-      attr_names.each_with_object({}.with_indifferent_access) do |attr_name, result|
+      attr_names.each_with_object(ActiveSupport::HashWithIndifferentAccess.new) do |attr_name, result|
         if changed?(attr_name)
-          result[attr_name] = original_value(attr_name)
+          result.store(attr_name, original_value(attr_name), convert_value: false)
         end
       end
     end
 
     def changes
-      attr_names.each_with_object({}.with_indifferent_access) do |attr_name, result|
+      attr_names.each_with_object(ActiveSupport::HashWithIndifferentAccess.new) do |attr_name, result|
         if change = change_to_attribute(attr_name)
-          result.merge!(attr_name => change)
+          result.store(attr_name, change, convert_value: false)
         end
       end
     end

data/lib/active_model/attribute_set.rb

@@ -71,7 +71,7 @@ module ActiveModel
     end
 
     def deep_dup
-      AttributeSet.new(attributes.deep_dup)
+      AttributeSet.new(attributes.transform_values(&:dup_or_share))
     end
 
     def initialize_dup(_)

data/lib/active_model/attributes/normalization.rb

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+module ActiveModel
+  module Attributes
+    module Normalization
+      extend ActiveSupport::Concern
+
+      included do
+        include ActiveModel::Dirty
+        include ActiveModel::Validations::Callbacks
+
+        class_attribute :normalized_attributes, default: Set.new
+
+        before_validation :normalize_changed_in_place_attributes
+      end
+
+      # Normalizes a specified attribute using its declared normalizations.
+      #
+      # ==== Examples
+      #
+      #   class User
+      #     include ActiveModel::Attributes
+      #     include ActiveModel::Attributes::Normalization
+      #
+      #     attribute :email, :string
+      #
+      #     normalizes :email, with: -> email { email.strip.downcase }
+      #   end
+      #
+      #   legacy_user = User.load_from_legacy_data(...)
+      #   legacy_user.email # => " CRUISE-CONTROL@EXAMPLE.COM\n"
+      #   legacy_user.normalize_attribute(:email)
+      #   legacy_user.email # => "cruise-control@example.com"
+      #
+      # ==== Behavior with Active Record
+      #
+      # To prevent confusion, normalization will not be applied
+      # when the attribute is fetched from the database. This means that if a
+      # record was persisted before the normalization was declared, the record's
+      # attribute will not be normalized until either it is assigned a new
+      # value, or it is explicitly migrated via Normalization#normalize_attribute.
+      #
+      # Be aware that if your app was created before Rails 7.1, and your app
+      # marshals instances of the targeted model (for example, when caching),
+      # then you should set ActiveRecord.marshalling_format_version to +7.1+ or
+      # higher via either <tt>config.load_defaults 7.1</tt> or
+      # <tt>config.active_record.marshalling_format_version = 7.1</tt>.
+      # Otherwise, +Marshal+ may attempt to serialize the normalization +Proc+
+      # and raise +TypeError+.
+      #
+      #   class User < ActiveRecord::Base
+      #     normalizes :email, with: -> email { email.strip.downcase }
+      #     normalizes :phone, with: -> phone { phone.delete("^0-9").delete_prefix("1") }
+      #   end
+      #
+      #   user = User.create(email: " CRUISE-CONTROL@EXAMPLE.COM\n")
+      #   user.email                  # => "cruise-control@example.com"
+      #
+      #   user = User.find_by(email: "\tCRUISE-CONTROL@EXAMPLE.COM ")
+      #   user.email                  # => "cruise-control@example.com"
+      #   user.email_before_type_cast # => "cruise-control@example.com"
+      #
+      #   User.where(email: "\tCRUISE-CONTROL@EXAMPLE.COM ").count         # => 1
+      #   User.where(["email = ?", "\tCRUISE-CONTROL@EXAMPLE.COM "]).count # => 0
+      #
+      #   User.exists?(email: "\tCRUISE-CONTROL@EXAMPLE.COM ")         # => true
+      #   User.exists?(["email = ?", "\tCRUISE-CONTROL@EXAMPLE.COM "]) # => false
+      #
+      #   User.normalize_value_for(:phone, "+1 (555) 867-5309") # => "5558675309"
+      def normalize_attribute(name)
+        # Treat the value as a new, unnormalized value.
+        send(:"#{name}=", send(name))
+      end
+
+      module ClassMethods
+        # Declares a normalization for one or more attributes. The normalization
+        # is applied when the attribute is assigned or validated.
+        #
+        # Because the normalization may be applied multiple times, it should be
+        # _idempotent_. In other words, applying the normalization more than once
+        # should have the same result as applying it only once.
+        #
+        # By default, the normalization will not be applied to +nil+ values. This
+        # behavior can be changed with the +:apply_to_nil+ option.
+        #
+        # ==== Options
+        #
+        # * +:with+ - Any callable object that accepts the attribute's value as
+        #   its sole argument, and returns it normalized.
+        # * +:apply_to_nil+ - Whether to apply the normalization to +nil+ values.
+        #   Defaults to +false+.
+        #
+        # ==== Examples
+        #
+        #   class User
+        #     include ActiveModel::Attributes
+        #     include ActiveModel::Attributes::Normalization
+        #
+        #     attribute :email, :string
+        #     attribute :phone, :string
+        #
+        #     normalizes :email, with: -> email { email.strip.downcase }
+        #     normalizes :phone, with: -> phone { phone.delete("^0-9").delete_prefix("1") }
+        #   end
+        #
+        #   user = User.new
+        #   user.email =    " CRUISE-CONTROL@EXAMPLE.COM\n"
+        #   user.email # => "cruise-control@example.com"
+        #
+        #   User.normalize_value_for(:phone, "+1 (555) 867-5309") # => "5558675309"
+        def normalizes(*names, with:, apply_to_nil: false)
+          decorate_attributes(names) do |name, cast_type|
+            NormalizedValueType.new(cast_type: cast_type, normalizer: with, normalize_nil: apply_to_nil)
+          end
+
+          self.normalized_attributes += names.map(&:to_sym)
+        end
+
+        # Normalizes a given +value+ using normalizations declared for +name+.
+        #
+        # ==== Examples
+        #
+        #   class User
+        #     include ActiveModel::Attributes
+        #     include ActiveModel::Attributes::Normalization
+        #
+        #     attribute :email, :string
+        #
+        #     normalizes :email, with: -> email { email.strip.downcase }
+        #   end
+        #
+        #   User.normalize_value_for(:email, " CRUISE-CONTROL@EXAMPLE.COM\n")
+        #   # => "cruise-control@example.com"
+        def normalize_value_for(name, value)
+          type_for_attribute(name).cast(value)
+        end
+      end
+
+      private
+        def normalize_changed_in_place_attributes
+          self.class.normalized_attributes.each do |name|
+            normalize_attribute(name) if attribute_changed_in_place?(name)
+          end
+        end
+
+        class NormalizedValueType < DelegateClass(ActiveModel::Type::Value) # :nodoc:
+          include ActiveModel::Type::SerializeCastValue
+
+          attr_reader :cast_type, :normalizer, :normalize_nil
+          alias :normalize_nil? :normalize_nil
+
+          def initialize(cast_type:, normalizer:, normalize_nil:)
+            @cast_type = cast_type
+            @normalizer = normalizer
+            @normalize_nil = normalize_nil
+            super(cast_type)
+          end
+
+          def cast(value)
+            normalize(super(value))
+          end
+
+          def serialize(value)
+            serialize_cast_value(cast(value))
+          end
+
+          def serialize_cast_value(value)
+            ActiveModel::Type::SerializeCastValue.serialize(cast_type, value)
+          end
+
+          def ==(other)
+            self.class == other.class &&
+              normalize_nil? == other.normalize_nil? &&
+              normalizer == other.normalizer &&
+              cast_type == other.cast_type
+          end
+          alias eql? ==
+
+          def hash
+            [self.class, cast_type, normalizer, normalize_nil?].hash
+          end
+
+          define_method(:inspect, Kernel.instance_method(:inspect))
+
+          private
+            def normalize(value)
+              normalizer.call(value) unless value.nil? && !normalize_nil?
+            end
+        end
+    end
+  end
+end

data/lib/active_model/conversion.rb

@@ -3,7 +3,7 @@
 module ActiveModel
   # = Active \Model \Conversion
   #
-  # Handles default conversions: to_model, to_key, to_param, and to_partial_path.
+  # Handles default conversions: #to_model, #to_key, #to_param, and #to_partial_path.
   #
   # Let's take for example this non-persisted object.
   #

data/lib/active_model/dirty.rb

@@ -108,7 +108,7 @@ module ActiveModel
   #   person.changes # => {"name" => ["Bill", "Bob"]}
   #
   # If an attribute is modified in-place then make use of
-  # {*_will_change!}[rdoc-label:method-i-2A_will_change-21] to mark that the attribute is changing.
+  # {*_will_change!}[rdoc-ref:#*_will_change!] to mark that the attribute is changing.
   # Otherwise \Active \Model can't track changes to in-place attributes. Note
   # that Active Record can detect in-place modifications automatically. You do
   # not need to call <tt>*_will_change!</tt> on Active Record models.
@@ -247,16 +247,23 @@ module ActiveModel
 
     def initialize_dup(other) # :nodoc:
       super
+      @mutations_from_database = nil
+    end
+
+    def init_attributes(other) # :nodoc:
+      attrs = super
       if self.class.respond_to?(:_default_attributes)
-        @attributes = self.class._default_attributes.map do |attr|
-          attr.with_value_from_user(@attributes.fetch_value(attr.name))
+        self.class._default_attributes.map do |attr|
+          attr.with_value_from_user(attrs.fetch_value(attr.name))
         end
+      else
+        attrs
       end
-      @mutations_from_database = nil
     end
 
     def as_json(options = {}) # :nodoc:
-      options[:except] = [*options[:except], "mutations_from_database", "mutations_before_last_save"]
+      except = [*options[:except], "mutations_from_database", "mutations_before_last_save"]
+      options = options.merge except: except
       super(options)
     end
 
@@ -289,22 +296,22 @@ module ActiveModel
       mutations_from_database.changed_attribute_names
     end
 
-    # Dispatch target for {*_changed?}[rdoc-label:method-i-2A_changed-3F] attribute methods.
+    # Dispatch target for {*_changed?}[rdoc-ref:#*_changed?] attribute methods.
     def attribute_changed?(attr_name, **options)
       mutations_from_database.changed?(attr_name.to_s, **options)
     end
 
-    # Dispatch target for {*_was}[rdoc-label:method-i-2A_was] attribute methods.
+    # Dispatch target for {*_was}[rdoc-ref:#*_was] attribute methods.
     def attribute_was(attr_name)
       mutations_from_database.original_value(attr_name.to_s)
     end
 
-    # Dispatch target for {*_previously_changed?}[rdoc-label:method-i-2A_previously_changed-3F] attribute methods.
+    # Dispatch target for {*_previously_changed?}[rdoc-ref:#*_previously_changed?] attribute methods.
     def attribute_previously_changed?(attr_name, **options)
       mutations_before_last_save.changed?(attr_name.to_s, **options)
     end
 
-    # Dispatch target for {*_previously_was}[rdoc-label:method-i-2A_previously_was] attribute methods.
+    # Dispatch target for {*_previously_was}[rdoc-ref:#*_previously_was] attribute methods.
     def attribute_previously_was(attr_name)
       mutations_before_last_save.original_value(attr_name.to_s)
     end

data/lib/active_model/error.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "active_support/core_ext/class/attribute"
 
 module ActiveModel
   # = Active \Model \Error
@@ -83,7 +82,7 @@ module ActiveModel
         defaults << :"#{i18n_scope}.errors.messages.#{type}"
 
         catch(:exception) do
-          translation = I18n.translate(defaults.first, **options.merge(default: defaults.drop(1), throw: true))
+          translation = I18n.translate(defaults.first, **options, default: defaults.drop(1), throw: true)
           return translation unless translation.nil?
         end unless options[:message]
       else
@@ -205,4 +204,6 @@ module ActiveModel
         [@base, @attribute, @raw_type, @options.except(*CALLBACKS_OPTIONS)]
       end
   end
+
+  ActiveSupport.run_load_hooks(:active_model_error, Error)
 end

data/lib/active_model/errors.rb

@@ -5,7 +5,6 @@ require "active_support/core_ext/string/inflections"
 require "active_support/core_ext/object/deep_dup"
 require "active_model/error"
 require "active_model/nested_error"
-require "forwardable"
 
 module ActiveModel
   # = Active \Model \Errors
@@ -61,8 +60,6 @@ module ActiveModel
   class Errors
     include Enumerable
 
-    extend Forwardable
-
     ##
     # :method: each
     #
@@ -100,7 +97,7 @@ module ActiveModel
     #
     # Returns number of errors.
 
-    def_delegators :@errors, :each, :clear, :empty?, :size, :uniq!
+    delegate :each, :clear, :empty?, :size, :uniq!, to: :@errors
 
     # The actual array of +Error+ objects
     # This method is aliased to <tt>objects</tt>.

data/lib/active_model/gem_version.rb

@@ -7,10 +7,10 @@ module ActiveModel
   end
 
   module VERSION
-    MAJOR = 7
-    MINOR = 2
+    MAJOR = 8
+    MINOR = 1
     TINY  = 2
-    PRE   = "1"
+    PRE   = nil
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
   end

data/lib/active_model/lint.rb

@@ -30,7 +30,7 @@ module ActiveModel
       # of the model, and is used to a generate unique DOM id for the object.
       def test_to_key
         assert_respond_to model, :to_key
-        def model.persisted?() false end
+        def_method(model, :persisted?) { false }
         assert model.to_key.nil?, "to_key should return nil when `persisted?` returns false"
       end
 
@@ -45,8 +45,8 @@ module ActiveModel
       # any of the possible implementation strategies on the implementer.
       def test_to_param
         assert_respond_to model, :to_param
-        def model.to_key() [1] end
-        def model.persisted?() false end
+        def_method(model, :to_key) { [1] }
+        def_method(model, :persisted?) { false }
         assert model.to_param.nil?, "to_param should return nil when `persisted?` returns false"
       end
 
@@ -105,6 +105,10 @@ module ActiveModel
       end
 
       private
+        def def_method(receiver, name, &block)
+          ::Object.instance_method(:define_singleton_method).bind_call(receiver, name, &block)
+        end
+
         def model
           assert_respond_to @model, :to_model
           @model.to_model

data/lib/active_model/model.rb

@@ -54,7 +54,7 @@ module ActiveModel
     #
     #   person = Person.new(id: 1, name: "bob")
     #   person.slice(:id, :name)
-    #   => { "id" => 1, "name" => "bob" }
+    #   # => { "id" => 1, "name" => "bob" }
     #
     #--
     # Implemented by ActiveModel::Access#slice.
@@ -68,7 +68,7 @@ module ActiveModel
     #
     #   person = Person.new(id: 1, name: "bob")
     #   person.values_at(:id, :name)
-    #   => [1, "bob"]
+    #   # => [1, "bob"]
     #
     #--
     # Implemented by ActiveModel::Access#values_at.

data/lib/active_model/naming.rb

@@ -3,7 +3,6 @@
 require "active_support/core_ext/hash/except"
 require "active_support/core_ext/module/introspection"
 require "active_support/core_ext/module/redefine_method"
-require "active_support/core_ext/module/delegation"
 
 module ActiveModel
   class Name