activemodel 6.1.3.1 → 7.0.0.alpha1

data/lib/active_model/attribute_set/builder.rb

@@ -146,7 +146,7 @@ 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.
+          Marshalling load from legacy attributes format is deprecated and will be removed in Rails 7.0.
         MSG
         empty_hash = {}.freeze
         initialize(empty_hash, empty_hash, empty_hash, empty_hash, values)

data/lib/active_model/attribute_set.rb

@@ -25,6 +25,10 @@ module ActiveModel
       attributes.transform_values(&:value_before_type_cast)
     end
 
+    def values_for_database
+      attributes.transform_values(&:value_for_database)
+    end
+
     def to_hash
       keys.index_with { |name| self[name].value }
     end
@@ -54,7 +58,6 @@ module ActiveModel
 
     def write_cast_value(name, value)
       @attributes[name] = self[name].with_cast_value(value)
-      value
     end
 
     def freeze

data/lib/active_model/attributes.rb

@@ -4,25 +4,26 @@ 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 "="
+      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, type = Type::Value.new, **options)
+      def attribute(name, cast_type = nil, default: NO_DEFAULT_PROVIDED, **options)
         name = name.to_s
-        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)
+
+        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)
         define_attribute_method(name)
       end
 
@@ -46,10 +47,12 @@ module ActiveModel
           ActiveModel::AttributeMethods::AttrNames.define_attribute_accessor_method(
             owner, name, writer: true,
           ) do |temp_method_name, attr_name_expr|
-            owner <<
-              "def #{temp_method_name}(value)" <<
-              "  _write_attribute(#{attr_name_expr}, value)" <<
-              "end"
+            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
           end
         end
 

data/lib/active_model/callbacks.rb

@@ -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

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,10 +123,11 @@ module ActiveModel
     include ActiveModel::AttributeMethods
 
     included do
-      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"
+      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
     end
 
     def initialize_dup(other) # :nodoc:
@@ -139,6 +140,11 @@ module ActiveModel
       @mutations_from_database = nil
     end
 
+    def as_json(options = {}) # :nodoc:
+      options[:except] = [*options[:except], "mutations_from_database", "mutations_before_last_save"]
+      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

data/lib/active_model/errors.rb

@@ -249,7 +249,7 @@ module ActiveModel
 
           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 6.2.
+          this will result in an ArgumentError in Rails 7.0.
         MSG
         @errors.
           sort { |a, b| a.attribute <=> b.attribute }.
@@ -325,7 +325,7 @@ module ActiveModel
 
     def to_h
       ActiveSupport::Deprecation.warn(<<~EOM)
-        ActiveModel::Errors#to_h is deprecated and will be removed in Rails 6.2.
+        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
@@ -378,6 +378,14 @@ 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.
     #
@@ -563,6 +571,12 @@ module ActiveModel
       add_from_legacy_details_hash(data["details"]) if data.key?("details")
     end
 
+    def inspect # :nodoc:
+      inspection = @errors.inspect
+
+      "#<#{self.class.name} #{inspection}>"
+    end
+
     private
       def normalize_arguments(attribute, type, **options)
         # Evaluate proc first
@@ -583,7 +597,7 @@ module ActiveModel
       end
 
       def deprecation_removal_warning(method_name, alternative_message = nil)
-        message = +"ActiveModel::Errors##{method_name} is deprecated and will be removed in Rails 6.2."
+        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
@@ -596,7 +610,7 @@ module ActiveModel
       end
   end
 
-  class DeprecationHandlingMessageHash < SimpleDelegator
+  class DeprecationHandlingMessageHash < SimpleDelegator # :nodoc:
     def initialize(errors)
       @errors = errors
       super(prepare_content)
@@ -635,7 +649,7 @@ module ActiveModel
       end
   end
 
-  class DeprecationHandlingMessageArray < SimpleDelegator
+  class DeprecationHandlingMessageArray < SimpleDelegator # :nodoc:
     def initialize(content, errors, attribute)
       @errors = errors
       @attribute = attribute
