activemodel 6.0.0.beta3 → 6.0.2.rc2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3b034b3f54d2c82df8caa74bf97be978e102611c91075d49329e353ff317d187
-  data.tar.gz: 6eedb13c89d8899c1f10584716a9c91d91628c8e7d7762bf2137f12f0d6a9165
+  metadata.gz: f53fd7a85f2c82e65474f83bfea395162728cb37c5a2b0e54a66558a192b31ef
+  data.tar.gz: d066c69bfc2aa4d87b599ab00a79f53cd052814b174f0f8777592e0e6859c85a
 SHA512:
-  metadata.gz: 56c12136b80022c6fc9e0b2594ba87146b1f0b6a312ad4e389fec4069955edac0aed51c64fd58e91539dd53f74dd393bfcf35ca6fb42ba97f7492696da92dbff
-  data.tar.gz: 2135d0a5bd6787134bb1bffd1602ec78ea45ac5d73109de2d6af625d8d3d56b2bef111abcf0cd96ef8a6f44d8ffcf68154bbfab5328b293c8e40a3e84e5341fd
+  metadata.gz: b35e989bdf9139fab9fac79123771c2338cc5919f3f096b58b2918b74b79a60fb86cff8c634666f76b95ef59e21f71210feec3b483376218b08348a487d37789
+  data.tar.gz: 1b524687a3256eca1b51d21f68fc28e79cf8e8583e17d51057667b97d504d64cd27a9de093b473985577717ab24de9bc469db2b411aaa385bc3bde76d33fee49

data/CHANGELOG.md

@@ -1,3 +1,55 @@
+## Rails 6.0.2.rc2 (December 09, 2019) ##
+
+*   No changes.
+
+
+## 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.
+
+    *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
+
+        en-US.errors.attributes.title.blank
+        en-US.errors.messages.blank
+
+        en.errors.attributes.title.blank
+        en.errors.messages.blank
+
+    *Hugo Vacher*
+
+
 ## Rails 6.0.0.beta3 (March 11, 2019) ##
 
 *   No changes.
@@ -11,12 +63,12 @@
     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>
+        # => #<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>
+        # => #<Day id: nil, day: "0001-01-01", created_at: nil, updated_at: nil>
 
     Fixes #28521.
 
@@ -52,6 +104,16 @@
 
 ## 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*
@@ -106,7 +168,7 @@
 
     *Unathi Chonco*
 
-*   Add `config.active_model.i18n_full_message` in order to control whether
+*   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.
 

data/README.rdoc

@@ -5,6 +5,8 @@ They allow for Action Pack helpers to interact with non-Active Record models,
 for example. Active Model also helps with building custom ORMs for use outside of
 the Rails framework.
 
+You can read more about Active Model in the {Active Model Basics}[https://edgeguides.rubyonrails.org/active_model_basics.html] guide.
+
 Prior to Rails 3.0, if a plugin or gem developer wanted to have an object
 interact with Action Pack helpers, it was required to either copy chunks of
 code from Rails, or monkey patch entire helpers to make them handle objects
@@ -253,7 +255,7 @@ Active Model is released under the MIT license:
 
 API documentation is at:
 
-* http://api.rubyonrails.org
+* https://api.rubyonrails.org
 
 Bug reports for the Ruby on Rails project can be filed here:
 

data/lib/active_model/attribute_methods.rb

@@ -286,12 +286,12 @@ module ActiveModel
           method_name = matcher.method_name(attr_name)
 
           unless instance_method_already_implemented?(method_name)
-            generate_method = "define_method_#{matcher.method_missing_target}"
+            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.method_missing_target, attr_name.to_s
+              define_proxy_call true, generated_attribute_methods, method_name, matcher.target, attr_name.to_s
             end
           end
         end
@@ -352,17 +352,18 @@ module ActiveModel
 
         def attribute_method_matchers_matching(method_name)
           attribute_method_matchers_cache.compute_if_absent(method_name) do
-            # Must try to match prefixes/suffixes first, or else the matcher with no prefix/suffix
-            # will match every time.
+            # 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 { |method| method.match(method_name) }.compact
+            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, send, *extra)
+        def define_proxy_call(include_private, mod, name, target, *extra)
           defn = if NAME_COMPILABLE_REGEXP.match?(name)
             "def #{name}(*args)"
           else
