activemodel 6.0.3.4 → 6.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 86ec2634e2357d939729f9c02269a2bc92978e78896724276eaa97e35856999b
-  data.tar.gz: 864dfd17b31fcd79df8a17a8fee1582693be410433ac950c588f609abf383782
+  metadata.gz: '08df17982afa4c16f01d3f9c07f60cc5817641626e071a40d6b9a3765672ba4a'
+  data.tar.gz: 51909d78d21a89d88a27278f6f19a7f97971c78d058be06261431f141e0c7392
 SHA512:
-  metadata.gz: b157e2de3984dafcda3e589300bd91caa02a7de7fd5257d7078068a8bf98e2a850a461ed0e1e8a53e35999691c95bcd06f892394ab8de5b1ea012e730b40eca8
-  data.tar.gz: f1a27fa1759dd46ce4dc16dc03c652d6aaf66b136e279253f2c2db5f8cc71620ef91306fe7d73bf0bb96d413f4ae42c8f0597f444ddc3465cdeb841c21846934
+  metadata.gz: b1968baa6cfe661631c0036dc4e544272f7ca3d1b136e93afa77e3c6c78605ce3c05196df85862f9a03eb612cb32ca65aacd392f0a13c6ecd58b0c9ae452fa3a
+  data.tar.gz: e038c7e4cad1354ce7a763e43b003a02b0470343494fbe0da45070c8f205d2f0bef4c3f9900fc492dc588b5a6331fc2bdc2b044d450e3a266cc32c502d98f00b

data/CHANGELOG.md

@@ -1,217 +1,83 @@
-## Rails 6.0.3.4 (October 07, 2020) ##
+## Rails 6.1.2 (February 09, 2021) ##
 
 *   No changes.
 
 
-## Rails 6.0.3.3 (September 09, 2020) ##
+## Rails 6.1.1 (January 07, 2021) ##
 
 *   No changes.
 
 
-## Rails 6.0.3.2 (June 17, 2020) ##
-
-*   No changes.
-
-
-## Rails 6.0.3.1 (May 18, 2020) ##
-
-*   No changes.
-
-
-## Rails 6.0.3 (May 06, 2020) ##
-
-*   No changes.
+## Rails 6.1.0 (December 09, 2020) ##
 
+*   Pass in `base` instead of `base_class` to Error.human_attribute_name
 
-## Rails 6.0.2.2 (March 19, 2020) ##
+    This is useful in cases where the `human_attribute_name` method depends
+    on other attributes' values of the class under validation to derive what the
+    attribute name should be.
 
-*   No changes.
-
-
-## Rails 6.0.2.1 (December 18, 2019) ##
-
-*   No changes.
-
-
-## Rails 6.0.2 (December 13, 2019) ##
-
-*   No changes.
+    *Filipe Sabella*
 
-
-## Rails 6.0.1 (November 5, 2019) ##
-
-*   No changes.
-
-
-## Rails 6.0.0 (August 16, 2019) ##
-
-*   No changes.
-
-
-## Rails 6.0.0.rc2 (July 22, 2019) ##
-
-*   No changes.
-
-
-## Rails 6.0.0.rc1 (April 24, 2019) ##
-
-*   Type cast falsy boolean symbols on boolean attribute as false.
-
-    Fixes #35676.
+*   Deprecate marshalling load from legacy attributes format.
 
     *Ryuta Kamizono*
 
-*   Change how validation error translation strings are fetched: The new behavior
-    will first try the more specific keys, including doing locale fallback, then try
-    the less specific ones.
-
-    For example, this is the order in which keys will now be tried for a `blank`
-    error on a `product`'s `title` attribute with current locale set to `en-US`:
-
-        en-US.activerecord.errors.models.product.attributes.title.blank
-        en-US.activerecord.errors.models.product.blank
-        en-US.activerecord.errors.messages.blank
-
-        en.activerecord.errors.models.product.attributes.title.blank
-        en.activerecord.errors.models.product.blank
-        en.activerecord.errors.messages.blank
+*   `*_previously_changed?` accepts `:from` and `:to` keyword arguments like `*_changed?`.
 
-        en-US.errors.attributes.title.blank
-        en-US.errors.messages.blank
+        topic.update!(status: :archived)
+        topic.status_previously_changed?(from: "active", to: "archived")
+        # => true
 
-        en.errors.attributes.title.blank
-        en.errors.messages.blank
+    *George Claghorn*
 
-    *Hugo Vacher*
+*   Raise FrozenError when trying to write attributes that aren't backed by the database on an object that is frozen:
 
+        class Animal
+          include ActiveModel::Attributes
+          attribute :age
+        end
 
