activemodel 8.0.2.1 → 8.1.0.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c988bbf0305fd8d20b9c86ef0f1543210703caf7d1be7e2be8d2f340313a02b2
-  data.tar.gz: 15a95a56369475bbc7405169654171cdfcf72811d09392336b20c05a444b5ac8
+  metadata.gz: d0477968c49c9249ac55371d34c8035ada03438da3b79f12d53f29179913018a
+  data.tar.gz: e9481d73df257802b3b69b46837b9806417f2244ecb672c397a2dc9944528799
 SHA512:
-  metadata.gz: 796c0ae9f3004ef5fd0f2562864a571e34eba8eedfed3dd40f211df7171274e760de8f8dce8f9907e61b31fdb1838e6c4796ac0adfa0e48898ff101e385f62d6
-  data.tar.gz: ed3de7df1c7d0e832a81c2c69e0b19ad0c722dea9e0725ed1cc47ded182ae2b08647a4bf07c55302aba06cac780920913900ce1fd4afd4674b81b0754cc7b934
+  metadata.gz: 652d349baa6d7d2354878e7e70300036f6529ca8a0e5ef700eca8ed58e936b3d2fa18f293dc69aba2ba3ed7c54bec30631b23070969f7e9e57c18e663f289e15
+  data.tar.gz: c188746810b0ce0b3645cbc32d288c16864eed5c1ce1c1569a5f6d0aa93b4d761e68bfacb77956be90a3de7449f60d6467813c74e3115a5baddd618190013ea9

data/CHANGELOG.md

@@ -1,125 +1,26 @@
-## Rails 8.0.2.1 (August 13, 2025) ##
+## Rails 8.1.0.beta1 (September 04, 2025) ##
 
-*   No changes.
+*   Add `except_on:` option for validation callbacks.
 
+    *Ben Sheldon*
 
-## Rails 8.0.2 (March 12, 2025) ##
-
-*   No changes.
-
-
-## Rails 8.0.2 (March 12, 2025) ##
-
-*   No changes.
-
-
-## Rails 8.0.1 (December 13, 2024) ##
-
-*   No changes.
-
-
-## Rails 8.0.0.1 (December 10, 2024) ##
-
-*   No changes.
-
-
-## Rails 8.0.0 (November 07, 2024) ##
-
-*   No changes.
-
-
-## Rails 8.0.0.rc2 (October 30, 2024) ##
-
-*   No changes.
-
-
-## Rails 8.0.0.rc1 (October 19, 2024) ##
-
-*   Add `:except_on` option for validations. Grants the ability to _skip_ validations in specified contexts.
-
-    ```ruby
-    class User < ApplicationRecord
-        #...
-        validates :birthday, presence: { except_on: :admin }
-        #...
-    end
-
-    user = User.new(attributes except birthday)
-    user.save(context: :admin)
-    ```
-
-    *Drew Bragg*
-
-## Rails 8.0.0.beta1 (September 26, 2024) ##
-
-*   Make `ActiveModel::Serialization#read_attribute_for_serialization` public
-
-    *Sean Doyle*
-
-*   Add a default token generator for password reset tokens when using `has_secure_password`.
-
-    ```ruby
-    class User < ApplicationRecord
-      has_secure_password
-    end
-
-    user = User.create!(name: "david", password: "123", password_confirmation: "123")
-    token = user.password_reset_token
-    User.find_by_password_reset_token(token) # returns user
-
-    # 16 minutes later...
-    User.find_by_password_reset_token(token) # returns nil
-
-    # raises ActiveSupport::MessageVerifier::InvalidSignature since the token is expired
-    User.find_by_password_reset_token!(token)
-    ```
-
-    *DHH*
-
-*   Add a load hook `active_model_translation` for `ActiveModel::Translation`.
-
-    *Shouichi Kamiya*
-
-*   Add `raise_on_missing_translations` option to `ActiveModel::Translation`.
-    When the option is set, `human_attribute_name` raises an error if a translation of the given attribute is missing.
-
-    ```ruby
-    # ActiveModel::Translation.raise_on_missing_translations = false
-    Post.human_attribute_name("title")
-    => "Title"
-
-    # ActiveModel::Translation.raise_on_missing_translations = true
-    Post.human_attribute_name("title")
-    => Translation missing. Options considered were: (I18n::MissingTranslationData)
-        - en.activerecord.attributes.post.title
-        - en.attributes.title
-
-                raise exception.respond_to?(:to_exception) ? exception.to_exception : exception
-                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-    ```
-
-    *Shouichi Kamiya*
-
-*   Introduce `ActiveModel::AttributeAssignment#attribute_writer_missing`
-
-    Provide instances with an opportunity to gracefully handle assigning to an
-    unknown attribute:
+*   Backport `ActiveRecord::Normalization` to `ActiveModel::Attributes::Normalization`
 
     ```ruby
-    class Rectangle
-      include ActiveModel::AttributeAssignment
+    class User
+      include ActiveModel::Attributes
+      include ActiveModel::Attributes::Normalization
 
-      attr_accessor :length, :width
+      attribute :email, :string
 
-      def attribute_writer_missing(name, value)
-        Rails.logger.warn "Tried to assign to unknown attribute #{name}"
-      end
+      normalizes :email, with: -> email { email.strip.downcase }
     end
 
-    rectangle = Rectangle.new
-    rectangle.assign_attributes(height: 10) # => Logs "Tried to assign to unknown attribute 'height'"
+    user = User.new
+    user.email =    " CRUISE-CONTROL@EXAMPLE.COM\n"
+    user.email # => "cruise-control@example.com"
     ```
 
     *Sean Doyle*
 