@@ -371,34 +372,34 @@ module ActiveModel
 
           extra = (extra.map!(&:inspect) << "*args").join(", ")
 
-          target = if CALL_COMPILABLE_REGEXP.match?(send)
-            "#{"self." unless include_private}#{send}(#{extra})"
+          body = if CALL_COMPILABLE_REGEXP.match?(target)
+            "#{"self." unless include_private}#{target}(#{extra})"
           else
-            "send(:'#{send}', #{extra})"
+            "send(:'#{target}', #{extra})"
           end
 
           mod.module_eval <<-RUBY, __FILE__, __LINE__ + 1
             #{defn}
-              #{target}
+              #{body}
             end
           RUBY
         end
 
         class AttributeMethodMatcher #:nodoc:
-          attr_reader :prefix, :suffix, :method_missing_target
+          attr_reader :prefix, :suffix, :target
 
-          AttributeMethodMatch = Struct.new(:target, :attr_name, :method_name)
+          AttributeMethodMatch = Struct.new(:target, :attr_name)
 
           def initialize(options = {})
             @prefix, @suffix = options.fetch(:prefix, ""), options.fetch(:suffix, "")
             @regex = /^(?:#{Regexp.escape(@prefix)})(.*)(?:#{Regexp.escape(@suffix)})$/
-            @method_missing_target = "#{@prefix}attribute#{@suffix}"
+            @target = "#{@prefix}attribute#{@suffix}"
             @method_name = "#{prefix}%s#{suffix}"
           end
 
           def match(method_name)
             if @regex =~ method_name
-              AttributeMethodMatch.new(method_missing_target, $1, method_name)
+              AttributeMethodMatch.new(target, $1)
             end
           end
 

data/lib/active_model/attribute_mutation_tracker.rb

@@ -1,14 +1,15 @@
 # frozen_string_literal: true
 
 require "active_support/core_ext/hash/indifferent_access"
+require "active_support/core_ext/object/duplicable"
 
 module ActiveModel
   class AttributeMutationTracker # :nodoc:
     OPTION_NOT_GIVEN = Object.new
 
-    def initialize(attributes)
+    def initialize(attributes, forced_changes = Set.new)
       @attributes = attributes
-      @forced_changes = Set.new
+      @forced_changes = forced_changes
     end
 
     def changed_attribute_names
@@ -18,24 +19,22 @@ module ActiveModel
     def changed_values
       attr_names.each_with_object({}.with_indifferent_access) do |attr_name, result|
         if changed?(attr_name)
-          result[attr_name] = attributes[attr_name].original_value
+          result[attr_name] = original_value(attr_name)
         end
       end
     end
 
     def changes
       attr_names.each_with_object({}.with_indifferent_access) do |attr_name, result|
-        change = change_to_attribute(attr_name)
-        if change
+        if change = change_to_attribute(attr_name)
           result.merge!(attr_name => change)
         end
       end
     end
 
     def change_to_attribute(attr_name)
-      attr_name = attr_name.to_s
       if changed?(attr_name)
-        [attributes[attr_name].original_value, attributes.fetch_value(attr_name)]
+        [original_value(attr_name), fetch_value(attr_name)]
       end
     end
 
@@ -44,29 +43,26 @@ module ActiveModel
     end
 
     def changed?(attr_name, from: OPTION_NOT_GIVEN, to: OPTION_NOT_GIVEN)
-      attr_name = attr_name.to_s
-      forced_changes.include?(attr_name) ||
-        attributes[attr_name].changed? &&
-        (OPTION_NOT_GIVEN == from || attributes[attr_name].original_value == from) &&
-        (OPTION_NOT_GIVEN == to || attributes[attr_name].value == to)
+      attribute_changed?(attr_name) &&
+        (OPTION_NOT_GIVEN == from || original_value(attr_name) == from) &&
+        (OPTION_NOT_GIVEN == to || fetch_value(attr_name) == to)
     end
 
     def changed_in_place?(attr_name)
-      attributes[attr_name.to_s].changed_in_place?
+      attributes[attr_name].changed_in_place?
     end
 
     def forget_change(attr_name)
-      attr_name = attr_name.to_s
       attributes[attr_name] = attributes[attr_name].forgetting_assignment
       forced_changes.delete(attr_name)
     end
 
     def original_value(attr_name)
-      attributes[attr_name.to_s].original_value
+      attributes[attr_name].original_value
     end
 
     def force_change(attr_name)
-      forced_changes << attr_name.to_s
+      forced_changes << attr_name
     end
 
     private
@@ -75,45 +71,108 @@ module ActiveModel
       def attr_names
         attributes.keys
       end
+
+      def attribute_changed?(attr_name)
+        forced_changes.include?(attr_name) || !!attributes[attr_name].changed?
+      end
+
+      def fetch_value(attr_name)
+        attributes.fetch_value(attr_name)
+      end
+  end
+
+  class ForcedMutationTracker < AttributeMutationTracker # :nodoc:
+    def initialize(attributes, forced_changes = {})
+      super
+      @finalized_changes = nil
+    end
+
+    def changed_in_place?(attr_name)
+      false
+    end
+
+    def change_to_attribute(attr_name)
+      if finalized_changes&.include?(attr_name)
+        finalized_changes[attr_name].dup
+      else
+        super
+      end
+    end
+
+    def forget_change(attr_name)
+      forced_changes.delete(attr_name)
+    end
+
+    def original_value(attr_name)
+      if changed?(attr_name)
+        forced_changes[attr_name]
+      else
+        fetch_value(attr_name)
+      end
+    end
+
+    def force_change(attr_name)
+      forced_changes[attr_name] = clone_value(attr_name) unless attribute_changed?(attr_name)
+    end
+
+    def finalize_changes
+      @finalized_changes = changes
+    end
+
+    private
+      attr_reader :finalized_changes
+
+      def attr_names
+        forced_changes.keys
+      end
+
+      def attribute_changed?(attr_name)
+        forced_changes.include?(attr_name)
+      end
+
+      def fetch_value(attr_name)
+        attributes.send(:_read_attribute, attr_name)
+      end
+
+      def clone_value(attr_name)
+        value = fetch_value(attr_name)
+        value.duplicable? ? value.clone : value
+      rescue TypeError, NoMethodError
+        value
+      end
   end
 
   class NullMutationTracker # :nodoc:
     include Singleton
 
-    def changed_attribute_names(*)
+    def changed_attribute_names
       []
     end
 
-    def changed_values(*)
+    def changed_values
       {}
     end
 
-    def changes(*)
+    def changes
       {}
     end
 
     def change_to_attribute(attr_name)
     end
 
-    def any_changes?(*)
+    def any_changes?
       false
     end
 
-    def changed?(*)
+    def changed?(attr_name, **)
       false
     end
 
-    def changed_in_place?(*)
+    def changed_in_place?(attr_name)
       false
     end
 
-    def forget_change(*)
-    end
-
-    def original_value(*)
-    end
-
-    def force_change(*)
+    def original_value(attr_name)
     end
   end
 end

data/lib/active_model/attributes.rb

@@ -26,6 +26,21 @@ module ActiveModel
         define_attribute_method(name)
       end
 
+      # Returns an array of attribute names as strings
+      #
+      #   class Person
+      #     include ActiveModel::Attributes
+      #
+      #     attribute :name, :string
+      #     attribute :age, :integer
+      #   end
+      #
+      #   Person.attribute_names
+      #   # => ["name", "age"]
+      def attribute_names
+        attribute_types.keys
+      end
+
       private
 
         def define_method_attribute=(name)
@@ -65,33 +80,57 @@ module ActiveModel
       super
     end
 
+    # Returns a hash of all the attributes with their names as keys and the values of the attributes as values.
+    #
+    #   class Person
+    #     include ActiveModel::Model
+    #     include ActiveModel::Attributes
+    #
+    #     attribute :name, :string
+    #     attribute :age, :integer
+    #   end
+    #
+    #   person = Person.new(name: 'Francesco', age: 22)
+    #   person.attributes
+    #   # => {"name"=>"Francesco", "age"=>22}
     def attributes
       @attributes.to_hash
     end
 
+    # Returns an array of attribute names as strings
+    #
+    #   class Person
+    #     include ActiveModel::Attributes
+    #
+    #     attribute :name, :string
+    #     attribute :age, :integer
+    #   end
+    #
+    #   person = Person.new
+    #   person.attribute_names
+    #   # => ["name", "age"]
+    def attribute_names
+      @attributes.keys
+    end
+
     private
 
       def write_attribute(attr_name, value)
-        name = if self.class.attribute_alias?(attr_name)
-          self.class.attribute_alias(attr_name).to_s
-        else
-          attr_name.to_s
-        end
+        name = attr_name.to_s
+        name = self.class.attribute_aliases[name] || name
 
         @attributes.write_from_user(name, value)
         value
       end
 
       def attribute(attr_name)
-        name = if self.class.attribute_alias?(attr_name)
-          self.class.attribute_alias(attr_name).to_s
-        else
-          attr_name.to_s
-        end
+        name = attr_name.to_s
+        name = self.class.attribute_aliases[name] || name
+
         @attributes.fetch_value(name)
       end
 
-      # Handle *= for method_missing.
+      # Dispatch target for <tt>*=</tt> attribute methods.
       def attribute=(attribute_name, value)
         write_attribute(attribute_name, value)
       end

data/lib/active_model/dirty.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "active_support/hash_with_indifferent_access"
-require "active_support/core_ext/object/duplicable"
 require "active_model/attribute_mutation_tracker"
 
 module ActiveModel
@@ -122,9 +120,6 @@ module ActiveModel
     extend ActiveSupport::Concern
     include ActiveModel::AttributeMethods
 
-    OPTION_NOT_GIVEN = Object.new # :nodoc:
-    private_constant :OPTION_NOT_GIVEN
-
     included do
       attribute_method_suffix "_changed?", "_change", "_will_change!", "_was"
       attribute_method_suffix "_previously_changed?", "_previous_change"
@@ -145,10 +140,9 @@ module ActiveModel
     # +mutations_from_database+ to +mutations_before_last_save+ respectively.
     def changes_applied
       unless defined?(@attributes)
-        @previously_changed = changes
+        mutations_from_database.finalize_changes
       end
       @mutations_before_last_save = mutations_from_database
-      @attributes_changed_by_setter = ActiveSupport::HashWithIndifferentAccess.new
       forget_attribute_assignments
       @mutations_from_database = nil
     end
@@ -159,7 +153,7 @@ module ActiveModel
     #   person.name = 'bob'
     #   person.changed? # => true
     def changed?
-      changed_attributes.present?
+      mutations_from_database.any_changes?
     end
 
     # Returns an array with the name of the attributes with unsaved changes.
@@ -168,42 +162,37 @@ module ActiveModel
     #   person.name = 'bob'
     #   person.changed # => ["name"]
     def changed
-      changed_attributes.keys
+      mutations_from_database.changed_attribute_names
     end
 
-    # Handles <tt>*_changed?</tt> for +method_missing+.
-    def attribute_changed?(attr, from: OPTION_NOT_GIVEN, to: OPTION_NOT_GIVEN) # :nodoc:
-      !!changes_include?(attr) &&
-        (to == OPTION_NOT_GIVEN || to == _read_attribute(attr)) &&
-        (from == OPTION_NOT_GIVEN || from == changed_attributes[attr])
+    # Dispatch target for <tt>*_changed?</tt> attribute methods.
+    def attribute_changed?(attr_name, **options) # :nodoc:
+      mutations_from_database.changed?(attr_name.to_s, options)
     end
 
-    # Handles <tt>*_was</tt> for +method_missing+.
-    def attribute_was(attr) # :nodoc:
-      attribute_changed?(attr) ? changed_attributes[attr] : _read_attribute(attr)
+    # Dispatch target for <tt>*_was</tt> attribute methods.
+    def attribute_was(attr_name) # :nodoc:
+      mutations_from_database.original_value(attr_name.to_s)
     end
 
-    # Handles <tt>*_previously_changed?</tt> for +method_missing+.
-    def attribute_previously_changed?(attr) #:nodoc:
-      previous_changes_include?(attr)
+    # Dispatch target for <tt>*_previously_changed?</tt> attribute methods.
+    def attribute_previously_changed?(attr_name) # :nodoc:
+      mutations_before_last_save.changed?(attr_name.to_s)
     end
 
     # Restore all previous data of the provided attributes.
-    def restore_attributes(attributes = changed)
-      attributes.each { |attr| restore_attribute! attr }
+    def restore_attributes(attr_names = changed)
+      attr_names.each { |attr_name| restore_attribute!(attr_name) }
     end
 
     # Clears all dirty data: current changes and previous changes.
     def clear_changes_information
-      @previously_changed = ActiveSupport::HashWithIndifferentAccess.new
       @mutations_before_last_save = nil
-      @attributes_changed_by_setter = ActiveSupport::HashWithIndifferentAccess.new
       forget_attribute_assignments
       @mutations_from_database = nil
     end
 
     def clear_attribute_changes(attr_names)
-      attributes_changed_by_setter.except!(*attr_names)
       attr_names.each do |attr_name|
         clear_attribute_change(attr_name)
       end
@@ -216,13 +205,7 @@ module ActiveModel
     #   person.name = 'robert'
     #   person.changed_attributes # => {"name" => "bob"}
     def changed_attributes
-      # This should only be set by methods which will call changed_attributes
-      # multiple times when it is known that the computed value cannot change.
-      if defined?(@cached_changed_attributes)
-        @cached_changed_attributes
-      else
-        attributes_changed_by_setter.reverse_merge(mutations_from_database.changed_values).freeze
-      end
+      mutations_from_database.changed_values
     end
 
     # Returns a hash of changed attributes indicating their original
@@ -232,9 +215,7 @@ module ActiveModel
     #   person.name = 'bob'
     #   person.changes # => { "name" => ["bill", "bob"] }
     def changes
-      cache_changed_attributes do
-        ActiveSupport::HashWithIndifferentAccess[changed.map { |attr| [attr, attribute_change(attr)] }]
-      end
+      mutations_from_database.changes
     end
 
     # Returns a hash of attributes that were changed before the model was saved.
@@ -244,27 +225,23 @@ module ActiveModel
     #   person.save
     #   person.previous_changes # => {"name" => ["bob", "robert"]}
     def previous_changes
-      @previously_changed ||= ActiveSupport::HashWithIndifferentAccess.new
-      @previously_changed.merge(mutations_before_last_save.changes)
+      mutations_before_last_save.changes
     end
 
     def attribute_changed_in_place?(attr_name) # :nodoc:
-      mutations_from_database.changed_in_place?(attr_name)
+      mutations_from_database.changed_in_place?(attr_name.to_s)
     end
 
     private
       def clear_attribute_change(attr_name)
-        mutations_from_database.forget_change(attr_name)
+        mutations_from_database.forget_change(attr_name.to_s)
       end
 
       def mutations_from_database
-        unless defined?(@mutations_from_database)
-          @mutations_from_database = nil
-        end
         @mutations_from_database ||= if defined?(@attributes)
           ActiveModel::AttributeMutationTracker.new(@attributes)
         else
-          NullMutationTracker.instance
+          ActiveModel::ForcedMutationTracker.new(self)
         end
       end
 
@@ -276,68 +253,28 @@ module ActiveModel
         @mutations_before_last_save ||= ActiveModel::NullMutationTracker.instance
       end
 
-      def cache_changed_attributes
-        @cached_changed_attributes = changed_attributes
-        yield
-      ensure
-        clear_changed_attributes_cache
-      end
-
-      def clear_changed_attributes_cache
-        remove_instance_variable(:@cached_changed_attributes) if defined?(@cached_changed_attributes)
-      end
-
-      # Returns +true+ if attr_name is changed, +false+ otherwise.
-      def changes_include?(attr_name)
-        attributes_changed_by_setter.include?(attr_name) || mutations_from_database.changed?(attr_name)
-      end
-      alias attribute_changed_by_setter? changes_include?
-
-      # Returns +true+ if attr_name were changed before the model was saved,
-      # +false+ otherwise.
-      def previous_changes_include?(attr_name)
-        previous_changes.include?(attr_name)
-      end
-
-      # Handles <tt>*_change</tt> for +method_missing+.
-      def attribute_change(attr)
-        [changed_attributes[attr], _read_attribute(attr)] if attribute_changed?(attr)
+      # Dispatch target for <tt>*_change</tt> attribute methods.
+      def attribute_change(attr_name)
+        mutations_from_database.change_to_attribute(attr_name.to_s)
       end
 
-      # Handles <tt>*_previous_change</tt> for +method_missing+.
-      def attribute_previous_change(attr)
-        previous_changes[attr]
+      # Dispatch target for <tt>*_previous_change</tt> attribute methods.
+      def attribute_previous_change(attr_name)
+        mutations_before_last_save.change_to_attribute(attr_name.to_s)
       end
 
-      # Handles <tt>*_will_change!</tt> for +method_missing+.
-      def attribute_will_change!(attr)
-        unless attribute_changed?(attr)
-          begin
-            value = _read_attribute(attr)
-            value = value.duplicable? ? value.clone : value
-          rescue TypeError, NoMethodError
-          end
-
-          set_attribute_was(attr, value)
-        end
-        mutations_from_database.force_change(attr)
+      # Dispatch target for <tt>*_will_change!</tt> attribute methods.
+      def attribute_will_change!(attr_name)
+        mutations_from_database.force_change(attr_name.to_s)
       end
 
-      # Handles <tt>restore_*!</tt> for +method_missing+.
-      def restore_attribute!(attr)
-        if attribute_changed?(attr)
-          __send__("#{attr}=", changed_attributes[attr])
-          clear_attribute_changes([attr])
+      # Dispatch target for <tt>restore_*!</tt> attribute methods.
+      def restore_attribute!(attr_name)
+        attr_name = attr_name.to_s
+        if attribute_changed?(attr_name)
+          __send__("#{attr_name}=", attribute_was(attr_name))
+          clear_attribute_change(attr_name)
         end
       end
-
-      def attributes_changed_by_setter
-        @attributes_changed_by_setter ||= ActiveSupport::HashWithIndifferentAccess.new
-      end
-
-      # Force an attribute to have a particular "before" value
-      def set_attribute_was(attr, old_value)
-        attributes_changed_by_setter[attr] = old_value
-      end
   end
 end

data/lib/active_model/errors.rb

@@ -63,9 +63,9 @@ module ActiveModel
     MESSAGE_OPTIONS = [:message]
 
     class << self
-      attr_accessor :i18n_full_message # :nodoc:
+      attr_accessor :i18n_customize_full_message # :nodoc:
     end
-    self.i18n_full_message = false
+    self.i18n_customize_full_message = false
 
     attr_reader :messages, :details
 
@@ -413,7 +413,7 @@ module ActiveModel
       return message if attribute == :base
       attribute = attribute.to_s
 
-      if self.class.i18n_full_message && @base.class.respond_to?(:i18n_scope)
+      if self.class.i18n_customize_full_message && @base.class.respond_to?(:i18n_scope)
         attribute = attribute.remove(/\[\d\]/)
         parts = attribute.split(".")
         attribute_name = parts.pop
@@ -479,6 +479,14 @@ module ActiveModel
     # * <tt>errors.messages.blank</tt>
     def generate_message(attribute, type = :invalid, options = {})
       type = options.delete(:message) if options[:message].is_a?(Symbol)
+      value = (attribute != :base ? @base.send(:read_attribute_for_validation, attribute) : nil)
+
+      options = {
+        model: @base.model_name.human,
+        attribute: @base.class.human_attribute_name(attribute),
+        value: value,
+        object: @base
+      }.merge!(options)
 
       if @base.class.respond_to?(:i18n_scope)
         i18n_scope = @base.class.i18n_scope.to_s
@@ -487,6 +495,11 @@ module ActiveModel
             :"#{i18n_scope}.errors.models.#{klass.model_name.i18n_key}.#{type}" ]
         end
         defaults << :"#{i18n_scope}.errors.messages.#{type}"
+
+        catch(:exception) do
+          translation = I18n.translate(defaults.first, options.merge(default: defaults.drop(1), throw: true))
+          return translation unless translation.nil?
+        end unless options[:message]
       else
         defaults = []
       end
@@ -496,15 +509,7 @@ module ActiveModel
 
       key = defaults.shift
       defaults = options.delete(:message) if options[:message]
-      value = (attribute != :base ? @base.send(:read_attribute_for_validation, attribute) : nil)
-
-      options = {
-        default: defaults,
-        model: @base.model_name.human,
-        attribute: @base.class.human_attribute_name(attribute),
-        value: value,
-        object: @base
-      }.merge!(options)
+      options[:default] = defaults
 
       I18n.translate(key, options)
     end

data/lib/active_model/gem_version.rb

@@ -9,8 +9,8 @@ module ActiveModel
   module VERSION
     MAJOR = 6
     MINOR = 0
-    TINY  = 0
-    PRE   = "beta3"
+    TINY  = 2
+    PRE   = "rc2"
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
   end

data/lib/active_model/railtie.rb

@@ -13,8 +13,8 @@ module ActiveModel
       ActiveModel::SecurePassword.min_cost = Rails.env.test?
     end
 
-    initializer "active_model.i18n_full_message" do
-      ActiveModel::Errors.i18n_full_message = config.active_model.delete(:i18n_full_message) || false
+    initializer "active_model.i18n_customize_full_message" do
+      ActiveModel::Errors.i18n_customize_full_message = config.active_model.delete(:i18n_customize_full_message) || false
     end
   end
 end

data/lib/active_model/secure_password.rb

@@ -69,6 +69,27 @@ module ActiveModel
           raise
         end
 
+        include InstanceMethodsOnActivation.new(attribute)
+
+        if validations
+          include ActiveModel::Validations
+
+          # This ensures the model has a password by checking whether the password_digest
+          # is present, so that this works with both new and existing records. However,
+          # when there is an error, the message is added to the password attribute instead
+          # so that the error message will make sense to the end-user.
+          validate do |record|
+            record.errors.add(attribute, :blank) unless record.send("#{attribute}_digest").present?
+          end
+
+          validates_length_of attribute, maximum: ActiveModel::SecurePassword::MAX_PASSWORD_LENGTH_ALLOWED
+          validates_confirmation_of attribute, allow_blank: true
+        end
+      end
+    end
+
+    class InstanceMethodsOnActivation < Module
+      def initialize(attribute)
         attr_reader attribute
 
         define_method("#{attribute}=") do |unencrypted_password|
@@ -101,21 +122,6 @@ module ActiveModel
         end
 
         alias_method :authenticate, :authenticate_password if attribute == :password
-
-        if validations
-          include ActiveModel::Validations
-
-          # This ensures the model has a password by checking whether the password_digest
-          # is present, so that this works with both new and existing records. However,
-          # when there is an error, the message is added to the password attribute instead
-          # so that the error message will make sense to the end-user.
-          validate do |record|
-            record.errors.add(attribute, :blank) unless record.send("#{attribute}_digest").present?
-          end
-
-          validates_length_of attribute, maximum: ActiveModel::SecurePassword::MAX_PASSWORD_LENGTH_ALLOWED
-          validates_confirmation_of attribute, allow_blank: true
-        end
       end
     end
   end

data/lib/active_model/type/boolean.rb

@@ -14,7 +14,16 @@ module ActiveModel
     # - Empty strings are coerced to +nil+
     # - All other values will be coerced to +true+
     class Boolean < Value
-      FALSE_VALUES = [false, 0, "0", "f", "F", "false", "FALSE", "off", "OFF"].to_set
+      FALSE_VALUES = [
+        false, 0,
+        "0", :"0",
+        "f", :f,
+        "F", :F,
+        "false", :false,
+        "FALSE", :FALSE,
+        "off", :off,
+        "OFF", :OFF,
+      ].to_set.freeze
 
       def type # :nodoc:
         :boolean

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

@@ -22,10 +22,17 @@ module ActiveModel
         end
 
         def apply_seconds_precision(value)
-          return value unless precision && value.respond_to?(:usec)
-          number_of_insignificant_digits = 6 - precision
+          return value unless precision && value.respond_to?(:nsec)
+
+          number_of_insignificant_digits = 9 - precision
           round_power = 10**number_of_insignificant_digits
-          value.change(usec: value.usec - value.usec % round_power)
+          rounded_off_nsec = value.nsec % round_power
+
+          if rounded_off_nsec > 0
+            value.change(nsec: value.nsec - rounded_off_nsec)
+          else
+            value
+          end
         end
 
         def type_cast_for_schema(value)

data/lib/active_model/type/integer.rb

@@ -18,6 +18,11 @@ module ActiveModel
         :integer
       end
 
+      def deserialize(value)
+        return if value.blank?
+        value.to_i
+      end
+
       def serialize(value)
         return if value.is_a?(::String) && non_numeric_string?(value)
         ensure_in_range(super)

data/lib/active_model/validations/acceptance.rb

@@ -17,7 +17,8 @@ module ActiveModel
       private
 
         def setup!(klass)
-          klass.include(LazilyDefineAttributes.new(AttributeDefinition.new(attributes)))
+          define_attributes = LazilyDefineAttributes.new(attributes)
+          klass.include(define_attributes) unless klass.included_modules.include?(define_attributes)
         end
 
         def acceptable_option?(value)
@@ -25,46 +26,57 @@ module ActiveModel
         end
 
         class LazilyDefineAttributes < Module
-          def initialize(attribute_definition)
+          def initialize(attributes)
+            @attributes = attributes.map(&:to_s)
+          end
+
+          def included(klass)
+            @lock = Mutex.new
+            mod = self
+
             define_method(:respond_to_missing?) do |method_name, include_private = false|
-              super(method_name, include_private) || attribute_definition.matches?(method_name)
+              mod.define_on(klass)
+              super(method_name, include_private) || mod.matches?(method_name)
             end
 
             define_method(:method_missing) do |method_name, *args, &block|
