activemodel 7.0.4 → 6.1.7.1

data/lib/active_model/attributes.rb

@@ -4,26 +4,25 @@ require "active_model/attribute_set"
 require "active_model/attribute/user_provided_default"
 
 module ActiveModel
-  module Attributes # :nodoc:
+  module Attributes #:nodoc:
     extend ActiveSupport::Concern
     include ActiveModel::AttributeMethods
 
     included do
-      attribute_method_suffix "=", parameters: "value"
+      attribute_method_suffix "="
       class_attribute :attribute_types, :_default_attributes, instance_accessor: false
       self.attribute_types = Hash.new(Type.default_value)
       self._default_attributes = AttributeSet.new({})
     end
 
     module ClassMethods
-      def attribute(name, cast_type = nil, default: NO_DEFAULT_PROVIDED, **options)
+      def attribute(name, type = Type::Value.new, **options)
         name = name.to_s
-
-        cast_type = Type.lookup(cast_type, **options) if Symbol === cast_type
-        cast_type ||= attribute_types[name]
-
-        self.attribute_types = attribute_types.merge(name => cast_type)
-        define_default_attribute(name, default, cast_type)
+        if type.is_a?(Symbol)
+          type = ActiveModel::Type.lookup(type, **options.except(:default))
+        end
+        self.attribute_types = attribute_types.merge(name => type)
+        define_default_attribute(name, options.fetch(:default, NO_DEFAULT_PROVIDED), type)
         define_attribute_method(name)
       end
 
@@ -47,12 +46,10 @@ module ActiveModel
           ActiveModel::AttributeMethods::AttrNames.define_attribute_accessor_method(
             owner, name, writer: true,
           ) do |temp_method_name, attr_name_expr|
-            owner.define_cached_method("#{name}=", as: temp_method_name, namespace: :active_model) do |batch|
-              batch <<
-                "def #{temp_method_name}(value)" <<
-                "  _write_attribute(#{attr_name_expr}, value)" <<
-                "end"
-            end
+            owner <<
+              "def #{temp_method_name}(value)" <<
+              "  _write_attribute(#{attr_name_expr}, value)" <<
+              "end"
           end
         end
 

data/lib/active_model/callbacks.rb

@@ -32,7 +32,7 @@ module ActiveModel
   #     end
   #   end
   #
-  # Then in your class, you can use the +before_create+, +after_create+, and
+  # Then in your class, you can use the +before_create+, +after_create+ and
   # +around_create+ methods, just as you would in an Active Record model.
   #
   #   before_create :action_before_create
@@ -63,7 +63,7 @@ module ActiveModel
   # NOTE: Calling the same callback multiple times will overwrite previous callback definitions.
   #
   module Callbacks
-    def self.extended(base) # :nodoc:
+    def self.extended(base) #:nodoc:
       base.class_eval do
         include ActiveSupport::Callbacks
       end
@@ -84,7 +84,7 @@ module ActiveModel
     #   define_model_callbacks :update,  only: :before
     #   define_model_callbacks :destroy, only: :around
     #
-    # Would create +after_create+, +before_update+, and +around_destroy+ methods
+    # Would create +after_create+, +before_update+ and +around_destroy+ methods
     # only.
     #
     # You can pass in a class to before_<type>, after_<type> and around_<type>,

data/lib/active_model/conversion.rb

@@ -96,10 +96,10 @@ module ActiveModel
       self.class._to_partial_path
     end
 
-    module ClassMethods # :nodoc:
+    module ClassMethods #:nodoc:
       # Provide a class level cache for #to_partial_path. This is an
       # internal method and should not be accessed directly.
-      def _to_partial_path # :nodoc:
+      def _to_partial_path #:nodoc:
         @_to_partial_path ||= begin
           element = ActiveSupport::Inflector.underscore(ActiveSupport::Inflector.demodulize(name))
           collection = ActiveSupport::Inflector.tableize(name)

data/lib/active_model/dirty.rb

@@ -123,11 +123,10 @@ module ActiveModel
     include ActiveModel::AttributeMethods
 
     included do
-      attribute_method_suffix "_previously_changed?", "_changed?", parameters: "**options"
-      attribute_method_suffix "_change", "_will_change!", "_was", parameters: false
-      attribute_method_suffix "_previous_change", "_previously_was", parameters: false
-      attribute_method_affix prefix: "restore_", suffix: "!", parameters: false
-      attribute_method_affix prefix: "clear_", suffix: "_change", parameters: false
+      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:

data/lib/active_model/error.rb

@@ -159,7 +159,7 @@ module ActiveModel
       self.class.full_message(attribute, message, @base)
     end
 
-    # See if error matches provided +attribute+, +type+, and +options+.
+    # See if error matches provided +attribute+, +type+ and +options+.
     #
     # Omitted params are not checked for a match.
     def match?(attribute, type = nil, **options)
@@ -176,7 +176,7 @@ module ActiveModel
       true
     end
 
-    # See if error matches provided +attribute+, +type+, and +options+ exactly.
+    # 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.

data/lib/active_model/errors.rb

@@ -48,9 +48,9 @@ module ActiveModel
   #
   # The last three methods are required in your object for +Errors+ to be
   # able to generate error messages correctly and also handle multiple
-  # languages. Of course, if you extend your object with ActiveModel::Translation
+  # languages. Of course, if you extend your object with <tt>ActiveModel::Translation</tt>
   # you will not need to implement the last two. Likewise, using
-  # ActiveModel::Validations will handle the validation related methods
+  # <tt>ActiveModel::Validations</tt> will handle the validation related methods
   # for you.
   #
   # The above allows you to do:
@@ -63,19 +63,12 @@ module ActiveModel
     include Enumerable
 
     extend Forwardable
+    def_delegators :@errors, :size, :clear, :blank?, :empty?, :uniq!, :any?
+    # TODO: forward all enumerable methods after `each` deprecation is removed.
+    def_delegators :@errors, :count
 
-    # :method: each
-    #
-    # :call-seq: each(&block)
-    #
-    # Iterates through each error object.
-    #
-    #   person.errors.add(:name, :too_short, count: 2)
-    #   person.errors.each do |error|
-    #     # Will yield <#ActiveModel::Error attribute=name, type=too_short,
-    #                                       options={:count=>3}>
-    #   end
-    def_delegators :@errors, :each, :clear, :empty?, :size, :uniq!
+    LEGACY_ATTRIBUTES = [:messages, :details].freeze
+    private_constant :LEGACY_ATTRIBUTES
 
     # The actual array of +Error+ objects
     # This method is aliased to <tt>objects</tt>.
@@ -102,14 +95,11 @@ module ActiveModel
     # Copies the errors from <tt>other</tt>.
     # For copying errors but keep <tt>@base</tt> as is.
     #
-    # ==== Parameters
-    #
-    # * +other+ - The ActiveModel::Errors instance.
+    # other - The ActiveModel::Errors instance.
     #
-    # ==== Examples
+    # Examples
     #
     #   person.errors.copy!(other)
-    #
     def copy!(other) # :nodoc:
       @errors = other.errors.deep_dup
       @errors.each { |error|
@@ -117,15 +107,14 @@ module ActiveModel
       }
     end
 
-    # Imports one error.
+    # Imports one error
     # Imported errors are wrapped as a NestedError,
     # providing access to original error object.
     # If attribute or type needs to be overridden, use +override_options+.
     #
-    # ==== Options
-    #
-    # * +:attribute+ - Override the attribute the error belongs to.
-    # * +:type+ - Override type of the error.
+    # override_options - Hash
+    # @option override_options [Symbol] :attribute Override the attribute the error belongs to
+    # @option override_options [Symbol] :type Override type of the error.
     def import(error, override_options = {})
       [:attribute, :type].each do |key|
         if override_options.key?(key)