-Please check [7-2-stable](https://github.com/rails/rails/blob/7-2-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_methods.rb

@@ -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.transform_values(&: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/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.
@@ -252,7 +252,7 @@ module ActiveModel
 
     def init_attributes(other) # :nodoc:
       attrs = super
-      if other.persisted? && self.class.respond_to?(:_default_attributes)
+      if self.class.respond_to?(:_default_attributes)
         self.class._default_attributes.map do |attr|
           attr.with_value_from_user(attrs.fetch_value(attr.name))
         end
@@ -296,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

@@ -8,9 +8,9 @@ module ActiveModel
 
   module VERSION
     MAJOR = 8
-    MINOR = 0
-    TINY  = 2
-    PRE   = "1"
+    MINOR = 1
+    TINY  = 0
+    PRE   = "beta1"
 
     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

data/lib/active_model/nested_error.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "active_model/error"
-require "forwardable"
 
 module ActiveModel
   class NestedError < Error
@@ -16,7 +15,6 @@ module ActiveModel
 
     attr_reader :inner_error
 
-    extend Forwardable
-    def_delegators :@inner_error, :message
+    delegate :message, to: :@inner_error
   end
 end

data/lib/active_model/railtie.rb

@@ -14,11 +14,15 @@ module ActiveModel
     end
 
     initializer "active_model.secure_password" do
-      ActiveModel::SecurePassword.min_cost = Rails.env.test?
+      ActiveSupport.on_load(:active_model_secure_password) do
+        ActiveModel::SecurePassword.min_cost = Rails.env.test?
+      end
     end
 
-    initializer "active_model.i18n_customize_full_message" do
-      ActiveModel::Error.i18n_customize_full_message = config.active_model.delete(:i18n_customize_full_message) || false
+    initializer "active_model.i18n_customize_full_message" do |app|
+      ActiveSupport.on_load(:active_model_error) do
+        ActiveModel::Error.i18n_customize_full_message = app.config.active_model.i18n_customize_full_message || false
+      end
     end
   end
 end

data/lib/active_model/secure_password.rb

@@ -155,7 +155,7 @@ module ActiveModel
             end
           end
 
-          validates_confirmation_of attribute, allow_blank: true
+          validates_confirmation_of attribute, allow_nil: true
         end
 
         # Only generate tokens for records that are capable of doing so (Active Records, not vanilla Active Models)
@@ -228,4 +228,6 @@ module ActiveModel
       end
     end
   end
+
+  ActiveSupport.run_load_hooks(:active_model_secure_password, SecurePassword)
 end

data/lib/active_model/type/big_integer.rb

@@ -23,10 +23,31 @@ module ActiveModel
     # All casting and serialization are performed in the same way as the
     # standard ActiveModel::Type::Integer type.
     class BigInteger < Integer
+      def serialize(value) # :nodoc:
+        case value
+        when ::Integer
+          # noop
+        when ::String
+          int = value.to_i
+          if int.zero? && value != "0"
+            return if non_numeric_string?(value)
+          end
+          value = int
+        else
+          value = super
+        end
+
+        value
+      end
+
       def serialize_cast_value(value) # :nodoc:
         value
       end
 
+      def serializable?(value, &)
+        true
+      end
+
       private
         def max_value
           ::Float::INFINITY

data/lib/active_model/type/boolean.rb

@@ -12,6 +12,7 @@ module ActiveModel
     # - Empty strings are coerced to +nil+.
     # - All other values will be coerced to +true+.
     class Boolean < Value
+      include Helpers::Immutable
       FALSE_VALUES = [
         false, 0,
         "0", :"0",

data/lib/active_model/type/date.rb

@@ -24,6 +24,7 @@ module ActiveModel
     # String values are parsed using the ISO 8601 date format. Any other values
     # are cast using their +to_date+ method, if it exists.
     class Date < Value
+      include Helpers::Immutable
       include Helpers::Timezone
       include Helpers::AcceptsMultiparameterTime.new
 

data/lib/active_model/type/date_time.rb

@@ -50,6 +50,14 @@ module ActiveModel
         :datetime
       end
 
+      def mutable? # :nodoc:
+        # Time#zone can be mutated by #utc or #localtime
+        # However when serializing the time zone will always
+        # be coerced and even if the zone was mutated Time instances
+        # remain equal, so we don't need to implement `#changed_in_place?`
+        true
+      end
+
       private
         def cast_value(value)
           return apply_seconds_precision(value) unless value.is_a?(::String)

data/lib/active_model/type/decimal.rb

@@ -43,6 +43,7 @@ module ActiveModel
     #     attribute :weight, :decimal, precision: 24
     #   end
     class Decimal < Value
+      include Helpers::Immutable
       include Helpers::Numeric
       BIGDECIMAL_PRECISION = 18
 

data/lib/active_model/type/float.rb

@@ -34,6 +34,7 @@ module ActiveModel
     # - <tt>"-Infinity"</tt> is cast to <tt>-Float::INFINITY</tt>.
     # - <tt>"NaN"</tt> is cast to +Float::NAN+.
     class Float < Value
+      include Helpers::Immutable
       include Helpers::Numeric
 
       def type

data/lib/active_model/type/helpers/immutable.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module ActiveModel
+  module Type
+    module Helpers # :nodoc: all
+      module Immutable
+        def mutable? # :nodoc:
+          false
+        end
+      end
+    end
+  end
+end

data/lib/active_model/type/helpers.rb

@@ -3,5 +3,6 @@
 require "active_model/type/helpers/accepts_multiparameter_time"
 require "active_model/type/helpers/numeric"
 require "active_model/type/helpers/mutable"
+require "active_model/type/helpers/immutable"
 require "active_model/type/helpers/time_value"
 require "active_model/type/helpers/timezone"

data/lib/active_model/type/immutable_string.rb

@@ -35,6 +35,8 @@ module ActiveModel
     #
     #   person.active # => "aye"
     class ImmutableString < Value
+      include Helpers::Immutable
+
       def initialize(**args)
         @true  = -(args.delete(:true)&.to_s  || "t")
         @false = -(args.delete(:false)&.to_s || "f")

data/lib/active_model/type/integer.rb

@@ -42,6 +42,7 @@ module ActiveModel
     #     attribute :age, :integer, limit: 6
     #   end
     class Integer < Value
+      include Helpers::Immutable
       include Helpers::Numeric
 
       # Column storage size in bytes.
@@ -50,7 +51,8 @@ module ActiveModel
 
       def initialize(**)
         super
-        @range = min_value...max_value
+        @max = max_value
+        @min = min_value
       end
 
       def type
@@ -63,40 +65,50 @@ module ActiveModel
       end
 
       def serialize(value)
-        return if value.is_a?(::String) && non_numeric_string?(value)
-        ensure_in_range(super)
+        case value
+        when ::Integer
+          # noop
+        when ::String
+          int = value.to_i
+          if int.zero? && value != "0"
+            return if non_numeric_string?(value)
+          end
+          value = int
+        else
+          value = super
+        end
+
+        if out_of_range?(value)
+          raise ActiveModel::RangeError, "#{value} is out of range for #{self.class} with limit #{_limit} bytes"
+        end
+
+        value
       end
 
       def serialize_cast_value(value) # :nodoc:
-        ensure_in_range(value)
+        if out_of_range?(value)
+          raise ActiveModel::RangeError, "#{value} is out of range for #{self.class} with limit #{_limit} bytes"
+        end
+
+        value
       end
 
       def serializable?(value)
         cast_value = cast(value)
-        in_range?(cast_value) || begin
-          yield cast_value if block_given?
-          false
-        end
+        return true unless out_of_range?(cast_value)
+        yield cast_value if block_given?
+        false
       end
 
       private
-        attr_reader :range
-
-        def in_range?(value)
-          !value || range.member?(value)
+        def out_of_range?(value)
+          value && (@max <= value || @min > value)
         end
 
         def cast_value(value)
           value.to_i rescue nil
         end
 
-        def ensure_in_range(value)
-          unless in_range?(value)
-            raise ActiveModel::RangeError, "#{value} is out of range for #{self.class} with limit #{_limit} bytes"
-          end
-          value
-        end
-
         def max_value
           1 << (_limit * 8 - 1) # 8 bits per byte with one bit for sign
         end

data/lib/active_model/type/string.rb

@@ -19,6 +19,10 @@ module ActiveModel
         end
       end
 
+      def mutable? # :nodoc:
+        true
+      end
+
       def to_immutable_string
         ImmutableString.new(
           true: @true,

data/lib/active_model/type/value.rb

@@ -25,7 +25,7 @@ module ActiveModel
       # by the database.  For example a boolean type can return +true+ if the
       # value parameter is a Ruby boolean, but may return +false+ if the value
       # parameter is some other object.
-      def serializable?(value, &_)
+      def serializable?(value, &)
         true
       end
 
@@ -138,7 +138,7 @@ module ActiveModel
       end
 
       def mutable? # :nodoc:
-        false
+        true
       end
 
       def as_json(*)

data/lib/active_model/validations/callbacks.rb

@@ -106,6 +106,16 @@ module ActiveModel
                 *options[:if]
               ]
             end
+
+            if options.key?(:except_on)
+              options[:except_on] = Array(options[:except_on])
+              options[:unless] = [
+                ->(o) {
+                  options[:except_on].intersect?(Array(o.validation_context))
+                },
+                *options[:unless]
+              ]
+            end
           end
       end
 

data/lib/active_model/validations.rb

@@ -63,7 +63,8 @@ module ActiveModel
       #     end
       #   end
       #
-      # Options:
+      # ==== Options
+      #
       # * <tt>:on</tt> - Specifies the contexts where this validation is active.
       #   Runs in all validation contexts by default +nil+. You can pass a symbol
       #   or an array of symbols. (e.g. <tt>on: :create</tt> or
@@ -134,7 +135,8 @@ module ActiveModel
       # Note that the return value of validation methods is not relevant.
       # It's not possible to halt the validate callback chain.
       #
-      # Options:
+      # ==== Options
+      #
       # * <tt>:on</tt> - Specifies the contexts where this validation is active.
       #   Runs in all validation contexts by default +nil+. You can pass a symbol
       #   or an array of symbols. (e.g. <tt>on: :create</tt> or
@@ -437,20 +439,6 @@ module ActiveModel
     alias :read_attribute_for_validation :send
 
     # Returns the context when running validations.
-    #
-    # This is useful when running validations except a certain context (opposite to the +on+ option).
-    #
-    #   class Person
-    #     include ActiveModel::Validations
-    #
-    #     attr_accessor :name
-    #     validates :name, presence: true, if: -> { validation_context != :custom }
-    #   end
-    #
-    #   person = Person.new
-    #   person.valid?          #=> false
-    #   person.valid?(:new)    #=> false
-    #   person.valid?(:custom) #=> true
     def validation_context
       context_for_validation.context
     end

data/lib/active_model.rb

@@ -56,6 +56,12 @@ module ActiveModel
   autoload :Validations
   autoload :Validator
 
+  module Attributes
+    extend ActiveSupport::Autoload
+
+    autoload :Normalization
+  end
+
   eager_autoload do
     autoload :Errors
     autoload :Error

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: activemodel
 version: !ruby/object:Gem::Version
-  version: 8.0.2.1
+  version: 8.1.0.beta1
 platform: ruby
 authors:
 - David Heinemeier Hansson
@@ -15,14 +15,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 8.0.2.1
+        version: 8.1.0.beta1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 8.0.2.1
+        version: 8.1.0.beta1
 description: A toolkit for building modeling frameworks like Active Record. Rich support
   for attributes, callbacks, validations, serialization, internationalization, and
   testing.
@@ -47,6 +47,7 @@ files:
 - lib/active_model/attribute_set/builder.rb
 - lib/active_model/attribute_set/yaml_encoder.rb
 - lib/active_model/attributes.rb
+- lib/active_model/attributes/normalization.rb
 - lib/active_model/callbacks.rb
 - lib/active_model/conversion.rb
 - lib/active_model/deprecator.rb
@@ -75,6 +76,7 @@ files:
 - lib/active_model/type/float.rb
 - lib/active_model/type/helpers.rb
 - lib/active_model/type/helpers/accepts_multiparameter_time.rb
+- lib/active_model/type/helpers/immutable.rb
 - lib/active_model/type/helpers/mutable.rb
 - lib/active_model/type/helpers/numeric.rb
 - lib/active_model/type/helpers/time_value.rb
@@ -111,10 +113,10 @@ licenses:
 - MIT
 metadata:
   bug_tracker_uri: https://github.com/rails/rails/issues
-  changelog_uri: https://github.com/rails/rails/blob/v8.0.2.1/activemodel/CHANGELOG.md
-  documentation_uri: https://api.rubyonrails.org/v8.0.2.1/
+  changelog_uri: https://github.com/rails/rails/blob/v8.1.0.beta1/activemodel/CHANGELOG.md
+  documentation_uri: https://api.rubyonrails.org/v8.1.0.beta1/
   mailing_list_uri: https://discuss.rubyonrails.org/c/rubyonrails-talk
-  source_code_uri: https://github.com/rails/rails/tree/v8.0.2.1/activemodel
+  source_code_uri: https://github.com/rails/rails/tree/v8.1.0.beta1/activemodel
   rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths: