activemodel 4.2.0 → 6.1.0

data/lib/active_model/dirty.rb

@@ -1,6 +1,6 @@
-require 'active_support/hash_with_indifferent_access'
-require 'active_support/core_ext/object/duplicable'
-require 'active_support/core_ext/string/filters'
+# frozen_string_literal: true
+
+require "active_model/attribute_mutation_tracker"
 
 module ActiveModel
   # == Active \Model \Dirty
@@ -13,7 +13,7 @@ module ActiveModel
   # * <tt>include ActiveModel::Dirty</tt> in your object.
   # * Call <tt>define_attribute_methods</tt> passing each method you want to
   #   track.
-  # * Call <tt>attr_name_will_change!</tt> before each change to the tracked
+  # * Call <tt>[attr_name]_will_change!</tt> before each change to the tracked
   #   attribute.
   # * Call <tt>changes_applied</tt> after the changes are persisted.
   # * Call <tt>clear_changes_information</tt> when you want to reset the changes
@@ -27,6 +27,10 @@ module ActiveModel
   #
   #     define_attribute_methods :name
   #
+  #     def initialize
+  #       @name = nil
+  #     end
+  #
   #     def name
   #       @name
   #     end
@@ -53,80 +57,106 @@ module ActiveModel
   #     end
   #   end
   #
-  # A newly instantiated object is unchanged:
+  # A newly instantiated +Person+ object is unchanged:
   #
-  #   person = Person.find_by(name: 'Uncle Bob')
-  #   person.changed?       # => false
+  #   person = Person.new
+  #   person.changed? # => false
   #
   # Change the name:
   #
   #   person.name = 'Bob'
   #   person.changed?       # => true
   #   person.name_changed?  # => true
-  #   person.name_changed?(from: "Uncle Bob", to: "Bob") # => true
-  #   person.name_was       # => "Uncle Bob"
-  #   person.name_change    # => ["Uncle Bob", "Bob"]
+  #   person.name_changed?(from: nil, to: "Bob") # => true
+  #   person.name_was       # => nil
+  #   person.name_change    # => [nil, "Bob"]
   #   person.name = 'Bill'
-  #   person.name_change    # => ["Uncle Bob", "Bill"]
+  #   person.name_change    # => [nil, "Bill"]
   #
   # Save the changes:
   #
   #   person.save
-  #   person.changed?       # => false
-  #   person.name_changed?  # => false
+  #   person.changed?      # => false
+  #   person.name_changed? # => false
   #
   # Reset the changes:
   #
-  #   person.previous_changes # => {"name" => ["Uncle Bob", "Bill"]}
+  #   person.previous_changes         # => {"name" => [nil, "Bill"]}
+  #   person.name_previously_changed? # => true
+  #   person.name_previously_changed?(from: nil, to: "Bill") # => true
+  #   person.name_previous_change     # => [nil, "Bill"]
+  #   person.name_previously_was      # => nil
   #   person.reload!
-  #   person.previous_changes # => {}
+  #   person.previous_changes         # => {}
   #
   # Rollback the changes:
   #
   #   person.name = "Uncle Bob"
   #   person.rollback!
-  #   person.name           # => "Bill"
-  #   person.name_changed?  # => false
+  #   person.name          # => "Bill"
+  #   person.name_changed? # => false
   #
   # Assigning the same value leaves the attribute unchanged:
   #
   #   person.name = 'Bill'
-  #   person.name_changed?  # => false
-  #   person.name_change    # => nil
+  #   person.name_changed? # => false
+  #   person.name_change   # => nil
   #
   # Which attributes have changed?
   #
   #   person.name = 'Bob'
-  #   person.changed        # => ["name"]
-  #   person.changes        # => {"name" => ["Bill", "Bob"]}
+  #   person.changed # => ["name"]
+  #   person.changes # => {"name" => ["Bill", "Bob"]}
   #
   # If an attribute is modified in-place then make use of