-## Rails 6.0.0.beta3 (March 11, 2019) ##
-
-*   No changes.
-
-
-## Rails 6.0.0.beta2 (February 25, 2019) ##
-
-*   Fix date value when casting a multiparameter date hash to not convert
-    from Gregorian date to Julian date.
-
-    Before:
-
-        Day.new({"day(1i)"=>"1", "day(2i)"=>"1", "day(3i)"=>"1"})
-        # => #<Day id: nil, day: "0001-01-03", created_at: nil, updated_at: nil>
-
-    After:
-
-        Day.new({"day(1i)"=>"1", "day(2i)"=>"1", "day(3i)"=>"1"})
-        # => #<Day id: nil, day: "0001-01-01", created_at: nil, updated_at: nil>
-
-    Fixes #28521.
-
-    *Sayan Chakraborty*
-
-*   Fix year value when casting a multiparameter time hash.
-
-    When assigning a hash to a time attribute that's missing a year component
-    (e.g. a `time_select` with `:ignore_date` set to `true`) then the year
-    defaults to 1970 instead of the expected 2000. This results in the attribute
-    changing as a result of the save.
-
-    Before:
-    ```
-    event = Event.new(start_time: { 4 => 20, 5 => 30 })
-    event.start_time # => 1970-01-01 20:30:00 UTC
-    event.save
-    event.reload
-    event.start_time # => 2000-01-01 20:30:00 UTC
-    ```
-
-    After:
-    ```
-    event = Event.new(start_time: { 4 => 20, 5 => 30 })
-    event.start_time # => 2000-01-01 20:30:00 UTC
-    event.save
-    event.reload
-    event.start_time # => 2000-01-01 20:30:00 UTC
-    ```
-
-    *Andrew White*
-
-
-## Rails 6.0.0.beta1 (January 18, 2019) ##
-
-*   Internal calls to `human_attribute_name` on an `Active Model` now pass attributes as strings instead of symbols
-    in some cases.
-
-    This is in line with examples in Rails docs and puts the code in line with the intention -
-    the potential use of strings or symbols.
-
-    It is recommended to cast the attribute input to your desired type as if you you are overriding that methid.
-
-    *Martin Larochelle*
-
-*   Add `ActiveModel::Errors#of_kind?`.
-
-    *bogdanvlviv*, *Rafael Mendonça França*
-
-*   Fix numericality equality validation of `BigDecimal` and `Float`
-    by casting to `BigDecimal` on both ends of the validation.
-
-    *Gannon McGibbon*
-
-*   Add `#slice!` method to `ActiveModel::Errors`.
-
-    *Daniel López Prat*
-
-*   Fix numericality validator to still use value before type cast except Active Record.
-
-    Fixes #33651, #33686.
-
-    *Ryuta Kamizono*
-
-*   Fix `ActiveModel::Serializers::JSON#as_json` method for timestamps.
-
-    Before:
-    ```
-    contact = Contact.new(created_at: Time.utc(2006, 8, 1))
-    contact.as_json["created_at"] # => 2006-08-01 00:00:00 UTC
-    ```
+        animal = Animal.new
+        animal.freeze
+        animal.age = 25 # => FrozenError, "can't modify a frozen Animal"
 
-    After:
-    ```
-    contact = Contact.new(created_at: Time.utc(2006, 8, 1))
-    contact.as_json["created_at"] # => "2006-08-01T00:00:00.000Z"
-    ```
+    *Josh Brody*
 
-    *Bogdan Gusiev*
+*   Add `*_previously_was` attribute methods when dirty tracking. Example:
 
-*   Allows configurable attribute name for `#has_secure_password`. This
-    still defaults to an attribute named 'password', causing no breaking
-    change. There is a new method `#authenticate_XXX` where XXX is the
-    configured attribute name, making the existing `#authenticate` now an
-    alias for this when the attribute is the default 'password'.
+        pirate.update(catchphrase: "Ahoy!")
+        pirate.previous_changes["catchphrase"] # => ["Thar She Blows!", "Ahoy!"]
+        pirate.catchphrase_previously_was # => "Thar She Blows!"
 
-    Example:
+    *DHH*
 
-        class User < ActiveRecord::Base
-          has_secure_password :recovery_password, validations: false
-        end
+*   Encapsulate each validation error as an Error object.
 
-        user = User.new()
-        user.recovery_password = "42password"
-        user.recovery_password_digest # => "$2a$04$iOfhwahFymCs5weB3BNH/uX..."
-        user.authenticate_recovery_password('42password') # => user
+    The `ActiveModel`’s `errors` collection is now an array of these Error
+    objects, instead of messages/details hash.
 