-              if attribute_definition.matches?(method_name)
-                attribute_definition.define_on(self.class)
+              mod.define_on(klass)
+              if mod.matches?(method_name)
                 send(method_name, *args, &block)
               else
                 super(method_name, *args, &block)
               end
             end
           end
-        end
-
-        class AttributeDefinition
-          def initialize(attributes)
-            @attributes = attributes.map(&:to_s)
-          end
 
           def matches?(method_name)
-            attr_name = convert_to_reader_name(method_name)
-            attributes.include?(attr_name)
+            attr_name = method_name.to_s.chomp("=")
+            attributes.any? { |name| name == attr_name }
           end
 
           def define_on(klass)
-            attr_readers = attributes.reject { |name| klass.attribute_method?(name) }
-            attr_writers = attributes.reject { |name| klass.attribute_method?("#{name}=") }
-            klass.define_attribute_methods
-            klass.attr_reader(*attr_readers)
-            klass.attr_writer(*attr_writers)
-          end
+            @lock&.synchronize do
+              return unless @lock
 
-          private
-            attr_reader :attributes
+              attr_readers = attributes.reject { |name| klass.attribute_method?(name) }
+              attr_writers = attributes.reject { |name| klass.attribute_method?("#{name}=") }
+
+              attr_reader(*attr_readers)
+              attr_writer(*attr_writers)
 