-  # +[attribute_name]_will_change!+ to mark that the attribute is changing.
-  # Otherwise Active Model can't track changes to in-place attributes. Note
+  # <tt>[attribute_name]_will_change!</tt> to mark that the attribute is changing.
+  # Otherwise \Active \Model can't track changes to in-place attributes. Note
   # that Active Record can detect in-place modifications automatically. You do
-  # not need to call +[attribute_name]_will_change!+ on Active Record models.
+  # not need to call <tt>[attribute_name]_will_change!</tt> on Active Record models.
   #
   #   person.name_will_change!
-  #   person.name_change    # => ["Bill", "Bill"]
+  #   person.name_change # => ["Bill", "Bill"]
   #   person.name << 'y'
-  #   person.name_change    # => ["Bill", "Billy"]
+  #   person.name_change # => ["Bill", "Billy"]
   module Dirty
     extend ActiveSupport::Concern
     include ActiveModel::AttributeMethods
 
     included do
-      attribute_method_suffix '_changed?', '_change', '_will_change!', '_was'
-      attribute_method_affix prefix: 'reset_', suffix: '!'
-      attribute_method_affix prefix: 'restore_', suffix: '!'
+      attribute_method_suffix "_changed?", "_change", "_will_change!", "_was"
+      attribute_method_suffix "_previously_changed?", "_previous_change", "_previously_was"
+      attribute_method_affix prefix: "restore_", suffix: "!"
+      attribute_method_affix prefix: "clear_", suffix: "_change"
+    end
+
+    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))
+        end
+      end
+      @mutations_from_database = nil
+    end
+
+    # Clears dirty data and moves +changes+ to +previous_changes+ and
+    # +mutations_from_database+ to +mutations_before_last_save+ respectively.
+    def changes_applied
+      unless defined?(@attributes)
+        mutations_from_database.finalize_changes
+      end
+      @mutations_before_last_save = mutations_from_database
+      forget_attribute_assignments
+      @mutations_from_database = nil
     end
 
-    # Returns +true+ if any attribute have unsaved changes, +false+ otherwise.
+    # Returns +true+ if any of the attributes has unsaved changes, +false+ otherwise.
     #
     #   person.changed? # => false
     #   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.
@@ -135,7 +165,55 @@ module ActiveModel
     #   person.name = 'bob'
     #   person.changed # => ["name"]
     def changed
-      changed_attributes.keys
+      mutations_from_database.changed_attribute_names
+    end
+
+    # 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
+
+    # Dispatch target for <tt>*_was</tt> attribute methods.
+    def attribute_was(attr_name) # :nodoc:
+      mutations_from_database.original_value(attr_name.to_s)
+    end
+
+    # Dispatch target for <tt>*_previously_changed?</tt> attribute methods.
+    def attribute_previously_changed?(attr_name, **options) # :nodoc:
+      mutations_before_last_save.changed?(attr_name.to_s, **options)
+    end
+
+    # Dispatch target for <tt>*_previously_was</tt> attribute methods.
+    def attribute_previously_was(attr_name) # :nodoc:
+      mutations_before_last_save.original_value(attr_name.to_s)
+    end
+
+    # Restore all previous data of the provided attributes.
+    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
+      @mutations_before_last_save = nil
+      forget_attribute_assignments
+      @mutations_from_database = nil
+    end
+
+    def clear_attribute_changes(attr_names)
+      attr_names.each do |attr_name|
+        clear_attribute_change(attr_name)
+      end
+    end
+
+    # Returns a hash of the attributes with unsaved changes indicating their original
+    # values like <tt>attr => original value</tt>.
+    #
+    #   person.name # => "bob"
+    #   person.name = 'robert'
+    #   person.changed_attributes # => {"name" => "bob"}
+    def changed_attributes
+      mutations_from_database.changed_values
     end
 
     # Returns a hash of changed attributes indicating their original
