activemodel 7.2.1.1 → 8.0.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e589e4c3a8a7002f27353fdc043d9f8662774b0c073e57834e13ced5a4aa8ccc
-  data.tar.gz: '059bf63fbcb6b05e9744c9d3066b2bfb50c5d00e7ddeed96635cd9a4de592d06'
+  metadata.gz: cff9ce182fe19b1ba44acb21c565c8527602855ad42582c68ca865c6c7808418
+  data.tar.gz: ac9f1b90cdad91c42d192ccd31fff45f96236a05dfab084a6846a1bba2881f31
 SHA512:
-  metadata.gz: cb4eaa35dddcd45300236499be5d319f5605cf6708260e49ef2a29984374868eaf30ab7d60dc7879b67c84be0ead2af83b4426ced1e39d928dae7e3ebc573c2b
-  data.tar.gz: b9aa71fa74d17e3b169ad035e02bff7bc6254b9e8a6f69608e49f90d3173a2e2349049aba9b897c2b98e25f977a08aa9c20152295f35aecdd61eb309fca69710
+  metadata.gz: f1cd9e0aabc319cfa3b73d3951470b2c31adedc2aafc11a5cd25a13ddaa7f346db103d6351009bd0f681184e8fbf840358df747b808e59e2857133bd6e372561
+  data.tar.gz: 917d12bda8d9f7f7f442897256fd046d27f29ca0f8a28aee17c68773cf48772f0142f30603af455f952ec1a308a20b4fc70367eba3dcabaa28cb1c24397eccef

data/CHANGELOG.md

@@ -1,34 +1,90 @@
-## Rails 7.2.1.1 (October 15, 2024) ##
+## Rails 8.0.0.rc1 (October 19, 2024) ##
 
-*   No changes.
+*   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
 
-## Rails 7.2.1 (August 22, 2024) ##
+    user = User.new(attributes except birthday)
+    user.save(context: :admin)
+    ```
 
-*   No changes.
+    *Drew Bragg*
 
+## Rails 8.0.0.beta1 (September 26, 2024) ##
 
-## Rails 7.2.0 (August 09, 2024) ##
+*   Make `ActiveModel::Serialization#read_attribute_for_serialization` public
 
-*   Fix a bug where type casting of string to `Time` and `DateTime` doesn't
-    calculate minus minute value in TZ offset correctly.
+    *Sean Doyle*
 
-    *Akira Matsuda*
+*   Add a default token generator for password reset tokens when using `has_secure_password`.
 
-*   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 < ApplicationRecord
+      has_secure_password
+    end
 
-      ```ruby
-      class MyModel
-        include ActiveModel::Attributes
+    user = User.create!(name: "david", password: "123", password_confirmation: "123")
+    token = user.password_reset_token
+    User.find_by_password_reset_token(token) # returns user
 
-        attribute :my_attribute, :integer
+    # 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:
+
+    ```ruby
+    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
 
-      MyModel.type_for_attribute(:my_attribute) # => #<ActiveModel::Type::Integer ...>
-      ```
+    rectangle = Rectangle.new
+    rectangle.assign_attributes(height: 10) # => Logs "Tried to assign to unknown attribute 'height'"
+    ```
 
-    *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 [7-2-stable](https://github.com/rails/rails/blob/7-2-stable/activemodel/CHANGELOG.md) for previous changes.

data/lib/active_model/attribute_assignment.rb

@@ -36,6 +36,27 @@ 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|
@@ -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

@@ -215,7 +215,12 @@ module ActiveModel
       end
 
       def generate_alias_attribute_methods(code_generator, new_name, old_name)
-        define_attribute_method(old_name, _owner: code_generator, as: new_name)
+        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)
+          end
+          attribute_method_patterns_cache.clear
+        end
       end
 
       def alias_attribute_method_definition(code_generator, pattern, new_name, old_name) # :nodoc:
@@ -228,7 +233,7 @@ module ActiveModel
         call_args = []
         call_args << parameters if parameters
 
-        define_call(code_generator, method_name, target_name, mangled_name, parameters, call_args, namespace: :alias_attribute)
+        define_call(code_generator, method_name, target_name, mangled_name, parameters, call_args, namespace: :alias_attribute, as: method_name)
       end
 
       # Is +new_name+ an alias?
@@ -441,7 +446,7 @@ module ActiveModel
           mangled_name = name
 
           unless NAME_COMPILABLE_REGEXP.match?(name)