@@ -136,25 +125,39 @@ module ActiveModel
     end
 
     # Merges the errors from <tt>other</tt>,
-    # each Error wrapped as NestedError.
-    #
-    # ==== Parameters
+    # each <tt>Error</tt> wrapped as <tt>NestedError</tt>.
     #
-    # * +other+ - The ActiveModel::Errors instance.
+    # other - The ActiveModel::Errors instance.
     #
-    # ==== Examples
+    # Examples
     #
     #   person.errors.merge!(other)
-    #
     def merge!(other)
-      return errors if equal?(other)
-
       other.errors.each { |error|
         import(error)
       }
     end
 
-    # Search for errors matching +attribute+, +type+, or +options+.
+    # Removes all errors except the given keys. Returns a hash containing the removed errors.
+    #
+    #   person.errors.keys                  # => [:name, :age, :gender, :city]
+    #   person.errors.slice!(:age, :gender) # => { :name=>["cannot be nil"], :city=>["cannot be nil"] }
+    #   person.errors.keys                  # => [:age, :gender]
+    def slice!(*keys)
+      deprecation_removal_warning(:slice!)
+
+      keys = keys.map(&:to_sym)
+
+      results = messages.dup.slice!(*keys)
+
+      @errors.keep_if do |error|
+        keys.include?(error.attribute)
+      end
+
+      results
+    end
+
+    # Search for errors matching +attribute+, +type+ or +options+.
     #
     # Only supplied params will be matched.
     #
@@ -202,7 +205,76 @@ module ActiveModel
     #   person.errors[:name]  # => ["cannot be nil"]
     #   person.errors['name'] # => ["cannot be nil"]
     def [](attribute)
-      messages_for(attribute)
+      DeprecationHandlingMessageArray.new(messages_for(attribute), self, attribute)
+    end
+
+    # Iterates through each error object.
+    #
+    #   person.errors.add(:name, :too_short, count: 2)
+    #   person.errors.each do |error|
+    #     # Will yield <#ActiveModel::Error attribute=name, type=too_short,
+    #                                       options={:count=>3}>
+    #   end
+    #
+    # To be backward compatible with past deprecated hash-like behavior,
+    # when block accepts two parameters instead of one, it
+    # iterates through each error key, value pair in the error messages hash.
+    # Yields the attribute and the error for that attribute. If the attribute
+    # has more than one error message, yields once for each error message.
+    #
+    #   person.errors.add(:name, :blank, message: "can't be blank")
+    #   person.errors.each do |attribute, message|
+    #     # Will yield :name and "can't be blank"
+    #   end
+    #
+    #   person.errors.add(:name, :not_specified, message: "must be specified")
+    #   person.errors.each do |attribute, message|
+    #     # Will yield :name and "can't be blank"
+    #     # then yield :name and "must be specified"
+    #   end
+    def each(&block)
+      if block.arity <= 1
+        @errors.each(&block)
+      else
+        ActiveSupport::Deprecation.warn(<<~MSG)
+          Enumerating ActiveModel::Errors as a hash has been deprecated.
+          In Rails 6.1, `errors` is an array of Error objects,
+          therefore it should be accessed by a block with a single block
+          parameter like this:
+
+          person.errors.each do |error|
+            attribute = error.attribute
+            message = error.message
+          end
+
+          You are passing a block expecting two parameters,
+          so the old hash behavior is simulated. As this is deprecated,
+          this will result in an ArgumentError in Rails 7.0.
+        MSG
+        @errors.
+          sort { |a, b| a.attribute <=> b.attribute }.
+          each { |error| yield error.attribute, error.message }
+      end
+    end
+
+    # Returns all message values.
+    #
+    #   person.errors.messages # => {:name=>["cannot be nil", "must be specified"]}
+    #   person.errors.values   # => [["cannot be nil", "must be specified"]]
+    def values
+      deprecation_removal_warning(:values, "errors.map { |error| error.message }")
+      @errors.map(&:message).freeze
+    end
+
+    # Returns all message keys.
+    #
+    #   person.errors.messages # => {:name=>["cannot be nil", "must be specified"]}
+    #   person.errors.keys     # => [:name]
+    def keys
+      deprecation_removal_warning(:keys, "errors.attribute_names")
+      keys = @errors.map(&:attribute)
+      keys.uniq!
+      keys.freeze
     end
 
     # Returns all error attribute names