@@ -145,7 +223,7 @@ module ActiveModel
     #   person.name = 'bob'
     #   person.changes # => { "name" => ["bill", "bob"] }
     def changes
-      ActiveSupport::HashWithIndifferentAccess[changed.map { |attr| [attr, attribute_change(attr)] }]
+      mutations_from_database.changes
     end
 
     # Returns a hash of attributes that were changed before the model was saved.
@@ -155,108 +233,56 @@ module ActiveModel
     #   person.save
     #   person.previous_changes # => {"name" => ["bob", "robert"]}
     def previous_changes
-      @previously_changed ||= ActiveSupport::HashWithIndifferentAccess.new
-    end
-
-    # Returns a hash of the attributes with unsaved changes indicating their original
-    # values like <tt>attr => original value</tt>.
-    #
-    #   person.name # => "bob"
-    #   person.name = 'robert'
-    #   person.changed_attributes # => {"name" => "bob"}
-    def changed_attributes
-      @changed_attributes ||= ActiveSupport::HashWithIndifferentAccess.new
-    end
-
-    # Handle <tt>*_changed?</tt> for +method_missing+.
-    def attribute_changed?(attr, options = {}) #:nodoc:
-      result = changed_attributes.include?(attr)
-      result &&= options[:to] == __send__(attr) if options.key?(:to)
-      result &&= options[:from] == changed_attributes[attr] if options.key?(:from)
-      result
+      mutations_before_last_save.changes
     end
 
-    # Handle <tt>*_was</tt> for +method_missing+.
-    def attribute_was(attr) # :nodoc:
-      attribute_changed?(attr) ? changed_attributes[attr] : __send__(attr)
-    end
-
-    # Restore all previous data of the provided attributes.
-    def restore_attributes(attributes = changed)
-      attributes.each { |attr| restore_attribute! attr }
+    def attribute_changed_in_place?(attr_name) # :nodoc:
+      mutations_from_database.changed_in_place?(attr_name.to_s)
     end
 
     private
-
-      # Removes current changes and makes them accessible through +previous_changes+.
-      def changes_applied # :doc:
-        @previously_changed = changes
-        @changed_attributes = ActiveSupport::HashWithIndifferentAccess.new
+      def clear_attribute_change(attr_name)
+        mutations_from_database.forget_change(attr_name.to_s)
       end
 
-      # Clear all dirty data: current changes and previous changes.
-      def clear_changes_information # :doc:
-        @previously_changed = ActiveSupport::HashWithIndifferentAccess.new
-        @changed_attributes = ActiveSupport::HashWithIndifferentAccess.new
+      def mutations_from_database
+        @mutations_from_database ||= if defined?(@attributes)
+          ActiveModel::AttributeMutationTracker.new(@attributes)
+        else
+          ActiveModel::ForcedMutationTracker.new(self)
+        end
       end
 
-      def reset_changes
-        ActiveSupport::Deprecation.warn(<<-MSG.squish)
-          `#reset_changes` is deprecated and will be removed on Rails 5.
-          Please use `#clear_changes_information` instead.
-        MSG
-
-        clear_changes_information
+      def forget_attribute_assignments
+        @attributes = @attributes.map(&:forgetting_assignment) if defined?(@attributes)
       end
 
-      # Handle <tt>*_change</tt> for +method_missing+.
-      def attribute_change(attr)
-        [changed_attributes[attr], __send__(attr)] if attribute_changed?(attr)
+      def mutations_before_last_save
+        @mutations_before_last_save ||= ActiveModel::NullMutationTracker.instance
       end
 
-      # Handle <tt>*_will_change!</tt> for +method_missing+.
-      def attribute_will_change!(attr)
-        return if attribute_changed?(attr)
-
-        begin
-          value = __send__(attr)
-          value = value.duplicable? ? value.clone : value
-        rescue TypeError, NoMethodError
-        end
-
-        set_attribute_was(attr, value)
+      # Dispatch target for <tt>*_change</tt> attribute methods.
+      def attribute_change(attr_name)
+        mutations_from_database.change_to_attribute(attr_name.to_s)
       end
 
