activemodel 6.0.4 → 6.1.4

data/lib/active_model/attribute_mutation_tracker.rb

@@ -7,9 +7,8 @@ module ActiveModel
   class AttributeMutationTracker # :nodoc:
     OPTION_NOT_GIVEN = Object.new
 
-    def initialize(attributes, forced_changes = Set.new)
+    def initialize(attributes)
       @attributes = attributes
-      @forced_changes = forced_changes
     end
 
     def changed_attribute_names
@@ -62,11 +61,15 @@ module ActiveModel
     end
 
     def force_change(attr_name)
-      forced_changes << attr_name
+      forced_changes[attr_name] = fetch_value(attr_name)
     end
 
     private
-      attr_reader :attributes, :forced_changes
+      attr_reader :attributes
+
+      def forced_changes
+        @forced_changes ||= {}
+      end
 
       def attr_names
         attributes.keys
@@ -82,7 +85,7 @@ module ActiveModel
   end
 
   class ForcedMutationTracker < AttributeMutationTracker # :nodoc:
-    def initialize(attributes, forced_changes = {})
+    def initialize(attributes)
       super
       @finalized_changes = nil
     end

data/lib/active_model/attribute_set.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "active_support/core_ext/enumerable"
 require "active_support/core_ext/object/deep_dup"
 require "active_model/attribute_set/builder"
 require "active_model/attribute_set/yaml_encoder"
@@ -13,11 +14,11 @@ module ActiveModel
     end
 
     def [](name)
-      attributes[name] || Attribute.null(name)
+      @attributes[name] || default_attribute(name)
     end
 
     def []=(name, value)
-      attributes[name] = value
+      @attributes[name] = value
     end
 
     def values_before_type_cast
@@ -25,9 +26,9 @@ module ActiveModel
     end
 
     def to_hash
-      initialized_attributes.transform_values(&:value)
+      keys.index_with { |name| self[name].value }
     end
-    alias_method :to_h, :to_hash
+    alias :to_h :to_hash
 
     def key?(name)
       attributes.key?(name) && self[name].initialized?
@@ -42,35 +43,36 @@ module ActiveModel
     end
 
     def write_from_database(name, value)
-      attributes[name] = self[name].with_value_from_database(value)
+      @attributes[name] = self[name].with_value_from_database(value)
     end
 
     def write_from_user(name, value)
-      attributes[name] = self[name].with_value_from_user(value)
+      raise FrozenError, "can't modify frozen attributes" if frozen?
+      @attributes[name] = self[name].with_value_from_user(value)
+      value
     end
 
     def write_cast_value(name, value)
-      attributes[name] = self[name].with_cast_value(value)
+      @attributes[name] = self[name].with_cast_value(value)
+      value
     end
 
     def freeze
-      @attributes.freeze
+      attributes.freeze
       super
     end
 
     def deep_dup
-      self.class.allocate.tap do |copy|
-        copy.instance_variable_set(:@attributes, attributes.deep_dup)
-      end
+      AttributeSet.new(attributes.deep_dup)
     end
 
     def initialize_dup(_)
-      @attributes = attributes.dup
+      @attributes = @attributes.dup
       super
     end
 
     def initialize_clone(_)
-      @attributes = attributes.clone
+      @attributes = @attributes.clone
       super
     end
 
@@ -81,7 +83,7 @@ module ActiveModel
     end
 
     def accessed
-      attributes.select { |_, attr| attr.has_been_read? }.keys
+      attributes.each_key.select { |name| self[name].has_been_read? }
     end
 
     def map(&block)
@@ -97,8 +99,8 @@ module ActiveModel
       attr_reader :attributes
 
     private
-      def initialized_attributes
-        attributes.select { |_, attr| attr.initialized? }
+      def default_attribute(name)
+        Attribute.null(name)
       end
   end
 end

data/lib/active_model/attribute_set/builder.rb

@@ -13,14 +13,86 @@ module ActiveModel
       end
 
       def build_from_database(values = {}, additional_types = {})
-        attributes = LazyAttributeHash.new(types, values, additional_types, default_attributes)
-        AttributeSet.new(attributes)
+        LazyAttributeSet.new(values, types, additional_types, default_attributes)
       end
     end
   end
 
+  class LazyAttributeSet < AttributeSet # :nodoc:
+    def initialize(values, types, additional_types, default_attributes, attributes = {})
+      super(attributes)
+      @values = values
+      @types = types
+      @additional_types = additional_types
+      @default_attributes = default_attributes
+      @casted_values = {}
+      @materialized = false
+    end
+
+    def key?(name)
+      (values.key?(name) || types.key?(name) || @attributes.key?(name)) && self[name].initialized?
+    end
+
+    def keys
+      keys = values.keys | types.keys | @attributes.keys
+      keys.keep_if { |name| self[name].initialized? }
+    end
+
+    def fetch_value(name, &block)
+      if attr = @attributes[name]
+        return attr.value(&block)
+      end
+
+      @casted_values.fetch(name) do
+        value_present = true
+        value = values.fetch(name) { value_present = false }
+
+        if value_present
+          type = additional_types.fetch(name, types[name])
+          @casted_values[name] = type.deserialize(value)
+        else
+          attr = default_attribute(name, value_present, value)
+          attr.value(&block)
+        end
+      end
+    end
+
+    protected
+      def attributes
+        unless @materialized
+          values.each_key { |key| self[key] }
+          types.each_key { |key| self[key] }
+          @materialized = true
+        end
+        @attributes
+      end
+
+    private
+      attr_reader :values, :types, :additional_types, :default_attributes
+
+      def default_attribute(
+        name,
+        value_present = true,
+        value = values.fetch(name) { value_present = false }
+      )
+        type = additional_types.fetch(name, types[name])
+
+        if value_present
+          @attributes[name] = Attribute.from_database(name, value, type, @casted_values[name])
+        elsif types.key?(name)
+          if attr = default_attributes[name]
+            @attributes[name] = attr.dup
+          else
+            @attributes[name] = Attribute.uninitialized(name, type)
+          end
+        else
+          Attribute.null(name)
+        end
+      end
+  end
+
   class LazyAttributeHash # :nodoc:
-    delegate :transform_values, :each_key, :each_value, :fetch, :except, to: :materialize
+    delegate :transform_values, :each_value, :fetch, :except, to: :materialize
 
     def initialize(types, values, additional_types, default_attributes, delegate_hash = {})
       @types = types
@@ -40,9 +112,6 @@ module ActiveModel
     end
 
     def []=(key, value)
-      if frozen?
-        raise RuntimeError, "Can't modify frozen hash"
-      end
       delegate_hash[key] = value
     end
 
@@ -57,14 +126,9 @@ module ActiveModel
       super
     end
 
-    def select
+    def each_key(&block)
       keys = types.keys | values.keys | delegate_hash.keys
-      keys.each_with_object({}) do |key, hash|
-        attribute = self[key]
-        if yield(key, attribute)
-          hash[key] = attribute
-        end
-      end
+      keys.each(&block)
     end
 
     def ==(other)
@@ -81,6 +145,9 @@ module ActiveModel
 
     def marshal_load(values)
       if values.is_a?(Hash)
+        ActiveSupport::Deprecation.warn(<<~MSG)
+          Marshalling load from legacy attributes format is deprecated and will be removed in Rails 6.2.
+        MSG
         empty_hash = {}.freeze
         initialize(empty_hash, empty_hash, empty_hash, empty_hash, values)
         @materialized = true

data/lib/active_model/attributes.rb

@@ -42,16 +42,14 @@ module ActiveModel
       end
 
       private
-        def define_method_attribute=(name)
+        def define_method_attribute=(name, owner:)
           ActiveModel::AttributeMethods::AttrNames.define_attribute_accessor_method(
-            generated_attribute_methods, name, writer: true,
+            owner, name, writer: true,
           ) do |temp_method_name, attr_name_expr|
-            generated_attribute_methods.module_eval <<-RUBY, __FILE__, __LINE__ + 1
-              def #{temp_method_name}(value)
-                name = #{attr_name_expr}
-                write_attribute(name, value)
-              end
-            RUBY
+            owner <<
+              "def #{temp_method_name}(value)" <<
+              "  _write_attribute(#{attr_name_expr}, value)" <<
+              "end"
           end
         end
 
@@ -79,10 +77,14 @@ module ActiveModel
       super
     end
 
+    def initialize_dup(other) # :nodoc:
+      @attributes = @attributes.deep_dup
+      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
@@ -112,25 +114,19 @@ module ActiveModel
       @attributes.keys
     end
 
-    private
-      def write_attribute(attr_name, value)
-        name = attr_name.to_s
-        name = self.class.attribute_aliases[name] || name
+    def freeze
+      @attributes = @attributes.clone.freeze unless frozen?
+      super
+    end
 
-        @attributes.write_from_user(name, value)
-        value
+    private
+      def _write_attribute(attr_name, value)
+        @attributes.write_from_user(attr_name, value)
       end
+      alias :attribute= :_write_attribute
 
       def attribute(attr_name)
-        name = attr_name.to_s
-        name = self.class.attribute_aliases[name] || name
-
-        @attributes.fetch_value(name)
-      end
-
-      # Dispatch target for <tt>*=</tt> attribute methods.
-      def attribute=(attribute_name, value)
-        write_attribute(attribute_name, value)
+        @attributes.fetch_value(attr_name)
       end
   end
 end

data/lib/active_model/callbacks.rb

@@ -147,7 +147,7 @@ module ActiveModel
           conditional = ActiveSupport::Callbacks::Conditionals::Value.new { |v|
             v != false
           }
-          options[:if] = Array(options[:if]) << conditional
+          options[:if] = Array(options[:if]) + [conditional]
           set_callback(:"#{callback}", :after, *args, options, &block)
         end
       end

data/lib/active_model/dirty.rb

@@ -83,7 +83,9 @@ module ActiveModel
   #
   #   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         # => {}
   #
@@ -122,8 +124,9 @@ module ActiveModel
 
     included do
       attribute_method_suffix "_changed?", "_change", "_will_change!", "_was"
-      attribute_method_suffix "_previously_changed?", "_previous_change"
+      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:
@@ -136,7 +139,12 @@ module ActiveModel
       @mutations_from_database = nil
     end
 
-    # Clears dirty data and moves +changes+ to +previously_changed+ and
+    def as_json(options = {}) # :nodoc:
+      options[:except] = [options[:except], "mutations_from_database"].flatten
+      super(options)
+    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)
@@ -176,8 +184,13 @@ module ActiveModel
     end
 
     # 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)
+    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.

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