@@ -213,6 +285,22 @@ module ActiveModel
       @errors.map(&:attribute).uniq.freeze
     end
 
+    # Returns an xml formatted representation of the Errors hash.
+    #
+    #   person.errors.add(:name, :blank, message: "can't be blank")
+    #   person.errors.add(:name, :not_specified, message: "must be specified")
+    #   person.errors.to_xml
+    #   # =>
+    #   #  <?xml version=\"1.0\" encoding=\"UTF-8\"?>
+    #   #  <errors>
+    #   #    <error>name can't be blank</error>
+    #   #    <error>name must be specified</error>
+    #   #  </errors>
+    def to_xml(options = {})
+      deprecation_removal_warning(:to_xml)
+      to_a.to_xml({ root: "errors", skip_types: true }.merge!(options))
+    end
+
     # Returns a Hash that can be used as the JSON representation for this
     # object. You can pass the <tt>:full_messages</tt> option. This determines
     # if the json object should contain full messages or not (false by default).
@@ -235,26 +323,33 @@ module ActiveModel
       end
     end
 
-    undef :to_h
+    def to_h
+      ActiveSupport::Deprecation.warn(<<~EOM)
+        ActiveModel::Errors#to_h is deprecated and will be removed in Rails 7.0.
+        Please use `ActiveModel::Errors.to_hash` instead. The values in the hash
+        returned by `ActiveModel::Errors.to_hash` is an array of error messages.
+      EOM
 
-    EMPTY_ARRAY = [].freeze # :nodoc:
+      to_hash.transform_values { |values| values.last }
+    end
 
     # Returns a Hash of attributes with an array of their error messages.
+    #
+    # Updating this hash would still update errors state for backward
+    # compatibility, but this behavior is deprecated.
     def messages
-      hash = to_hash
-      hash.default = EMPTY_ARRAY
-      hash.freeze
-      hash
+      DeprecationHandlingMessageHash.new(self)
     end
 
     # Returns a Hash of attributes with an array of their error details.
+    #
+    # Updating this hash would still update errors state for backward
+    # compatibility, but this behavior is deprecated.
     def details
       hash = group_by_attribute.transform_values do |errors|
         errors.map(&:details)
       end
-      hash.default = EMPTY_ARRAY
-      hash.freeze
-      hash
+      DeprecationHandlingDetailsHash.new(hash)
     end
 
     # Returns a Hash of attributes with an array of their Error objects.
@@ -283,14 +378,6 @@ module ActiveModel
     # If +type+ is a symbol, it will be translated using the appropriate
     # scope (see +generate_message+).
     #
-    #   person.errors.add(:name, :blank)
-    #   person.errors.messages
-    #   # => {:name=>["can't be blank"]}
-    #
-    #   person.errors.add(:name, :too_long, { count: 25 })
-    #   person.errors.messages
-    #   # => ["is too long (maximum is 25 characters)"]
-    #
     # If +type+ is a proc, it will be called, allowing for things like
     # <tt>Time.now</tt> to be used within an error.
     #
@@ -434,7 +521,7 @@ module ActiveModel
     # if it's not there, it's looked up in <tt>activemodel.errors.models.MODEL.MESSAGE</tt> and if
     # that is not there also, it returns the translation of the default message
     # (e.g. <tt>activemodel.errors.messages.MESSAGE</tt>). The translated model
-    # name, translated attribute name, and the value are available for
+    # name, translated attribute name and the value are available for
     # interpolation.
     #
     # When using inheritance in your models, it will check all the inherited
