activemodel 6.1.4.6 → 7.0.0.alpha1

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:
@@ -140,7 +141,7 @@ module ActiveModel
     end
 
     def as_json(options = {}) # :nodoc:
-      options[:except] = [options[:except], "mutations_from_database"].flatten
+      options[:except] = [*options[:except], "mutations_from_database", "mutations_before_last_save"]
       super(options)
     end
 

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  = 4
-    PRE   = "6"
+    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

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

@@ -12,9 +12,9 @@ module ActiveModel
 
           if value.acts_like?(:time)
             if is_utc?
-              value = value.getutc if value.respond_to?(:getutc) && !value.utc?
+              value = value.getutc if !value.utc?
             else
-              value = value.getlocal if value.respond_to?(:getlocal)
+              value = value.getlocal
             end
           end
 

data/lib/active_model/type/integer.rb

@@ -30,7 +30,10 @@ module ActiveModel
 
       def serializable?(value)
         cast_value = cast(value)
-        in_range?(cast_value) && super
+        in_range?(cast_value) || begin
+          yield cast_value if block_given?
+          false
+        end
       end
 
       private

data/lib/active_model/type/registry.rb

@@ -1,70 +1,38 @@
 # frozen_string_literal: true
 
 module ActiveModel
-  # :stopdoc:
   module Type
-    class Registry
+    class Registry # :nodoc:
       def initialize
-        @registrations = []
+        @registrations = {}
       end
 
-      def initialize_dup(other)
+      def initialize_copy(other)
         @registrations = @registrations.dup
         super
       end
 
-      def register(type_name, klass = nil, **options, &block)
+      def register(type_name, klass = nil, &block)
         unless block_given?
           block = proc { |_, *args| klass.new(*args) }
           block.ruby2_keywords if block.respond_to?(:ruby2_keywords)
         end
-        registrations << registration_klass.new(type_name, block, **options)
+        registrations[type_name] = block
       end
 
-      def lookup(symbol, *args, **kwargs)
-        registration = find_registration(symbol, *args, **kwargs)
+      def lookup(symbol, *args)
+        registration = registrations[symbol]
 
         if registration
-          registration.call(self, symbol, *args, **kwargs)
+          registration.call(symbol, *args)
         else
           raise ArgumentError, "Unknown type #{symbol.inspect}"
         end
       end
+      ruby2_keywords(:lookup)
 
       private
         attr_reader :registrations
-
-        def registration_klass
-          Registration
-        end
-
-        def find_registration(symbol, *args, **kwargs)
-          registrations.find { |r| r.matches?(symbol, *args, **kwargs) }
-        end
-    end
-
-    class Registration
-      # Options must be taken because of https://bugs.ruby-lang.org/issues/10856
-      def initialize(name, block, **)
-        @name = name
-        @block = block
-      end
-
-      def call(_registry, *args, **kwargs)
-        if kwargs.any? # https://bugs.ruby-lang.org/issues/10856
-          block.call(*args, **kwargs)
-        else
-          block.call(*args)
-        end
-      end
-
-      def matches?(type_name, *args, **kwargs)
-        type_name == name
-      end
-
-      private
-        attr_reader :name, :block
     end
   end
-  # :startdoc:
 end

data/lib/active_model/type/time.rb

@@ -33,7 +33,7 @@ module ActiveModel
           return apply_seconds_precision(value) unless value.is_a?(::String)
           return if value.empty?
 
-          dummy_time_value = value.sub(/\A(\d\d\d\d-\d\d-\d\d |)/, "2000-01-01 ")
+          dummy_time_value = value.sub(/\A\d{4}-\d\d-\d\d(?:T|\s)|/, "2000-01-01 ")
 
           fast_string_to_time(dummy_time_value) || begin
             time_hash = ::Date._parse(dummy_time_value)

data/lib/active_model/type.rb

@@ -24,13 +24,14 @@ module ActiveModel
     class << self
       attr_accessor :registry # :nodoc:
 
-      # Add a new type to the registry, allowing it to be gotten through ActiveModel::Type#lookup
-      def register(type_name, klass = nil, **options, &block)
-        registry.register(type_name, klass, **options, &block)
+      # Add a new type to the registry, allowing it to be referenced as a
+      # symbol by {attribute}[rdoc-ref:Attributes::ClassMethods#attribute].
+      def register(type_name, klass = nil, &block)
+        registry.register(type_name, klass, &block)
       end
 
-      def lookup(*args, **kwargs) # :nodoc:
-        registry.lookup(*args, **kwargs)
+      def lookup(...) # :nodoc:
+        registry.lookup(...)
       end
 
       def default_value # :nodoc:

data/lib/active_model/validations/absence.rb

@@ -3,7 +3,7 @@
 module ActiveModel
   module Validations
     # == \Active \Model Absence Validator
-    class AbsenceValidator < EachValidator #:nodoc:
+    class AbsenceValidator < EachValidator # :nodoc:
       def validate_each(record, attr_name, value)
         record.errors.add(attr_name, :present, **options) if value.present?
       end

data/lib/active_model/validations/clusivity.rb