-    *Unathi Chonco*
+    For each of these `Error` object, its `message` and `full_message` methods
+    are for generating error messages. Its `details` method would return error’s
+    extra parameters, found in the original `details` hash.
 
-*   Add `config.active_model.i18n_customize_full_message` in order to control whether
-    the `full_message` error format can be overridden at the attribute or model
-    level in the locale files. This is `false` by default.
+    The change tries its best at maintaining backward compatibility, however
+    some edge cases won’t be covered, like `errors#first` will return `ActiveModel::Error` and manipulating
+    `errors.messages` and `errors.details` hashes directly will have no effect. Moving forward,
+    please convert those direct manipulations to use provided API methods instead.
 
-    *Martin Larochelle*
+    The list of deprecated methods and their planned future behavioral changes at the next major release are:
 
-*   Rails 6 requires Ruby 2.5.0 or newer.
+    * `errors#slice!` will be removed.
+    * `errors#each` with the `key, value` two-arguments block will stop working, while the `error` single-argument block would return `Error` object.
+    * `errors#values` will be removed.
+    * `errors#keys` will be removed.
+    * `errors#to_xml` will be removed.
+    * `errors#to_h` will be removed, and can be replaced with `errors#to_hash`.
+    * Manipulating `errors` itself as a hash will have no effect (e.g. `errors[:foo] = 'bar'`).
+    * Manipulating the hash returned by `errors#messages` (e.g. `errors.messages[:foo] = 'bar'`) will have no effect.
+    * Manipulating the hash returned by `errors#details` (e.g. `errors.details[:foo].clear`) will have no effect.
 