@@ -455,10 +542,25 @@ module ActiveModel
       Error.generate_message(attribute, type, @base, options)
     end
 
-    def inspect # :nodoc:
-      inspection = @errors.inspect
+    def marshal_load(array) # :nodoc:
+      # Rails 5
+      @errors = []
+      @base = array[0]
+      add_from_legacy_details_hash(array[2])
+    end
+
+    def init_with(coder) # :nodoc:
+      data = coder.map
+
+      data.each { |k, v|
+        next if LEGACY_ATTRIBUTES.include?(k.to_sym)
+        instance_variable_set(:"@#{k}", v)
+      }
+
+      @errors ||= []
 
-      "#<#{self.class.name} #{inspection}>"
+      # Legacy support Rails 5.x details hash
+      add_from_legacy_details_hash(data["details"]) if data.key?("details")
     end
 
     private
@@ -470,6 +572,97 @@ module ActiveModel
 
         [attribute.to_sym, type, options]
       end
+
+      def add_from_legacy_details_hash(details)
+        details.each { |attribute, errors|
+          errors.each { |error|
+            type = error.delete(:error)
+            add(attribute, type, **error)
+          }
+        }
+      end
+
+      def deprecation_removal_warning(method_name, alternative_message = nil)
+        message = +"ActiveModel::Errors##{method_name} is deprecated and will be removed in Rails 7.0."
+        if alternative_message
+          message << "\n\nTo achieve the same use:\n\n  "
+          message << alternative_message
+        end
+        ActiveSupport::Deprecation.warn(message)
+      end
+
+      def deprecation_rename_warning(old_method_name, new_method_name)
+        ActiveSupport::Deprecation.warn("ActiveModel::Errors##{old_method_name} is deprecated. Please call ##{new_method_name} instead.")
+      end
+  end
+
+  class DeprecationHandlingMessageHash < SimpleDelegator
+    def initialize(errors)
+      @errors = errors
+      super(prepare_content)
+    end
+
+    def []=(attribute, value)
+      ActiveSupport::Deprecation.warn("Calling `[]=` to an ActiveModel::Errors is deprecated. Please call `ActiveModel::Errors#add` instead.")
+
+      @errors.delete(attribute)
+      Array(value).each do |message|
+        @errors.add(attribute, message)
+      end
+
+      __setobj__ prepare_content
+    end
+
+    def delete(attribute)
+      ActiveSupport::Deprecation.warn("Calling `delete` to an ActiveModel::Errors messages hash is deprecated. Please call `ActiveModel::Errors#delete` instead.")
+
+      @errors.delete(attribute)
+    end
+
+    private
+      def prepare_content
+        content = @errors.to_hash
+        content.each do |attribute, value|
+          content[attribute] = DeprecationHandlingMessageArray.new(value, @errors, attribute)
+        end
+        content.default_proc = proc do |hash, attribute|
+          hash = hash.dup
+          hash[attribute] = DeprecationHandlingMessageArray.new([], @errors, attribute)
+          __setobj__ hash.freeze
+          hash[attribute]
+        end
+        content.freeze
+      end
+  end
+
+  class DeprecationHandlingMessageArray < SimpleDelegator
+    def initialize(content, errors, attribute)
+      @errors = errors
+      @attribute = attribute
+      super(content.freeze)
+    end
+
+    def <<(message)
+      ActiveSupport::Deprecation.warn("Calling `<<` to an ActiveModel::Errors message array in order to add an error is deprecated. Please call `ActiveModel::Errors#add` instead.")
+
+      @errors.add(@attribute, message)
+      __setobj__ @errors.messages_for(@attribute)
+      self
+    end
+
+    def clear
+      ActiveSupport::Deprecation.warn("Calling `clear` to an ActiveModel::Errors message array in order to delete all errors is deprecated. Please call `ActiveModel::Errors#delete` instead.")
+
+      @errors.delete(@attribute)
+    end
+  end
+
+  class DeprecationHandlingDetailsHash < SimpleDelegator
+    def initialize(details)
+      details.default = []
+      details.freeze
+      super(details)
+    end
   end
 
   # Raised when a validation cannot be corrected by end users and are considered