-            mangled_name = "__temp__#{name.unpack1("h*")}"
+            mangled_name = :"__temp__#{name.unpack1("h*")}"
           end
 
           mangled_name

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(&:deep_dup))
     end
 
     def initialize_dup(_)

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

@@ -247,16 +247,23 @@ module ActiveModel
 
     def initialize_dup(other) # :nodoc:
       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))
+      @mutations_from_database = nil
+    end
+
+    def init_attributes(other) # :nodoc:
+      attrs = super
+      if other.persisted? && self.class.respond_to?(:_default_attributes)
+        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
 

data/lib/active_model/gem_version.rb

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

data/lib/active_model/secure_password.rb

@@ -39,6 +39,10 @@ module ActiveModel
       # <tt>validations: false</tt> as an argument. This allows complete
       # customizability of validation behavior.
       #
+      # Finally, a password reset token that's valid for 15 minutes after issue
+      # is automatically configured when +reset_token+ is set to true (which it is by default)
+      # and the object reponds to +generates_token_for+ (which Active Records do).
+      #
       # To use +has_secure_password+, add bcrypt (~> 3.1.7) to your Gemfile:
       #
       #   gem "bcrypt", "~> 3.1.7"
@@ -98,7 +102,18 @@ module ActiveModel
       #   account.is_guest = true
       #   account.valid? # => true
       #
-      def has_secure_password(attribute = :password, validations: true)
+      # ===== Using the password reset token
+      #
+      #   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)
+      def has_secure_password(attribute = :password, validations: true, reset_token: true)
         # Load bcrypt gem only when has_secure_password is used.
         # This is to avoid ActiveModel (and by extension the entire framework)
         # being dependent on a binary library.
@@ -109,7 +124,7 @@ module ActiveModel
           raise
         end
 
-        include InstanceMethodsOnActivation.new(attribute)
+        include InstanceMethodsOnActivation.new(attribute, reset_token: reset_token)
 
         if validations
           include ActiveModel::Validations
@@ -142,11 +157,30 @@ module ActiveModel
 
           validates_confirmation_of attribute, allow_blank: true
         end