-      # Handle <tt>reset_*!</tt> for +method_missing+.
-      def reset_attribute!(attr)
-        ActiveSupport::Deprecation.warn(<<-MSG.squish)
-          `#reset_#{attr}!` is deprecated and will be removed on Rails 5.
-          Please use `#restore_#{attr}!` instead.
-        MSG
-
-        restore_attribute!(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
 
-      # Handle <tt>restore_*!</tt> for +method_missing+.
-      def restore_attribute!(attr)
-        if attribute_changed?(attr)
-          __send__("#{attr}=", changed_attributes[attr])
-          clear_attribute_changes([attr])
-        end
+      # 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
 
-      # This is necessary because `changed_attributes` might be overridden in
-      # other implemntations (e.g. in `ActiveRecord`)
-      alias_method :attributes_changed_by_setter, :changed_attributes # :nodoc:
-
-      # Force an attribute to have a particular "before" value
-      def set_attribute_was(attr, old_value)
-        attributes_changed_by_setter[attr] = old_value
-      end
-
-      # Remove changes information for the provided attributes.
-      def clear_attribute_changes(attributes) # :doc:
-        attributes_changed_by_setter.except!(*attributes)
+      # 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
   end
 end

data/lib/active_model/error.rb

@@ -0,0 +1,207 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/class/attribute"
+
+module ActiveModel
+  # == Active \Model \Error
+  #
+  # Represents one single error
+  class Error
+    CALLBACKS_OPTIONS = [:if, :unless, :on, :allow_nil, :allow_blank, :strict]
+    MESSAGE_OPTIONS = [:message]
+
+    class_attribute :i18n_customize_full_message, default: false
+
+    def self.full_message(attribute, message, base) # :nodoc:
+      return message if attribute == :base
+
+      base_class = base.class
+      attribute = attribute.to_s
+
+      if i18n_customize_full_message && base_class.respond_to?(:i18n_scope)
+        attribute = attribute.remove(/\[\d+\]/)
+        parts = attribute.split(".")
+        attribute_name = parts.pop
+        namespace = parts.join("/") unless parts.empty?
+        attributes_scope = "#{base_class.i18n_scope}.errors.models"
+
+        if namespace
+          defaults = base_class.lookup_ancestors.map do |klass|
+            [
+              :"#{attributes_scope}.#{klass.model_name.i18n_key}/#{namespace}.attributes.#{attribute_name}.format",
+              :"#{attributes_scope}.#{klass.model_name.i18n_key}/#{namespace}.format",
+            ]
+          end
+        else
+          defaults = base_class.lookup_ancestors.map do |klass|
+            [
+              :"#{attributes_scope}.#{klass.model_name.i18n_key}.attributes.#{attribute_name}.format",
+              :"#{attributes_scope}.#{klass.model_name.i18n_key}.format",
+            ]
+          end
+        end
+
+        defaults.flatten!
+      else
+        defaults = []
+      end
+
+      defaults << :"errors.format"
+      defaults << "%{attribute} %{message}"
+
+      attr_name = attribute.tr(".", "_").humanize
+      attr_name = base_class.human_attribute_name(attribute, {
+        default: attr_name,
+        base: base,
+      })
+
+      I18n.t(defaults.shift,
+        default:  defaults,
+        attribute: attr_name,
+        message:   message)
+    end
+
+    def self.generate_message(attribute, type, base, options) # :nodoc:
+      type = options.delete(:message) if options[:message].is_a?(Symbol)
+      value = (attribute != :base ? base.read_attribute_for_validation(attribute) : nil)
+
+      options = {
+        model: base.model_name.human,
+        attribute: base.class.human_attribute_name(attribute, { base: base }),
+        value: value,
+        object: base
+      }.merge!(options)
+
+      if base.class.respond_to?(:i18n_scope)
+        i18n_scope = base.class.i18n_scope.to_s
+        attribute = attribute.to_s.remove(/\[\d+\]/)
+
+        defaults = base.class.lookup_ancestors.flat_map do |klass|
+          [ :"#{i18n_scope}.errors.models.#{klass.model_name.i18n_key}.attributes.#{attribute}.#{type}",
+            :"#{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
+
+      defaults << :"errors.attributes.#{attribute}.#{type}"
+      defaults << :"errors.messages.#{type}"
+
+      key = defaults.shift
+      defaults = options.delete(:message) if options[:message]
+      options[:default] = defaults
+
+      I18n.translate(key, **options)
+    end
+
+    def initialize(base, attribute, type = :invalid, **options)
+      @base = base
+      @attribute = attribute
+      @raw_type = type
+      @type = type || :invalid
+      @options = options
+    end
+
+    def initialize_dup(other) # :nodoc:
+      @attribute = @attribute.dup
+      @raw_type = @raw_type.dup
+      @type = @type.dup
+      @options = @options.deep_dup
+    end
+
+    # The object which the error belongs to
+    attr_reader :base
+    # The attribute of +base+ which the error belongs to
+    attr_reader :attribute
+    # The type of error, defaults to `:invalid` unless specified
+    attr_reader :type
+    # The raw value provided as the second parameter when calling `errors#add`
+    attr_reader :raw_type
+    # The options provided when calling `errors#add`
+    attr_reader :options
+
+    # Returns the error message.
+    #
+    #   error = ActiveModel::Error.new(person, :name, :too_short, count: 5)
+    #   error.message
+    #   # => "is too short (minimum is 5 characters)"
+    def message
+      case raw_type
+      when Symbol
+        self.class.generate_message(attribute, raw_type, @base, options.except(*CALLBACKS_OPTIONS))
+      else
+        raw_type
+      end
+    end
+
+    # Returns the error details.
+    #
+    #   error = ActiveModel::Error.new(person, :name, :too_short, count: 5)
+    #   error.details
+    #   # => { error: :too_short, count: 5 }
+    def details
+      { error: raw_type }.merge(options.except(*CALLBACKS_OPTIONS + MESSAGE_OPTIONS))
+    end
+    alias_method :detail, :details
+
+    # Returns the full error message.
+    #
+    #   error = ActiveModel::Error.new(person, :name, :too_short, count: 5)
+    #   error.full_message
+    #   # => "Name is too short (minimum is 5 characters)"
+    def full_message
+      self.class.full_message(attribute, message, @base)
+    end
+
+    # See if error matches provided +attribute+, +type+ and +options+.
+    #
+    # Omitted params are not checked for a match.
+    def match?(attribute, type = nil, **options)
+      if @attribute != attribute || (type && @type != type)
+        return false
+      end
+
+      options.each do |key, value|
+        if @options[key] != value
+          return false
+        end
+      end
+
+      true
+    end
+
+    # See if error matches provided +attribute+, +type+ and +options+ exactly.
+    #
+    # All params must be equal to Error's own attributes to be considered a
+    # strict match.
+    def strict_match?(attribute, type, **options)
+      return false unless match?(attribute, type)
+
+      options == @options.except(*CALLBACKS_OPTIONS + MESSAGE_OPTIONS)
+    end
+
+    def ==(other) # :nodoc:
+      other.is_a?(self.class) && attributes_for_hash == other.attributes_for_hash
+    end
+    alias eql? ==
+
+    def hash # :nodoc:
+      attributes_for_hash.hash
+    end
+
+    def inspect # :nodoc:
+      "#<#{self.class.name} attribute=#{@attribute}, type=#{@type}, options=#{@options.inspect}>"
+    end
+
+    protected
+      def attributes_for_hash
+        [@base, @attribute, @raw_type, @options.except(*CALLBACKS_OPTIONS)]
+      end
+  end
+end