@@ -657,7 +671,7 @@ module ActiveModel
     end
   end
 
-  class DeprecationHandlingDetailsHash < SimpleDelegator
+  class DeprecationHandlingDetailsHash < SimpleDelegator # :nodoc:
     def initialize(details)
       details.default = []
       details.freeze

data/lib/active_model/gem_version.rb

@@ -7,10 +7,10 @@ module ActiveModel
   end
 
   module VERSION
-    MAJOR = 6
-    MINOR = 1
-    TINY  = 3
-    PRE   = "1"
+    MAJOR = 7
+    MINOR = 0
+    TINY  = 0
+    PRE   = "alpha1"
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
   end

data/lib/active_model/locale/en.yml

@@ -32,5 +32,6 @@ 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,11 +3,10 @@
 module ActiveModel
   # == Active \Model \Basic \Model
   #
-  # 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.
+  # Allows implementing models similar to <tt>ActiveRecord::Base</tt>.
+  # Includes <tt>ActiveModel::API</tt> for the required interface for an
+  # object to interact with Action Pack and Action View, but can be
+  # extended with other functionalities.
   #
   # A minimal implementation could be:
   #
@@ -20,23 +19,7 @@ module ActiveModel
   #   person.name # => "bob"
   #   person.age  # => "18"
   #
-  # 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
+  # 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.
   #
@@ -58,42 +41,6 @@ module ActiveModel
   # (see below).
   module Model
     extend ActiveSupport::Concern
-    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
+    include ActiveModel::API
   end
 end

data/lib/active_model/naming.rb

@@ -3,6 +3,7 @@
 require "active_support/core_ext/hash/except"
 require "active_support/core_ext/module/introspection"
 require "active_support/core_ext/module/redefine_method"
+require "active_support/core_ext/module/delegation"
 
 module ActiveModel
   class Name
@@ -153,6 +154,7 @@ module ActiveModel
     # Returns a new ActiveModel::Name instance. By default, the +namespace+
     # and +name+ option will take the namespace and name of the given class
     # respectively.
+    # Use +locale+ argument for singularize and pluralize model name.
     #
     #   module Foo
     #     class Bar
@@ -161,7 +163,7 @@ module ActiveModel
     #
     #   ActiveModel::Name.new(Foo::Bar).to_s
     #   # => "Foo::Bar"
-    def initialize(klass, namespace = nil, name = nil)
+    def initialize(klass, namespace = nil, name = nil, locale = :en)
       @name = name || klass.name
 
       raise ArgumentError, "Class name cannot be blank. You need to supply a name argument when anonymous class given" if @name.blank?
@@ -169,16 +171,17 @@ module ActiveModel
       @unnamespaced = @name.delete_prefix("#{namespace.name}::") if namespace
       @klass        = klass
       @singular     = _singularize(@name)
-      @plural       = ActiveSupport::Inflector.pluralize(@singular)
+      @plural       = ActiveSupport::Inflector.pluralize(@singular, locale)
+      @uncountable  = @plural == @singular
       @element      = ActiveSupport::Inflector.underscore(ActiveSupport::Inflector.demodulize(@name))
       @human        = ActiveSupport::Inflector.humanize(@element)
       @collection   = ActiveSupport::Inflector.tableize(@name)
       @param_key    = (namespace ? _singularize(@unnamespaced) : @singular)
       @i18n_key     = @name.underscore.to_sym
 
-      @route_key          = (namespace ? ActiveSupport::Inflector.pluralize(@param_key) : @plural.dup)
-      @singular_route_key = ActiveSupport::Inflector.singularize(@route_key)
-      @route_key << "_index" if @plural == @singular
+      @route_key          = (namespace ? ActiveSupport::Inflector.pluralize(@param_key, locale) : @plural.dup)
+      @singular_route_key = ActiveSupport::Inflector.singularize(@route_key, locale)
+      @route_key << "_index" if @uncountable
     end
 
     # Transform the model name into a more human format, using I18n. By default,