+
+        # Only generate tokens for records that are capable of doing so (Active Records, not vanilla Active Models)
+        if reset_token && respond_to?(:generates_token_for)
+          generates_token_for :"#{attribute}_reset", expires_in: 15.minutes do
+            public_send(:"#{attribute}_salt")&.last(10)
+          end
+
+          class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            silence_redefinition_of_method :find_by_#{attribute}_reset_token
+            def self.find_by_#{attribute}_reset_token(token)
+              find_by_token_for(:#{attribute}_reset, token)
+            end
+
+            silence_redefinition_of_method :find_by_#{attribute}_reset_token!
+            def self.find_by_#{attribute}_reset_token!(token)
+              find_by_token_for!(:#{attribute}_reset, token)
+            end
+          RUBY
+        end
       end
     end
 
     class InstanceMethodsOnActivation < Module
-      def initialize(attribute)
+      def initialize(attribute, reset_token:)
         attr_reader attribute
 
         define_method("#{attribute}=") do |unencrypted_password|
@@ -184,6 +218,13 @@ module ActiveModel
         end
 
         alias_method :authenticate, :authenticate_password if attribute == :password
+
+        if reset_token
+          # Returns the class-level configured reset token for the password.
+          define_method("#{attribute}_reset_token") do
+            generate_token_for(:"#{attribute}_reset")
+          end
+        end
       end
     end
   end

data/lib/active_model/serialization.rb

@@ -29,8 +29,8 @@ module ActiveModel
   # An +attributes+ hash must be defined and should contain any attributes you
   # need to be serialized. Attributes must be strings, not symbols.
   # When called, serializable hash will use instance methods that match the name
-  # of the attributes hash's keys. In order to override this behavior, take a look
-  # at the private method +read_attribute_for_serialization+.
+  # of the attributes hash's keys. In order to override this behavior, override
+  # the +read_attribute_for_serialization+ method.
   #
   # ActiveModel::Serializers::JSON module automatically includes
   # the +ActiveModel::Serialization+ module, so there is no need to
@@ -128,7 +128,7 @@ module ActiveModel
       return serializable_attributes(attribute_names) if options.blank?
 
       if only = options[:only]
-        attribute_names &= Array(only).map(&:to_s)
+        attribute_names = Array(only).map(&:to_s) & attribute_names
       elsif except = options[:except]
         attribute_names -= Array(except).map(&:to_s)
       end
@@ -148,29 +148,29 @@ module ActiveModel
       hash
     end
 
+    # Hook method defining how an attribute value should be retrieved for
+    # serialization. By default this is assumed to be an instance named after
+    # the attribute. Override this method in subclasses should you need to
+    # retrieve the value for a given attribute differently:
+    #
+    #   class MyClass
+    #     include ActiveModel::Serialization
+    #
+    #     def initialize(data = {})
+    #       @data = data
+    #     end
+    #
+    #     def read_attribute_for_serialization(key)
+    #       @data[key]
+    #     end
+    #   end
+    alias :read_attribute_for_serialization :send
+
     private
       def attribute_names_for_serialization
         attributes.keys
       end
 
-      # Hook method defining how an attribute value should be retrieved for
-      # serialization. By default this is assumed to be an instance named after
-      # the attribute. Override this method in subclasses should you need to
-      # retrieve the value for a given attribute differently:
-      #
-      #   class MyClass
-      #     include ActiveModel::Serialization
-      #
-      #     def initialize(data = {})
-      #       @data = data
-      #     end
-      #
-      #     def read_attribute_for_serialization(key)
-      #       @data[key]
-      #     end
-      #   end
-      alias :read_attribute_for_serialization :send
-
       def serializable_attributes(attribute_names)
         attribute_names.index_with { |n| read_attribute_for_serialization(n) }
       end

data/lib/active_model/translation.rb

@@ -22,6 +22,8 @@ module ActiveModel
   module Translation
     include ActiveModel::Naming
 
+    singleton_class.attr_accessor :raise_on_missing_translations
+
     # Returns the +i18n_scope+ for the class. Override if you want custom lookup.
     def i18n_scope
       :activemodel
@@ -60,13 +62,17 @@ module ActiveModel
         end
       end
 
+      raise_on_missing = options.fetch(:raise, Translation.raise_on_missing_translations)
+
       defaults << :"attributes.#{attribute}"
       defaults << options[:default] if options[:default]
-      defaults << MISSING_TRANSLATION
+      defaults << MISSING_TRANSLATION unless raise_on_missing
 
-      translation = I18n.translate(defaults.shift, count: 1, **options, default: defaults)
+      translation = I18n.translate(defaults.shift, count: 1, raise: raise_on_missing, **options, default: defaults)
       translation = attribute.humanize if translation == MISSING_TRANSLATION
       translation
     end
   end
+
+  ActiveSupport.run_load_hooks(:active_model_translation, Translation)
 end

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

@@ -69,56 +69,32 @@ module ActiveModel
             \z
           /x
 
-          if RUBY_VERSION >= "3.2"
-            if Time.new(2000, 1, 1, 0, 0, 0, "-00:00").yday != 1 # Early 3.2.x had a bug
-              # BUG: Wrapping the Time object with Time.at because Time.new with `in:` in Ruby 3.2.0
-              # used to return an invalid Time object
-              # see: https://bugs.ruby-lang.org/issues/19292
-              def fast_string_to_time(string)
-                return unless string.include?("-") #  Time.new("1234") # => 1234-01-01 00:00:00
-
-                if is_utc?
-                  ::Time.at(::Time.new(string, in: "UTC"))
-                else
-                  ::Time.new(string)
-                end
-              rescue ArgumentError
-                nil
-              end
-            else
-              def fast_string_to_time(string)
-                return unless string.include?("-") #  Time.new("1234") # => 1234-01-01 00:00:00
-
-                if is_utc?
-                  ::Time.new(string, in: "UTC")
-                else
-                  ::Time.new(string)
-                end
-              rescue ArgumentError
-                nil
+          if Time.new(2000, 1, 1, 0, 0, 0, "-00:00").yday != 1 # Early 3.2.x had a bug
+            # BUG: Wrapping the Time object with Time.at because Time.new with `in:` in Ruby 3.2.0
+            # used to return an invalid Time object
+            # see: https://bugs.ruby-lang.org/issues/19292
+            def fast_string_to_time(string)
+              return unless string.include?("-") #  Time.new("1234") # => 1234-01-01 00:00:00
+
+              if is_utc?
+                ::Time.at(::Time.new(string, in: "UTC"))
+              else
+                ::Time.new(string)
               end
+            rescue ArgumentError
+              nil
             end
           else
             def fast_string_to_time(string)
-              return unless ISO_DATETIME =~ string
+              return unless string.include?("-") #  Time.new("1234") # => 1234-01-01 00:00:00
 
-              usec = $7.to_i
-              usec_len = $7&.length
-              if usec_len&.< 6
-                usec *= 10**(6 - usec_len)
+              if is_utc?
+                ::Time.new(string, in: "UTC")
+              else
+                ::Time.new(string)
               end
-
-              if $8
-                offset = \
-                  if $8 == "Z"
-                    0
-                  else
-                    offset_h, offset_m = $8.to_i, $9.to_i
-                    offset_h.to_i * 3600 + (offset_h.negative? ? -1 : 1) * offset_m * 60
-                  end
-              end
-
-              new_time($1.to_i, $2.to_i, $3.to_i, $4.to_i, $5.to_i, $6.to_i, usec, offset)
+            rescue ArgumentError
+              nil
             end
           end
       end

data/lib/active_model/type/value.rb

@@ -114,8 +114,8 @@ module ActiveModel
         false
       end
 
-      def map(value) # :nodoc:
-        yield value
+      def map(value, &) # :nodoc:
+        value
       end
 
       def ==(other)

data/lib/active_model/validations/validates.rb

@@ -78,7 +78,12 @@ module ActiveModel
       #   or an array of symbols. (e.g. <tt>on: :create</tt> or
       #   <tt>on: :custom_validation_context</tt> or
       #   <tt>on: [:create, :custom_validation_context]</tt>)
-      # * <tt>:if</tt> - Specifies a method, proc, or string to call to determine
+      # * <tt>:except_on</tt> - Specifies the contexts where this validation is not active.
+      #   Runs in all validation contexts by default +nil+. You can pass a symbol
+      #   or an array of symbols. (e.g. <tt>except: :create</tt> or
+      #   <tt>except_on: :custom_validation_context</tt> or
+      #   <tt>except_on: [:create, :custom_validation_context]</tt>)
+      # * <tt>:if</tt> - Specifies a method, proc or string to call to determine
       #   if the validation should occur (e.g. <tt>if: :allow_validation</tt>,
       #   or <tt>if: Proc.new { |user| user.signup_step > 2 }</tt>). The method,
       #   proc or string should return or evaluate to a +true+ or +false+ value.
@@ -155,7 +160,7 @@ module ActiveModel
       # When creating custom validators, it might be useful to be able to specify
       # additional default keys. This can be done by overwriting this method.
       def _validates_default_keys
-        [:if, :unless, :on, :allow_blank, :allow_nil, :strict]
+        [:if, :unless, :on, :allow_blank, :allow_nil, :strict, :except_on]
       end
 
       def _parse_validates_options(options)

data/lib/active_model/validations.rb

@@ -45,27 +45,6 @@ module ActiveModel
       extend  HelperMethods
       include HelperMethods
 
-      ##
-      # :method: validation_context
-      # 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
-
-      ##
-      attr_accessor :validation_context
-      private :validation_context=
       define_callbacks :validate, scope: :name
 
       class_attribute :_validators, instance_writer: false, default: Hash.new { |h, k| h[k] = [] }
@@ -90,6 +69,11 @@ module ActiveModel
       #   or an array of symbols. (e.g. <tt>on: :create</tt> or
       #   <tt>on: :custom_validation_context</tt> or
       #   <tt>on: [:create, :custom_validation_context]</tt>)
+      # * <tt>:except_on</tt> - Specifies the contexts where this validation is not active.
+      #   Runs in all validation contexts by default +nil+. You can pass a symbol
+      #   or an array of symbols. (e.g. <tt>except: :create</tt> or
+      #   <tt>except_on: :custom_validation_context</tt> or
+      #   <tt>except_on: [:create, :custom_validation_context]</tt>)
       # * <tt>:allow_nil</tt> - Skip validation if attribute is +nil+.
       # * <tt>:allow_blank</tt> - Skip validation if attribute is blank.
       # * <tt>:if</tt> - Specifies a method, proc, or string to call to determine
@@ -105,7 +89,7 @@ module ActiveModel
         validates_with BlockValidator, _merge_attributes(attr_names), &block
       end
 
-      VALID_OPTIONS_FOR_VALIDATE = [:on, :if, :unless, :prepend].freeze # :nodoc:
+      VALID_OPTIONS_FOR_VALIDATE = [:on, :if, :unless, :prepend, :except_on].freeze # :nodoc:
 
       # Adds a validation method or block to the class. This is useful when
       # overriding the +validate+ instance method becomes too unwieldy and
@@ -156,7 +140,12 @@ module ActiveModel
       #   or an array of symbols. (e.g. <tt>on: :create</tt> or
       #   <tt>on: :custom_validation_context</tt> or
       #   <tt>on: [:create, :custom_validation_context]</tt>)
-      # * <tt>:if</tt> - Specifies a method, proc, or string to call to determine
+      # * <tt>:except_on</tt> - Specifies the contexts where this validation is not active.
+      #   Runs in all validation contexts by default +nil+. You can pass a symbol
+      #   or an array of symbols. (e.g. <tt>except: :create</tt> or
+      #   <tt>except_on: :custom_validation_context</tt> or
+      #   <tt>except_on: [:create, :custom_validation_context]</tt>)
+      # * <tt>:if</tt> - Specifies a method, proc or string to call to determine
       #   if the validation should occur (e.g. <tt>if: :allow_validation</tt>,
       #   or <tt>if: Proc.new { |user| user.signup_step > 2 }</tt>). The method,
       #   proc or string should return or evaluate to a +true+ or +false+ value.
@@ -183,6 +172,15 @@ module ActiveModel
           options = options.merge(if: [predicate_for_validation_context(options[:on]), *options[:if]])
         end
 
+        if options.key?(:except_on)
+          options = options.dup
+          options[:except_on] = Array(options[:except_on])
+          options[:unless] = [
+            ->(o) { (options[:except_on] & Array(o.validation_context)).any? },
+            *options[:unless]
+          ]
+        end
+
         set_callback(:validate, *args, options, &block)
       end
 
@@ -361,15 +359,23 @@ module ActiveModel
     #   person.valid?       # => true
     #   person.valid?(:new) # => false
     def valid?(context = nil)
-      current_context, self.validation_context = validation_context, context
+      current_context = validation_context
+      context_for_validation.context = context
       errors.clear
       run_validations!
     ensure
-      self.validation_context = current_context
+      context_for_validation.context = current_context
     end
 
     alias_method :validate, :valid?
 
+    def freeze
+      errors
+      context_for_validation
+
+      super
+    end
+
     # Performs the opposite of <tt>valid?</tt>. Returns +true+ if errors were
     # added, +false+ otherwise.
     #
@@ -430,11 +436,38 @@ module ActiveModel
     #   end
     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
+
   private
+    def validation_context=(context)
+      context_for_validation.context = context
+    end
+
+    def context_for_validation
+      @context_for_validation ||= ValidationContext.new
+    end
+
     def init_internals
       super
       @errors = nil
-      @validation_context = nil
+      @context_for_validation = nil
     end
 
     def run_validations!
@@ -466,6 +499,10 @@ module ActiveModel
       super(I18n.t(:"#{@model.class.i18n_scope}.errors.messages.model_invalid", errors: errors, default: :"errors.messages.model_invalid"))
     end
   end
+
+  class ValidationContext # :nodoc:
+    attr_accessor :context
+  end
 end
 
 Dir[File.expand_path("validations/*.rb", __dir__)].each { |file| require file }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activemodel
 version: !ruby/object:Gem::Version
-  version: 7.2.1.1
+  version: 8.0.0.rc1
 platform: ruby
 authors:
 - David Heinemeier Hansson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-10-15 00:00:00.000000000 Z
+date: 2024-10-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 7.2.1.1
+        version: 8.0.0.rc1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 7.2.1.1
+        version: 8.0.0.rc1
 description: A toolkit for building modeling frameworks like Active Record. Rich support
   for attributes, callbacks, validations, serialization, internationalization, and
   testing.
@@ -112,10 +112,10 @@ licenses:
 - MIT
 metadata:
   bug_tracker_uri: https://github.com/rails/rails/issues
-  changelog_uri: https://github.com/rails/rails/blob/v7.2.1.1/activemodel/CHANGELOG.md
-  documentation_uri: https://api.rubyonrails.org/v7.2.1.1/
+  changelog_uri: https://github.com/rails/rails/blob/v8.0.0.rc1/activemodel/CHANGELOG.md
+  documentation_uri: https://api.rubyonrails.org/v8.0.0.rc1/
   mailing_list_uri: https://discuss.rubyonrails.org/c/rubyonrails-talk
-  source_code_uri: https://github.com/rails/rails/tree/v7.2.1.1/activemodel
+  source_code_uri: https://github.com/rails/rails/tree/v8.0.0.rc1/activemodel
   rubygems_mfa_required: 'true'
 post_install_message: 
 rdoc_options: []
@@ -125,7 +125,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.1.0
+      version: 3.2.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="