-    *Jeremy Daer*, *Kasper Timm Hansen*
+    *lulalala*
 
 
-Please check [5-2-stable](https://github.com/rails/rails/blob/5-2-stable/activemodel/CHANGELOG.md) for previous changes.
+Please check [6-0-stable](https://github.com/rails/rails/blob/6-0-stable/activemodel/CHANGELOG.md) for previous changes.

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2004-2019 David Heinemeier Hansson
+Copyright (c) 2004-2020 David Heinemeier Hansson
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.rdoc

@@ -200,7 +200,7 @@ behavior out of the box:
       attr_accessor :first_name, :last_name
 
       validates_each :first_name, :last_name do |record, attr, value|
-        record.errors.add attr, 'starts with z.' if value.to_s[0] == ?z
+        record.errors.add attr, "starts with z." if value.start_with?("z")
       end
     end
 
@@ -241,7 +241,7 @@ The latest version of Active Model can be installed with RubyGems:
 
 Source code can be downloaded as part of the Rails project on GitHub
 
-* https://github.com/rails/rails/tree/master/activemodel
+* https://github.com/rails/rails/tree/main/activemodel
 
 
 == License

data/lib/active_model.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 #--
-# Copyright (c) 2004-2019 David Heinemeier Hansson
+# Copyright (c) 2004-2020 David Heinemeier Hansson
 #
 # Permission is hereby granted, free of charge, to any person obtaining
 # a copy of this software and associated documentation files (the
@@ -53,6 +53,7 @@ module ActiveModel
 
   eager_autoload do
     autoload :Errors
+    autoload :Error
     autoload :RangeError, "active_model/errors"
     autoload :StrictValidationFailed, "active_model/errors"
     autoload :UnknownAttributeError, "active_model/errors"

data/lib/active_model/attribute.rb

@@ -5,16 +5,16 @@ require "active_support/core_ext/object/duplicable"
 module ActiveModel
   class Attribute # :nodoc:
     class << self
-      def from_database(name, value, type)
-        FromDatabase.new(name, value, type)
+      def from_database(name, value_before_type_cast, type, value = nil)
+        FromDatabase.new(name, value_before_type_cast, type, nil, value)
       end
 
-      def from_user(name, value, type, original_attribute = nil)
-        FromUser.new(name, value, type, original_attribute)
+      def from_user(name, value_before_type_cast, type, original_attribute = nil)
+        FromUser.new(name, value_before_type_cast, type, original_attribute)
       end
 
-      def with_cast_value(name, value, type)
-        WithCastValue.new(name, value, type)
+      def with_cast_value(name, value_before_type_cast, type)
+        WithCastValue.new(name, value_before_type_cast, type)
       end
 
       def null(name)
@@ -30,11 +30,12 @@ module ActiveModel
 
     # This method should not be called directly.
     # Use #from_database or #from_user
-    def initialize(name, value_before_type_cast, type, original_attribute = nil)
+    def initialize(name, value_before_type_cast, type, original_attribute = nil, value = nil)
       @name = name
       @value_before_type_cast = value_before_type_cast
       @type = type
       @original_attribute = original_attribute
+      @value = value unless value.nil?
     end
 
     def value
@@ -132,14 +133,13 @@ module ActiveModel
       coder["value"] = value if defined?(@value)
     end
 
-    protected
-      def original_value_for_database
-        if assigned?
-          original_attribute.original_value_for_database
-        else
-          _original_value_for_database
-        end
+    def original_value_for_database
+      if assigned?
+        original_attribute.original_value_for_database
+      else
+        _original_value_for_database
       end
+    end
 
     private
       attr_reader :original_attribute
@@ -164,9 +164,10 @@ module ActiveModel
           type.deserialize(value)
         end
 
-        def _original_value_for_database
-          value_before_type_cast
-        end
+        private
+          def _original_value_for_database
+            value_before_type_cast
+          end
       end
 
       class FromUser < Attribute # :nodoc:

data/lib/active_model/attribute_assignment.rb

@@ -26,13 +26,12 @@ module ActiveModel
     #   cat.name # => 'Gorby'
     #   cat.status # => 'sleeping'
     def assign_attributes(new_attributes)
-      if !new_attributes.respond_to?(:stringify_keys)
+      unless new_attributes.respond_to?(:each_pair)
         raise ArgumentError, "When assigning attributes, you must pass a hash as an argument, #{new_attributes.class} passed."
       end
       return if new_attributes.empty?
 
-      attributes = new_attributes.stringify_keys
-      _assign_attributes(sanitize_for_mass_assignment(attributes))
+      _assign_attributes(sanitize_for_mass_assignment(new_attributes))
     end
 
     alias attributes= assign_attributes
@@ -49,7 +48,7 @@ module ActiveModel
         if respond_to?(setter)
           public_send(setter, v)
         else
-          raise UnknownAttributeError.new(self, k)
+          raise UnknownAttributeError.new(self, k.to_s)
         end
       end
   end

data/lib/active_model/attribute_methods.rb

@@ -207,10 +207,12 @@ module ActiveModel
       #   person.nickname_short? # => true
       def alias_attribute(new_name, old_name)
         self.attribute_aliases = attribute_aliases.merge(new_name.to_s => old_name.to_s)
-        attribute_method_matchers.each do |matcher|
-          matcher_new = matcher.method_name(new_name).to_s
-          matcher_old = matcher.method_name(old_name).to_s
-          define_proxy_call false, self, matcher_new, matcher_old
+        CodeGenerator.batch(self, __FILE__, __LINE__) do |owner|
+          attribute_method_matchers.each do |matcher|
+            matcher_new = matcher.method_name(new_name).to_s
+            matcher_old = matcher.method_name(old_name).to_s
+            define_proxy_call false, owner, matcher_new, matcher_old
+          end
         end
       end
 
@@ -249,7 +251,9 @@ module ActiveModel
       #     end
       #   end
       def define_attribute_methods(*attr_names)
-        attr_names.flatten.each { |attr_name| define_attribute_method(attr_name) }
+        CodeGenerator.batch(generated_attribute_methods, __FILE__, __LINE__) do |owner|
+          attr_names.flatten.each { |attr_name| define_attribute_method(attr_name, _owner: owner) }
+        end
       end
 
       # Declares an attribute that should be prefixed and suffixed by
@@ -281,21 +285,23 @@ module ActiveModel
       #   person.name = 'Bob'
       #   person.name        # => "Bob"
       #   person.name_short? # => true
-      def define_attribute_method(attr_name)
-        attribute_method_matchers.each do |matcher|
-          method_name = matcher.method_name(attr_name)
-
-          unless instance_method_already_implemented?(method_name)
-            generate_method = "define_method_#{matcher.target}"
-
-            if respond_to?(generate_method, true)
-              send(generate_method, attr_name.to_s)
-            else
-              define_proxy_call true, generated_attribute_methods, method_name, matcher.target, attr_name.to_s
+      def define_attribute_method(attr_name, _owner: generated_attribute_methods)
+        CodeGenerator.batch(_owner, __FILE__, __LINE__) do |owner|
+          attribute_method_matchers.each do |matcher|
+            method_name = matcher.method_name(attr_name)
+
+            unless instance_method_already_implemented?(method_name)
+              generate_method = "define_method_#{matcher.target}"
+
+              if respond_to?(generate_method, true)
+                send(generate_method, attr_name.to_s, owner: owner)
+              else
+                define_proxy_call true, owner, method_name, matcher.target, attr_name.to_s
+              end
             end
           end
+          attribute_method_matchers_cache.clear
         end
-        attribute_method_matchers_cache.clear
       end
 
       # Removes all the previously dynamically defined methods from the class.
@@ -323,12 +329,52 @@ module ActiveModel
       #   person.name_short? # => NoMethodError
       def undefine_attribute_methods
         generated_attribute_methods.module_eval do
-          instance_methods.each { |m| undef_method(m) }
+          undef_method(*instance_methods)
         end
         attribute_method_matchers_cache.clear
       end
 
       private
+        class CodeGenerator
+          class << self
+            def batch(owner, path, line)
+              if owner.is_a?(CodeGenerator)
+                yield owner
+              else
+                instance = new(owner, path, line)
+                result = yield instance
+                instance.execute
+                result
+              end
+            end
+          end
+
+          def initialize(owner, path, line)
+            @owner = owner
+            @path = path
+            @line = line
+            @sources = ["# frozen_string_literal: true\n"]
+            @renames = {}
+          end
+
+          def <<(source_line)
+            @sources << source_line
+          end
+
+          def rename_method(old_name, new_name)
+            @renames[old_name] = new_name
+          end
+
+          def execute
+            @owner.module_eval(@sources.join(";"), @path, @line - 1)
+            @renames.each do |old_name, new_name|
+              @owner.alias_method new_name, old_name
+              @owner.undef_method old_name
+            end
+          end
+        end
+        private_constant :CodeGenerator
+
         def generated_attribute_methods
           @generated_attribute_methods ||= Module.new.tap { |mod| include mod }
         end
@@ -352,18 +398,14 @@ module ActiveModel
 
         def attribute_method_matchers_matching(method_name)
           attribute_method_matchers_cache.compute_if_absent(method_name) do
-            # Bump plain matcher to last place so that only methods that do not
-            # match any other pattern match the actual attribute name.
-            # This is currently only needed to support legacy usage.
-            matchers = attribute_method_matchers.partition(&:plain?).reverse.flatten(1)
-            matchers.map { |matcher| matcher.match(method_name) }.compact
+            attribute_method_matchers.map { |matcher| matcher.match(method_name) }.compact
           end
         end
 
         # Define a method `name` in `mod` that dispatches to `send`
         # using the given `extra` args. This falls back on `define_method`
         # and `send` if the given names cannot be compiled.
-        def define_proxy_call(include_private, mod, name, target, *extra)
+        def define_proxy_call(include_private, code_generator, name, target, *extra)
           defn = if NAME_COMPILABLE_REGEXP.match?(name)
             "def #{name}(*args)"
           else
@@ -378,12 +420,11 @@ module ActiveModel
             "send(:'#{target}', #{extra})"
           end
 
-          mod.module_eval <<-RUBY, __FILE__, __LINE__ + 1
-            #{defn}
-              #{body}
-            end
-            ruby2_keywords(:'#{name}') if respond_to?(:ruby2_keywords, true)
-          RUBY
+          code_generator <<
+            defn <<
+            body <<
+            "end" <<
+            "ruby2_keywords(:'#{name}') if respond_to?(:ruby2_keywords, true)"
         end
 
         class AttributeMethodMatcher #:nodoc:
@@ -407,10 +448,6 @@ module ActiveModel
           def method_name(attr_name)
             @method_name % attr_name
           end
-
-          def plain?
-            prefix.empty? && suffix.empty?
-          end
         end
     end
 
@@ -499,10 +536,10 @@ module ActiveModel
         # to allocate an object on each call to the attribute method.
         # Making it frozen means that it doesn't get duped when used to
         # key the @attributes in read_attribute.
-        def self.define_attribute_accessor_method(mod, attr_name, writer: false)
+        def self.define_attribute_accessor_method(owner, attr_name, writer: false)
           method_name = "#{attr_name}#{'=' if writer}"
           if attr_name.ascii_only? && DEF_SAFE_NAME.match?(attr_name)
-            yield method_name, "'#{attr_name}'.freeze"
+            yield method_name, "'#{attr_name}'"
           else
             safe_name = attr_name.unpack1("h*")
             const_name = "ATTR_#{safe_name}"
@@ -510,8 +547,7 @@ module ActiveModel
             temp_method_name = "__temp__#{safe_name}#{'=' if writer}"
             attr_name_expr = "::ActiveModel::AttributeMethods::AttrNames::#{const_name}"
             yield temp_method_name, attr_name_expr
-            mod.alias_method method_name, temp_method_name
-            mod.undef_method temp_method_name
+            owner.rename_method(temp_method_name, method_name)
           end
         end
       end