activemodel 7.0.8.7 → 7.2.2.1

data/lib/active_model/attributes.rb

@@ -1,33 +1,67 @@
 # frozen_string_literal: true
 
-require "active_model/attribute_set"
-require "active_model/attribute/user_provided_default"
-
 module ActiveModel
-  module Attributes # :nodoc:
+  # = Active \Model \Attributes
+  #
+  # The Attributes module allows models to define attributes beyond simple Ruby
+  # readers and writers. Similar to Active Record attributes, which are
+  # typically inferred from the database schema, Active Model Attributes are
+  # aware of data types, can have default values, and can handle casting and
+  # serialization.
+  #
+  # To use Attributes, include the module in your model class and define your
+  # attributes using the +attribute+ macro. It accepts a name, a type, a default
+  # value, and any other options supported by the attribute type.
+  #
+  # ==== Examples
+  #
+  #   class Person
+  #     include ActiveModel::Attributes
+  #
+  #     attribute :name, :string
+  #     attribute :active, :boolean, default: true
+  #   end
+  #
+  #   person = Person.new
+  #   person.name = "Volmer"
+  #
+  #   person.name # => "Volmer"
+  #   person.active # => true
+  module Attributes
     extend ActiveSupport::Concern
+    include ActiveModel::AttributeRegistration
     include ActiveModel::AttributeMethods
 
     included do
       attribute_method_suffix "=", parameters: "value"
-      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)
-        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)
+      ##
+      # :call-seq: attribute(name, cast_type = nil, default: nil, **options)
+      #
+      # Defines a model attribute. In addition to the attribute name, a cast
+      # type and default value may be specified, as well as any options
+      # supported by the given cast type.
+      #
+      #   class Person
+      #     include ActiveModel::Attributes
+      #
+      #     attribute :name, :string
+      #     attribute :active, :boolean, default: true
+      #   end
+      #
+      #   person = Person.new
+      #   person.name = "Volmer"
+      #
+      #   person.name   # => "Volmer"
+      #   person.active # => true
+      def attribute(name, ...)
+        super
         define_attribute_method(name)
       end
 
-      # Returns an array of attribute names as strings
+      # Returns an array of attribute names as strings.
       #
       #   class Person
       #     include ActiveModel::Attributes
@@ -36,18 +70,30 @@ module ActiveModel
       #     attribute :age, :integer
       #   end
       #
-      #   Person.attribute_names
-      #   # => ["name", "age"]
+      #   Person.attribute_names # => ["name", "age"]
       def attribute_names
         attribute_types.keys
       end
 
+      ##
+      # :method: type_for_attribute
+      # :call-seq: type_for_attribute(attribute_name, &block)
+      #
+      # Returns the type of the specified attribute after applying any
+      # modifiers. This method is the only valid source of information for
+      # anything related to the types of a model's attributes. The return value
+      # of this method will implement the interface described by
+      # ActiveModel::Type::Value (though the object itself may not subclass it).
+      #--
+      # Implemented by ActiveModel::AttributeRegistration::ClassMethods#type_for_attribute.
+
+      ##
       private
-        def define_method_attribute=(name, owner:)
+        def define_method_attribute=(canonical_name, owner:, as: canonical_name)
           ActiveModel::AttributeMethods::AttrNames.define_attribute_accessor_method(
-            owner, name, writer: true,
+            owner, canonical_name, writer: true,
           ) do |temp_method_name, attr_name_expr|
-            owner.define_cached_method("#{name}=", as: temp_method_name, namespace: :active_model) do |batch|
+            owner.define_cached_method(temp_method_name, as: "#{as}=", namespace: :active_model) do |batch|
               batch <<
                 "def #{temp_method_name}(value)" <<
                 "  _write_attribute(#{attr_name_expr}, value)" <<
@@ -55,27 +101,9 @@ module ActiveModel
             end
           end
         end
-
-        NO_DEFAULT_PROVIDED = Object.new # :nodoc:
-        private_constant :NO_DEFAULT_PROVIDED
-
-        def define_default_attribute(name, value, type)
-          self._default_attributes = _default_attributes.deep_dup
-          if value == NO_DEFAULT_PROVIDED
-            default_attribute = _default_attributes[name].with_type(type)
-          else
-            default_attribute = Attribute::UserProvidedDefault.new(
-              name,
-              value,
-              type,
-              _default_attributes.fetch(name.to_s) { nil },
-            )
-          end
-          _default_attributes[name] = default_attribute
-        end
     end
 