@@ -4,7 +4,7 @@ require "active_support/core_ext/range"
 
 module ActiveModel
   module Validations
-    module Clusivity #:nodoc:
+    module Clusivity # :nodoc:
       ERROR_MESSAGE = "An object with the method #include? or a proc, lambda or symbol is required, " \
                       "and must be supplied as the :in (or :within) option of the configuration hash"
 

data/lib/active_model/validations/comparability.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module ActiveModel
+  module Validations
+    module Comparability # :nodoc:
+      COMPARE_CHECKS = { greater_than: :>, greater_than_or_equal_to: :>=,
+        equal_to: :==, less_than: :<, less_than_or_equal_to: :<=,
+        other_than: :!= }.freeze
+
+      def option_value(record, option_value)
+        case option_value
+        when Proc
+          option_value.call(record)
+        when Symbol
+          record.send(option_value)
+        else
+          option_value
+        end
+      end
+
+      def error_options(value, option_value)
+        options.except(*COMPARE_CHECKS.keys).merge!(
+          count: option_value,
+          value: value
+        )
+      end
+    end
+  end
+end

data/lib/active_model/validations/comparison.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require "active_model/validations/comparability"
+
+module ActiveModel
+  module Validations
+    class ComparisonValidator < EachValidator # :nodoc:
+      include Comparability
+
+      def check_validity!
+        unless (options.keys & COMPARE_CHECKS.keys).any?
+          raise ArgumentError, "Expected one of :greater_than, :greater_than_or_equal_to, "\
+          ":equal_to, :less_than, :less_than_or_equal_to, or :other_than option to be supplied."
+        end
+      end
+
+      def validate_each(record, attr_name, value)
+        options.slice(*COMPARE_CHECKS.keys).each do |option, raw_option_value|
+          option_value = option_value(record, raw_option_value)
+
+          if value.nil? || value.blank?
+            return record.errors.add(attr_name, :blank, **error_options(value, option_value))
+          end
+
+          unless value.public_send(COMPARE_CHECKS[option], option_value)
+            record.errors.add(attr_name, option, **error_options(value, option_value))
+          end
+        rescue ArgumentError => e
+          record.errors.add(attr_name, e.message)
+        end
+      end
+    end
+
+    module HelperMethods
+      # Validates the value of a specified attribute fulfills all
+      # defined comparisons with another value, proc, or attribute.
+      #
+      #   class Person < ActiveRecord::Base
+      #     validates_comparison_of :value, greater_than: 'the sum of its parts'
+      #   end
+      #
+      # Configuration options:
+      # * <tt>:message</tt> - A custom error message (default is: "failed comparison").
+      # * <tt>:greater_than</tt> - Specifies the value must be greater than the
+      #   supplied value.
+      # * <tt>:greater_than_or_equal_to</tt> - Specifies the value must be
+      #   greater than or equal to the supplied value.
+      # * <tt>:equal_to</tt> - Specifies the value must be equal to the supplied
+      #   value.
+      # * <tt>:less_than</tt> - Specifies the value must be less than the
+      #   supplied value.
+      # * <tt>:less_than_or_equal_to</tt> - Specifies the value must be less
+      #   than or equal to the supplied value.
+      # * <tt>:other_than</tt> - Specifies the value must not be equal to the
+      #   supplied value.
+      #
+      # There is also a list of default options supported by every validator:
+      # +:if+, +:unless+, +:on+, +:allow_nil+, +:allow_blank+, and +:strict+ .
+      # See <tt>ActiveModel::Validations#validates</tt> for more information
+      #
+      # The validator requires at least one of the following checks to be supplied.
+      # Each will accept a proc, value, or a symbol which corresponds to a method:
+      #
+      # * <tt>:greater_than</tt>
+      # * <tt>:greater_than_or_equal_to</tt>
+      # * <tt>:equal_to</tt>
+      # * <tt>:less_than</tt>
+      # * <tt>:less_than_or_equal_to</tt>
+      # * <tt>:other_than</tt>
+      #
+      # For example:
+      #
+      #   class Person < ActiveRecord::Base
+      #     validates_comparison_of :birth_date, less_than_or_equal_to: -> { Date.today }
+      #     validates_comparison_of :preferred_name, other_than: :given_name, allow_nil: true
+      #   end
+      def validates_comparison_of(*attr_names)
+        validates_with ComparisonValidator, _merge_attributes(attr_names)
+      end
+    end
+  end
+end

data/lib/active_model/validations/confirmation.rb

@@ -19,13 +19,13 @@ module ActiveModel
 
       private
         def setup!(klass)
-          klass.attr_reader(*attributes.map do |attribute|
+          klass.attr_reader(*attributes.filter_map do |attribute|
             :"#{attribute}_confirmation" unless klass.method_defined?(:"#{attribute}_confirmation")
-          end.compact)
+          end)
 
-          klass.attr_writer(*attributes.map do |attribute|
+          klass.attr_writer(*attributes.filter_map do |attribute|
             :"#{attribute}_confirmation" unless klass.method_defined?(:"#{attribute}_confirmation=")
-          end.compact)
+          end)
         end
 
         def confirmation_value_equal?(record, attribute, value, confirmed)