-            def convert_to_reader_name(method_name)
-              method_name.to_s.chomp("=")
+              remove_method :respond_to_missing?
+              remove_method :method_missing
+
+              @lock = nil
             end
+          end
+
+          def ==(other)
+            self.class == other.class && attributes == other.attributes
+          end
+
+          protected
+            attr_reader :attributes
         end
     end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activemodel
 version: !ruby/object:Gem::Version
-  version: 6.0.0.beta3
+  version: 6.0.2.rc2
 platform: ruby
 authors:
 - David Heinemeier Hansson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-03-13 00:00:00.000000000 Z
+date: 2019-12-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 6.0.0.beta3
+        version: 6.0.2.rc2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 6.0.0.beta3
+        version: 6.0.2.rc2
 description: A toolkit for building modeling frameworks like Active Record. Rich support
   for attributes, callbacks, validations, serialization, internationalization, and
   testing.
@@ -97,12 +97,15 @@ files:
 - lib/active_model/validations/with.rb
 - lib/active_model/validator.rb
 - lib/active_model/version.rb
-homepage: http://rubyonrails.org
+homepage: https://rubyonrails.org
 licenses:
 - MIT
 metadata:
-  source_code_uri: https://github.com/rails/rails/tree/v6.0.0.beta3/activemodel
-  changelog_uri: https://github.com/rails/rails/blob/v6.0.0.beta3/activemodel/CHANGELOG.md
+  bug_tracker_uri: https://github.com/rails/rails/issues
+  changelog_uri: https://github.com/rails/rails/blob/v6.0.2.rc2/activemodel/CHANGELOG.md
+  documentation_uri: https://api.rubyonrails.org/v6.0.2.rc2/
+  mailing_list_uri: https://groups.google.com/forum/#!forum/rubyonrails-talk
+  source_code_uri: https://github.com/rails/rails/tree/v6.0.2.rc2/activemodel
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -118,7 +121,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 1.3.1
 requirements: []
-rubygems_version: 3.0.1
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: A toolkit for building modeling frameworks (part of Rails).