-    def initialize(*)
+    def initialize(*) # :nodoc:
       @attributes = self.class._default_attributes.deep_dup
       super
     end
@@ -85,7 +113,8 @@ module ActiveModel
       super
     end
 
-    # Returns a hash of all the attributes with their names as keys and the values of the attributes as values.
+    # Returns a hash of all the attributes with their names as keys and the
+    # values of the attributes as values.
     #
     #   class Person
     #     include ActiveModel::Attributes
@@ -94,14 +123,16 @@ module ActiveModel
     #     attribute :age, :integer
     #   end
     #
-    #   person = Person.new(name: 'Francesco', age: 22)
-    #   person.attributes
-    #   # => {"name"=>"Francesco", "age"=>22}
+    #   person = Person.new
+    #   person.name = "Francesco"
+    #   person.age = 22
+    #
+    #   person.attributes # => { "name" => "Francesco", "age" => 22}
     def attributes
       @attributes.to_hash
     end
 
-    # Returns an array of attribute names as strings
+    # Returns an array of attribute names as strings.
     #
     #   class Person
     #     include ActiveModel::Attributes
@@ -111,13 +142,12 @@ module ActiveModel
     #   end
     #
     #   person = Person.new
-    #   person.attribute_names
-    #   # => ["name", "age"]
+    #   person.attribute_names # => ["name", "age"]
     def attribute_names
       @attributes.keys
     end
 
-    def freeze
+    def freeze # :nodoc:
       @attributes = @attributes.clone.freeze unless frozen?
       super
     end

data/lib/active_model/callbacks.rb

@@ -4,14 +4,14 @@ require "active_support/core_ext/array/extract_options"
 require "active_support/core_ext/hash/keys"
 
 module ActiveModel
-  # == Active \Model \Callbacks
+  # = Active \Model \Callbacks
   #
   # Provides an interface for any class to have Active Record like callbacks.
   #
   # Like the Active Record methods, the callback chain is aborted as soon as
   # one of the methods throws +:abort+.
   #
-  # First, extend ActiveModel::Callbacks from the class you are creating:
+  # First, extend +ActiveModel::Callbacks+ from the class you are creating:
   #
   #   class MyModel
   #     extend ActiveModel::Callbacks
@@ -60,7 +60,7 @@ module ActiveModel
   # Would only create the +after_create+ and +before_create+ callback methods in
   # your class.
   #
-  # NOTE: Calling the same callback multiple times will overwrite previous callback definitions.
+  # NOTE: Defining the same callback multiple times will overwrite previous callback definitions.
   #
   module Callbacks
     def self.extended(base) # :nodoc:
@@ -69,7 +69,7 @@ module ActiveModel
       end
     end
 
-    # define_model_callbacks accepts the same options +define_callbacks+ does,
+    # +define_model_callbacks+ accepts the same options +define_callbacks+ does,
     # in case you want to overwrite a default. Besides that, it also accepts an
     # <tt>:only</tt> option, where you can choose if you want all types (before,
     # around or after) or just some.
@@ -77,7 +77,7 @@ module ActiveModel
     #   define_model_callbacks :initialize, only: :after
     #
     # Note, the <tt>only: <type></tt> hash will apply to all callbacks defined
-    # on that method call. To get around this you can call the define_model_callbacks
+    # on that method call. To get around this you can call the +define_model_callbacks+
     # method as many times as you need.
     #
     #   define_model_callbacks :create,  only: :after
@@ -104,7 +104,7 @@ module ActiveModel
     #     end
     #   end
     #
-    # NOTE: +method_name+ passed to define_model_callbacks must not end with
+    # NOTE: +method_name+ passed to +define_model_callbacks+ must not end with
     # <tt>!</tt>, <tt>?</tt> or <tt>=</tt>.
     def define_model_callbacks(*callbacks)
       options = callbacks.extract_options!

data/lib/active_model/conversion.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module ActiveModel
-  # == Active \Model \Conversion
+  # = Active \Model \Conversion
   #
   # Handles default conversions: to_model, to_key, to_param, and to_partial_path.
   #
@@ -24,6 +24,14 @@ module ActiveModel
   module Conversion
     extend ActiveSupport::Concern
 