@@ -206,6 +209,10 @@ module ActiveModel
       I18n.translate(defaults.shift, **options)
     end
 
+    def uncountable?
+      @uncountable
+    end
+
     private
       def _singularize(string)
         ActiveSupport::Inflector.underscore(string).tr("/", "_")
@@ -232,7 +239,7 @@ module ActiveModel
   # is required to pass the \Active \Model Lint test. So either extending the
   # provided method below, or rolling your own is required.
   module Naming
-    def self.extended(base) #:nodoc:
+    def self.extended(base) # :nodoc:
       base.silence_redefinition_of_method :model_name
       base.delegate :model_name, to: :class
     end
@@ -279,7 +286,7 @@ module ActiveModel
     #   ActiveModel::Naming.uncountable?(Sheep) # => true
     #   ActiveModel::Naming.uncountable?(Post)  # => false
     def self.uncountable?(record_or_class)
-      plural(record_or_class) == singular(record_or_class)
+      model_name_from_record_or_class(record_or_class).uncountable?
     end
 
     # Returns string to use while generating route names. It differs for
@@ -321,7 +328,7 @@ module ActiveModel
       model_name_from_record_or_class(record_or_class).param_key
     end
 
-    def self.model_name_from_record_or_class(record_or_class) #:nodoc:
+    def self.model_name_from_record_or_class(record_or_class) # :nodoc:
       if record_or_class.respond_to?(:to_model)
         record_or_class.to_model.model_name
       else

data/lib/active_model/serialization.rb

@@ -123,7 +123,7 @@ module ActiveModel
     #   user.serializable_hash(include: { notes: { only: 'title' }})
     #   # => {"name" => "Napoleon", "notes" => [{"title"=>"Battle of Austerlitz"}]}
     def serializable_hash(options = nil)
-      attribute_names = attributes.keys
+      attribute_names = self.attribute_names
 
       return serializable_attributes(attribute_names) if options.blank?
 
@@ -148,6 +148,11 @@ module ActiveModel
       hash
     end
 
+    # Returns an array of attribute names as strings
+    def attribute_names # :nodoc:
+      attributes.keys
+    end
+
     private
       # Hook method defining how an attribute value should be retrieved for
       # serialization. By default this is assumed to be an instance named after
@@ -177,7 +182,7 @@ module ActiveModel
       #   +association+ - name of the association
       #   +records+     - the association record(s) to be serialized
       #   +opts+        - options for the association records
-      def serializable_add_includes(options = {}) #:nodoc:
+      def serializable_add_includes(options = {}) # :nodoc:
         return unless includes = options[:include]
 
         unless includes.is_a?(Hash)

data/lib/active_model/translation.rb

@@ -17,7 +17,7 @@ module ActiveModel
   #
   # This also provides the required class methods for hooking into the
   # Rails internationalization API, including being able to define a
-  # class based +i18n_scope+ and +lookup_ancestors+ to find translations in
+  # class-based +i18n_scope+ and +lookup_ancestors+ to find translations in
   # parent classes.
   module Translation
     include ActiveModel::Naming

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

@@ -25,10 +25,18 @@ module ActiveModel
         end
 
         def changed?(old_value, _new_value, new_value_before_type_cast) # :nodoc:
-          super || number_to_non_number?(old_value, new_value_before_type_cast)
+          (super || number_to_non_number?(old_value, new_value_before_type_cast)) &&
+            !equal_nan?(old_value, new_value_before_type_cast)
         end
 
         private
+          def equal_nan?(old_value, new_value)
+            (old_value.is_a?(::Float) || old_value.is_a?(BigDecimal)) &&
+              old_value.nan? &&
+              old_value.instance_of?(new_value.class) &&
+              new_value.nan?
+          end
+
           def number_to_non_number?(old_value, new_value_before_type_cast)
             old_value != nil && non_numeric_string?(new_value_before_type_cast.to_s)
           end