data/lib/active_model/gem_version.rb

@@ -1,16 +1,16 @@
 # frozen_string_literal: true
 
 module ActiveModel
-  # Returns the currently loaded version of \Active \Model as a <tt>Gem::Version</tt>.
+  # Returns the version of the currently loaded \Active \Model as a <tt>Gem::Version</tt>
   def self.gem_version
     Gem::Version.new VERSION::STRING
   end
 
   module VERSION
-    MAJOR = 7
-    MINOR = 0
-    TINY  = 4
-    PRE   = nil
+    MAJOR = 6
+    MINOR = 1
+    TINY  = 7
+    PRE   = "1"
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
   end

data/lib/active_model/locale/en.yml

@@ -32,6 +32,5 @@ en:
       less_than: "must be less than %{count}"
       less_than_or_equal_to: "must be less than or equal to %{count}"
       other_than: "must be other than %{count}"
-      in: "must be in %{count}"
       odd: "must be odd"
       even: "must be even"

data/lib/active_model/model.rb

@@ -3,10 +3,11 @@
 module ActiveModel
   # == Active \Model \Basic \Model
   #
-  # Allows implementing models similar to ActiveRecord::Base.
-  # Includes ActiveModel::API for the required interface for an
-  # object to interact with Action Pack and Action View, but can be
-  # extended with other functionalities.
+  # Includes the required interface for an object to interact with
+  # Action Pack and Action View, using different Active Model modules.
+  # It includes model name introspections, conversions, translations and
+  # validations. Besides that, it allows you to initialize the object with a
+  # hash of attributes, pretty much like Active Record does.
   #
   # A minimal implementation could be:
   #
@@ -19,7 +20,23 @@ module ActiveModel
   #   person.name # => "bob"
   #   person.age  # => "18"
   #
-  # If for some reason you need to run code on <tt>initialize</tt>, make
+  # Note that, by default, <tt>ActiveModel::Model</tt> implements <tt>persisted?</tt>
+  # to return +false+, which is the most common case. You may want to override
+  # it in your class to simulate a different scenario:
+  #
+  #   class Person
+  #     include ActiveModel::Model
+  #     attr_accessor :id, :name
+  #
+  #     def persisted?
+  #       self.id == 1
+  #     end
+  #   end
+  #
+  #   person = Person.new(id: 1, name: 'bob')
+  #   person.persisted? # => true
+  #
+  # Also, if for some reason you need to run code on <tt>initialize</tt>, make
   # sure you call +super+ if you want the attributes hash initialization to
   # happen.
   #
@@ -41,6 +58,42 @@ module ActiveModel
   # (see below).
   module Model
     extend ActiveSupport::Concern
-    include ActiveModel::API
+    include ActiveModel::AttributeAssignment
+    include ActiveModel::Validations
+    include ActiveModel::Conversion
+
+    included do
+      extend ActiveModel::Naming
+      extend ActiveModel::Translation
+    end
+
+    # Initializes a new model with the given +params+.
+    #
+    #   class Person
+    #     include ActiveModel::Model
+    #     attr_accessor :name, :age
+    #   end
+    #
+    #   person = Person.new(name: 'bob', age: '18')
+    #   person.name # => "bob"
+    #   person.age  # => "18"
+    def initialize(attributes = {})
+      assign_attributes(attributes) if attributes
+
+      super()
+    end
+
+    # Indicates if the model is persisted. Default is +false+.
+    #
+    #  class Person
+    #    include ActiveModel::Model
+    #    attr_accessor :id, :name
+    #  end
+    #
+    #  person = Person.new(id: 1, name: 'bob')
+    #  person.persisted? # => false
+    def persisted?
+      false
+    end
   end
 end