+    included do
+      ##
+      # :singleton-method:
+      #
+      # Accepts a string that will be used as a delimiter of object's key values in the `to_param` method.
+      class_attribute :param_delimiter, instance_reader: false, default: "-"
+    end
+
     # If your object is already designed to implement all of the \Active \Model
     # you can use the default <tt>:to_model</tt> implementation, which simply
     # returns +self+.
@@ -58,7 +66,7 @@ module ActiveModel
     #   person.to_key # => [1]
     def to_key
       key = respond_to?(:id) && id
-      key ? [key] : nil
+      key ? Array(key) : nil
     end
 
     # Returns a +string+ representing the object's key suitable for use in URLs,
@@ -80,7 +88,7 @@ module ActiveModel
     #   person = Person.new(1)
     #   person.to_param # => "1"
     def to_param
-      (persisted? && key = to_key) ? key.join("-") : nil
+      (persisted? && (key = to_key) && key.all?) ? key.join(self.class.param_delimiter) : nil
     end
 
     # Returns a +string+ identifying the path associated with the object.
@@ -100,7 +108,9 @@ module ActiveModel
       # 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:
-        @_to_partial_path ||= begin
+        @_to_partial_path ||= if respond_to?(:model_name)
+          "#{model_name.collection}/#{model_name.element}"
+        else
           element = ActiveSupport::Inflector.underscore(ActiveSupport::Inflector.demodulize(name))
           collection = ActiveSupport::Inflector.tableize(name)
           "#{collection}/#{element}"

data/lib/active_model/deprecator.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module ActiveModel
+  def self.deprecator # :nodoc:
+    @deprecator ||= ActiveSupport::Deprecation.new
+  end
+end

data/lib/active_model/dirty.rb

@@ -3,7 +3,7 @@
 require "active_model/attribute_mutation_tracker"
 
 module ActiveModel
-  # == Active \Model \Dirty
+  # = Active \Model \Dirty
   #
   # Provides a way to track changes in your object in the same way as
   # Active Record does.
@@ -13,8 +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
-  #   attribute.
+  # * Call <tt>*_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
   #   information.
@@ -109,20 +108,136 @@ module ActiveModel
   #   person.changes # => {"name" => ["Bill", "Bob"]}
   #
   # If an attribute is modified in-place then make use of
-  # <tt>[attribute_name]_will_change!</tt> to mark that the attribute is changing.
+  # {*_will_change!}[rdoc-label:method-i-2A_will_change-21] 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 <tt>[attribute_name]_will_change!</tt> on Active Record models.
+  # not need to call <tt>*_will_change!</tt> on Active Record models.
   #
   #   person.name_will_change!
   #   person.name_change # => ["Bill", "Bill"]
   #   person.name << 'y'
   #   person.name_change # => ["Bill", "Billy"]
+  #
+  # Methods can be invoked as +name_changed?+ or by passing an argument to the
+  # generic method <tt>attribute_changed?("name")</tt>.
   module Dirty
     extend ActiveSupport::Concern
     include ActiveModel::AttributeMethods
 
     included do
