activemodel 7.2.1 → 8.0.0.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3d6d86af15fa7149d24dbe05b187bc8eda73ced0b0017f36ff3732d088430619
-  data.tar.gz: 5169b5634a262e973a0b8a8120c3f5f5118fe45da440e99a8dd9a7b731df454f
+  metadata.gz: 906d52ef894a9f6b8fc0eb97488a653bcf0c0b141747cf7a7d5e8dcedb65e929
+  data.tar.gz: '084df4c1c4a669a5d5c583bb3a579fdbe1be8f7f2bc4c24506797f9197250d3f'
 SHA512:
-  metadata.gz: e71b27fb04a2a7288299197ebf8ab3d141090a9e20a6a4c14630adbe54bb87a2b750a7eda5d5efdb9be015193a601732b2d42c7a71b5499266e886eeb5a2b61e
-  data.tar.gz: e9739dc64d7509e2055a95715dd19f123f2aff7c3436b470eeb2c2cfc305121cd37d0befc08589285a14ada82383d4a2f411e272941d548719a8a51c22441c66
+  metadata.gz: acdcc972d445a2d7576785d1b145d66f2a895a9e21e6b17acdc5ef78871e49aea0a49694d92efce03c030b82e69b176298ced1eb8244bdd836151dd9dfaa5068
+  data.tar.gz: 918efc3fb79b912bfbff1661cfec5f822d86f2c33a135389de8f8bba150196c85411db87fb17470bccfea852ff3cda3c5c19bdc336d85238040f99ee0374138d

data/CHANGELOG.md

@@ -1,29 +1,73 @@
-## Rails 7.2.1 (August 22, 2024) ##
+## Rails 8.0.0.beta1 (September 26, 2024) ##
 
-*   No changes.
+*   Make `ActiveModel::Serialization#read_attribute_for_serialization` public
 
+    *Sean Doyle*
 
-## Rails 7.2.0 (August 09, 2024) ##
+*   Add a default token generator for password reset tokens when using `has_secure_password`.
 
-*   Fix a bug where type casting of string to `Time` and `DateTime` doesn't
-    calculate minus minute value in TZ offset correctly.
+    ```ruby
+    class User < ApplicationRecord
+      has_secure_password
+    end
 
-    *Akira Matsuda*
+    user = User.create!(name: "david", password: "123", password_confirmation: "123")
+    token = user.password_reset_token
+    User.find_by_password_reset_token(token) # returns user
 
-*   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.
+    # 16 minutes later...
+    User.find_by_password_reset_token(token) # returns nil
 
-      ```ruby
-      class MyModel
-        include ActiveModel::Attributes
+    # raises ActiveSupport::MessageVerifier::InvalidSignature since the token is expired
+    User.find_by_password_reset_token!(token)
+    ```
 
-        attribute :my_attribute, :integer
+    *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/dirty.rb

@@ -256,7 +256,8 @@ module ActiveModel
     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   = nil
+    MAJOR = 8
+    MINOR = 0
+    TINY  = 0
+    PRE   = "beta1"
 
     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/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] = [] }
@@ -361,15 +340,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 +417,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 +480,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
+  version: 8.0.0.beta1
 platform: ruby
 authors:
 - David Heinemeier Hansson
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-08-22 00:00:00.000000000 Z
+date: 2024-09-26 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
+        version: 8.0.0.beta1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 7.2.1
+        version: 8.0.0.beta1
 description: A toolkit for building modeling frameworks like Active Record. Rich support
   for attributes, callbacks, validations, serialization, internationalization, and
   testing.
@@ -112,12 +112,12 @@ licenses:
 - MIT
 metadata:
   bug_tracker_uri: https://github.com/rails/rails/issues
-  changelog_uri: https://github.com/rails/rails/blob/v7.2.1/activemodel/CHANGELOG.md
-  documentation_uri: https://api.rubyonrails.org/v7.2.1/
+  changelog_uri: https://github.com/rails/rails/blob/v8.0.0.beta1/activemodel/CHANGELOG.md
+  documentation_uri: https://api.rubyonrails.org/v8.0.0.beta1/
   mailing_list_uri: https://discuss.rubyonrails.org/c/rubyonrails-talk
-  source_code_uri: https://github.com/rails/rails/tree/v7.2.1/activemodel
+  source_code_uri: https://github.com/rails/rails/tree/v8.0.0.beta1/activemodel
   rubygems_mfa_required: 'true'
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -125,15 +125,15 @@ 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:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.11
-signing_key:
+rubygems_version: 3.5.16
+signing_key: 
 specification_version: 4
 summary: A toolkit for building modeling frameworks (part of Rails).
 test_files: []