+      ##
+      # :method: *_previously_changed?
+      #
+      # :call-seq: *_previously_changed?(**options)
+      #
+      # This method is generated for each attribute.
+      #
+      # Returns true if the attribute previously had unsaved changes.
+      #
+      #   person = Person.new
+      #   person.name = 'Britanny'
+      #   person.save
+      #   person.name_previously_changed? # => true
+      #   person.name_previously_changed?(from: nil, to: 'Britanny') # => true
+
+      ##
+      # :method: *_changed?
+      #
+      # This method is generated for each attribute.
+      #
+      # Returns true if the attribute has unsaved changes.
+      #
+      #   person = Person.new
+      #   person.name = 'Andrew'
+      #   person.name_changed? # => true
+
+      ##
+      # :method: *_change
+      #
+      # This method is generated for each attribute.
+      #
+      # Returns the old and the new value of the attribute.
+      #
+      #   person = Person.new
+      #   person.name = 'Nick'
+      #   person.name_change # => [nil, 'Nick']
+
+      ##
+      # :method: *_will_change!
+      #
+      # This method is generated for each attribute.
+      #
+      # If an attribute is modified in-place then make use of
+      # <tt>*_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 <tt>*_will_change!</tt> on Active Record
+      # models.
+      #
+      #   person = Person.new('Sandy')
+      #   person.name_will_change!
+      #   person.name_change # => ['Sandy', 'Sandy']
+
+      ##
+      # :method: *_was
+      #
+      # This method is generated for each attribute.
+      #
+      # Returns the old value of the attribute.
+      #
+      #   person = Person.new(name: 'Steph')
+      #   person.name = 'Stephanie'
+      #   person.name_was # => 'Steph'
+
+      ##
+      # :method: *_previous_change
+      #
+      # This method is generated for each attribute.
+      #
+      # Returns the old and the new value of the attribute before the last save.
+      #
+      #   person = Person.new
+      #   person.name = 'Emmanuel'
+      #   person.save
+      #   person.name_previous_change # => [nil, 'Emmanuel']
+
+      ##
+      # :method: *_previously_was
+      #
+      # This method is generated for each attribute.
+      #
+      # Returns the old value of the attribute before the last save.
+      #
+      #   person = Person.new
+      #   person.name = 'Sage'
+      #   person.save
+      #   person.name_previously_was  # => nil
+
+      ##
+      # :method: restore_*!
+      #
+      # This method is generated for each attribute.
+      #
+      # Restores the attribute to the old value.
+      #
+      #   person = Person.new
+      #   person.name = 'Amanda'
+      #   person.restore_name!
+      #   person.name # => nil
+
+      ##
+      # :method: clear_*_change
+      #
+      # This method is generated for each attribute.
+      #
+      # Clears all dirty data of the attribute: current changes and previous changes.
+      #
+      #   person = Person.new(name: 'Chris')
+      #   person.name = 'Jason'
+      #   person.name_change # => ['Chris', 'Jason']
+      #   person.clear_name_change
+      #   person.name_change # => nil
+
       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
@@ -174,23 +289,23 @@ module ActiveModel
       mutations_from_database.changed_attribute_names
     end
 
-    # Dispatch target for <tt>*_changed?</tt> attribute methods.
-    def attribute_changed?(attr_name, **options) # :nodoc:
+    # Dispatch target for {*_changed?}[rdoc-label:method-i-2A_changed-3F] attribute methods.
+    def attribute_changed?(attr_name, **options)
       mutations_from_database.changed?(attr_name.to_s, **options)
     end
 
-    # Dispatch target for <tt>*_was</tt> attribute methods.
-    def attribute_was(attr_name) # :nodoc:
+    # Dispatch target for {*_was}[rdoc-label:method-i-2A_was] attribute methods.
+    def attribute_was(attr_name)
       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:
+    # Dispatch target for {*_previously_changed?}[rdoc-label:method-i-2A_previously_changed-3F] attribute methods.
+    def attribute_previously_changed?(attr_name, **options)
       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:
+    # Dispatch target for {*_previously_was}[rdoc-label:method-i-2A_previously_was] attribute methods.
+    def attribute_previously_was(attr_name)
       mutations_before_last_save.original_value(attr_name.to_s)
     end
 
@@ -247,6 +362,12 @@ module ActiveModel
     end
 
     private
+      def init_internals
+        super
+        @mutations_before_last_save = nil
+        @mutations_from_database = nil
+      end
+
       def clear_attribute_change(attr_name)
         mutations_from_database.forget_change(attr_name.to_s)
       end

data/lib/active_model/error.rb

@@ -3,7 +3,7 @@
 require "active_support/core_ext/class/attribute"
 
 module ActiveModel
-  # == Active \Model \Error
+  # = Active \Model \Error
   #
   # Represents one single error
   class Error
@@ -121,9 +121,10 @@ module ActiveModel
     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+
+    # The raw value provided as the second parameter when calling
+    # <tt>errors#add</tt>
     attr_reader :raw_type
-    # The options provided when calling +errors#add+
+    # The options provided when calling <tt>errors#add</tt>
     attr_reader :options
 
     # Returns the error message.

data/lib/active_model/errors.rb

@@ -3,13 +3,12 @@
 require "active_support/core_ext/array/conversions"
 require "active_support/core_ext/string/inflections"
 require "active_support/core_ext/object/deep_dup"
-require "active_support/core_ext/string/filters"
 require "active_model/error"
 require "active_model/nested_error"
 require "forwardable"
 
 module ActiveModel
-  # == Active \Model \Errors
+  # = Active \Model \Errors
   #
   # Provides error related functionalities you can include in your object
   # for handling error messages and interacting with Action View helpers.
@@ -64,6 +63,7 @@ module ActiveModel
 
     extend Forwardable
 
+    ##
     # :method: each
     #
     # :call-seq: each(&block)
@@ -75,6 +75,31 @@ module ActiveModel
     #     # Will yield <#ActiveModel::Error attribute=name, type=too_short,
     #                                       options={:count=>3}>
     #   end
+
+    ##
+    # :method: clear
+    #
+    # :call-seq: clear
+    #
+    # Clears all errors. Clearing the errors does not, however, make the model
+    # valid. The next time the validations are run (for example, via
+    # ActiveRecord::Validations#valid?), the errors collection will be filled
+    # again if any validations fail.
+
+    ##
+    # :method: empty?
+    #
+    # :call-seq: empty?
+    #
+    # Returns true if there are no errors.
+
+    ##
+    # :method: size
+    #
+    # :call-seq: size
+    #
+    # Returns number of errors.
+
     def_delegators :@errors, :each, :clear, :empty?, :size, :uniq!
 
     # The actual array of +Error+ objects
@@ -215,7 +240,7 @@ module ActiveModel
 
     # 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).
+    # if the JSON object should contain full messages or not (false by default).
     #
     #   person.errors.as_json                      # => {:name=>["cannot be nil"]}
     #   person.errors.as_json(full_messages: true) # => {:name=>["name cannot be nil"]}
@@ -287,7 +312,7 @@ module ActiveModel
     #   person.errors.messages
     #   # => {:name=>["can't be blank"]}
     #
-    #   person.errors.add(:name, :too_long, { count: 25 })
+    #   person.errors.add(:name, :too_long, count: 25)
     #   person.errors.messages
     #   # => ["is too long (maximum is 25 characters)"]
     #
@@ -338,7 +363,7 @@ module ActiveModel
     # If the error requires options, then it returns +true+ with
     # the correct options, or +false+ with incorrect or missing options.
     #
-    #   person.errors.add :name, :too_long, { count: 25 }
+    #   person.errors.add :name, :too_long, count: 25
     #   person.errors.added? :name, :too_long, count: 25                     # => true
     #   person.errors.added? :name, "is too long (maximum is 25 characters)" # => true
     #   person.errors.added? :name, :too_long, count: 24                     # => false
@@ -360,7 +385,7 @@ module ActiveModel
     # present, or +false+ otherwise. +type+ is treated the same as for +add+.
     #
     #   person.errors.add :age
-    #   person.errors.add :name, :too_long, { count: 25 }
+    #   person.errors.add :name, :too_long, count: 25
     #   person.errors.of_kind? :age                                            # => true
     #   person.errors.of_kind? :name                                           # => false
     #   person.errors.of_kind? :name, :too_long                                # => true
@@ -472,6 +497,8 @@ module ActiveModel
       end
   end
 
+  # = Active \Model \StrictValidationFailed
+  #
   # Raised when a validation cannot be corrected by end users and are considered
   # exceptional.
   #
@@ -490,10 +517,14 @@ module ActiveModel
   class StrictValidationFailed < StandardError
   end
 
+  # = Active \Model \RangeError
+  #
   # Raised when attribute values are out of range.
   class RangeError < ::RangeError
   end
 
+  # = Active \Model \UnknownAttributeError
+  #
   # Raised when unknown attributes are supplied via mass assignment.
   #
   #   class Person

data/lib/active_model/forbidden_attributes_protection.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 module ActiveModel
+  # = Active \Model \ForbiddenAttributesError
+  #
   # Raised when forbidden attributes are used for mass assignment.
   #
   #   class Person < ActiveRecord::Base

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 currently loaded version of \Active \Model as a +Gem::Version+.
   def self.gem_version
     Gem::Version.new VERSION::STRING
   end
 
   module VERSION
     MAJOR = 7
-    MINOR = 0
-    TINY  = 8
-    PRE   = "7"
+    MINOR = 2
+    TINY  = 2
+    PRE   = "1"
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
   end

data/lib/active_model/lint.rb

@@ -5,7 +5,7 @@ module ActiveModel
     # == Active \Model \Lint \Tests
     #
     # You can test whether an object is compliant with the Active \Model API by
-    # including <tt>ActiveModel::Lint::Tests</tt> in your TestCase. It will
+    # including +ActiveModel::Lint::Tests+ in your TestCase. It will
     # include tests that tell you whether your object is fully compliant,
     # or if not, which aspects of the API are not implemented.
     #