activemodel 7.0.8.1 → 7.1.3.2

data/lib/active_model/type/integer.rb

@@ -2,7 +2,46 @@
 
 module ActiveModel
   module Type
-    class Integer < Value # :nodoc:
+    # = Active Model \Integer \Type
+    #
+    # Attribute type for integer representation. This type is registered under
+    # the +:integer+ key.
+    #
+    #   class Person
+    #     include ActiveModel::Attributes
+    #
+    #     attribute :age, :integer
+    #   end
+    #
+    # Values are cast using their +to_i+ method, except for blank strings, which
+    # are cast to +nil+. If a +to_i+ method is not defined or raises an error,
+    # the value will be cast to +nil+.
+    #
+    #   person = Person.new
+    #
+    #   person.age = "18"
+    #   person.age # => 18
+    #
+    #   person.age = ""
+    #   person.age # => nil
+    #
+    #   person.age = :not_an_integer
+    #   person.age # => nil (because Symbol does not define #to_i)
+    #
+    # Serialization also works under the same principle. Non-numeric strings are
+    # serialized as +nil+, for example.
+    #
+    # Serialization also validates that the integer can be stored using a
+    # limited number of bytes. If it cannot, an ActiveModel::RangeError will be
+    # raised. The default limit is 4 bytes, and can be customized when declaring
+    # an attribute:
+    #
+    #   class Person
+    #     include ActiveModel::Attributes
+    #
+    #     attribute :age, :integer, limit: 6
+    #   end
+    class Integer < Value
       include Helpers::Numeric
 
       # Column storage size in bytes.
@@ -28,6 +67,10 @@ module ActiveModel
         ensure_in_range(super)
       end
 
+      def serialize_cast_value(value) # :nodoc:
+        ensure_in_range(value)
+      end
+
       def serializable?(value)
         cast_value = cast(value)
         in_range?(cast_value) || begin

data/lib/active_model/type/serialize_cast_value.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module ActiveModel
+  module Type
+    module SerializeCastValue # :nodoc:
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def serialize_cast_value_compatible?
+          return @serialize_cast_value_compatible if defined?(@serialize_cast_value_compatible)
+          @serialize_cast_value_compatible = ancestors.index(instance_method(:serialize_cast_value).owner) <= ancestors.index(instance_method(:serialize).owner)
+        end
+      end
+
+      module DefaultImplementation
+        def serialize_cast_value(value)
+          value
+        end
+      end
+
+      def self.included(klass)
+        klass.include DefaultImplementation unless klass.method_defined?(:serialize_cast_value)
+      end
+
+      def self.serialize(type, value)
+        # Using `type.equal?(type.itself_if_...)` is a performant way to also
+        # ensure that `type` is not just a DelegateClass instance (e.g.
+        # ActiveRecord::Type::Serialized) unintentionally delegating
+        # SerializeCastValue methods.
+        if type.equal?((type.itself_if_serialize_cast_value_compatible rescue nil))
+          type.serialize_cast_value(value)
+        else
+          type.serialize(value)
+        end
+      end
+
+      def itself_if_serialize_cast_value_compatible
+        self if self.class.serialize_cast_value_compatible?
+      end
+
+      def initialize(...)
+        super
+        self.class.serialize_cast_value_compatible? # eagerly compute
+      end
+    end
+  end
+end

data/lib/active_model/type/string.rb

@@ -4,7 +4,15 @@ require "active_model/type/immutable_string"
 
 module ActiveModel
   module Type
-    class String < ImmutableString # :nodoc:
+    # = Active Model \String \Type
+    #
+    # Attribute type for strings. It is registered under the +:string+ key.
+    #
+    # This class is a specialization of ActiveModel::Type::ImmutableString. It
+    # performs coercion in the same way, and can be configured in the same way.
+    # However, it accounts for mutable strings, so dirty tracking can properly
+    # check if a string has changed.
+    class String < ImmutableString
       def changed_in_place?(raw_old_value, new_value)
         if new_value.is_a?(::String)
           raw_old_value != new_value

data/lib/active_model/type/time.rb

@@ -2,12 +2,45 @@
 
 module ActiveModel
   module Type
-    class Time < Value # :nodoc:
+    # = Active Model \Time \Type
+    #
+    # Attribute type for time of day representation. It is registered under the
+    # +:time+ key.
+    #
+    #   class Event
+    #     include ActiveModel::Attributes
+    #
+    #     attribute :start, :time
+    #   end
+    #
+    # String values are parsed using the ISO 8601 datetime format, but are
+    # normalized to have a date of 2000-01-01 and be in the UTC time zone.
+    #
+    #   event = Event.new
+    #   event.start = "2004-10-25T01:23:45-06:00"
+    #
+    #   event.start.class # => Time
+    #   event.start       # => 2000-01-01 07:23:45 UTC
+    #
+    # Partial time-only formats are also accepted.
+    #
+    #   event.start = "00:01:02+03:00"
+    #   event.start # => 1999-12-31 21:01:02 UTC
+    #
+    # The degree of sub-second precision can be customized when declaring an
+    # attribute:
+    #
+    #   class Event
+    #     include ActiveModel::Attributes
+    #
+    #     attribute :start, :time, precision: 4
+    #   end
+    class Time < Value
       include Helpers::Timezone
-      include Helpers::TimeValue
       include Helpers::AcceptsMultiparameterTime.new(
         defaults: { 1 => 2000, 2 => 1, 3 => 1, 4 => 0, 5 => 0 }
       )
+      include Helpers::TimeValue
 
       def type
         :time
@@ -19,8 +52,12 @@ module ActiveModel
         case value
         when ::String
           value = "2000-01-01 #{value}"
-          time_hash = ::Date._parse(value)
-          return if time_hash[:hour].nil?
+          time_hash = begin
+            ::Date._parse(value)
+          rescue ArgumentError
+          end
+
+          return if time_hash.nil? || time_hash[:hour].nil?
         when ::Time
           value = value.change(year: 2000, day: 1, month: 1)
         end
@@ -31,13 +68,17 @@ module ActiveModel
       private
         def cast_value(value)
           return apply_seconds_precision(value) unless value.is_a?(::String)
-          return if value.empty?
+          return if value.blank?
 
           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)
-            return if time_hash[:hour].nil?
+            time_hash = begin
+              ::Date._parse(dummy_time_value)
+            rescue ArgumentError
+            end
+
+            return if time_hash.nil? || time_hash[:hour].nil?
             new_time(*time_hash.values_at(:year, :mon, :mday, :hour, :min, :sec, :sec_fraction, :offset))
           end
         end

data/lib/active_model/type/value.rb

@@ -2,10 +2,20 @@
 
 module ActiveModel
   module Type
+    # = Active Model \Value \Type
+    #
+    # The base class for all attribute types. This class also serves as the
+    # default type for attributes that do not specify a type.
     class Value
+      include SerializeCastValue
       attr_reader :precision, :scale, :limit
 
+      # Initializes a type with three basic configuration settings: precision,
+      # limit, and scale. The Value base class does not define behavior for
+      # these settings. It uses them for equality comparison and hash key
+      # generation only.
       def initialize(precision: nil, limit: nil, scale: nil)
+        super()
         @precision = precision
         @scale = scale
         @limit = limit
@@ -19,7 +29,9 @@ module ActiveModel
         true
       end
 
-      def type # :nodoc:
+      # Returns the unique type name as a Symbol. Subclasses should override
+      # this method.
+      def type
       end
 
       # Converts a value from database input to the appropriate ruby type. The
@@ -129,6 +141,10 @@ module ActiveModel
         false
       end
 
+      def as_json(*)
+        raise NoMethodError
+      end
+
       private
         # Convenience method for types which do not need separate type casting
         # behavior for user and database inputs. Called by Value#cast for

data/lib/active_model/type.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "active_model/type/helpers"
+require "active_model/type/serialize_cast_value"
 require "active_model/type/value"
 
 require "active_model/type/big_integer"

data/lib/active_model/validations/absence.rb

@@ -11,7 +11,7 @@ module ActiveModel
 
     module HelperMethods
       # Validates that the specified attributes are blank (as defined by
-      # Object#present?). Happens by default on save.
+      # Object#present?).
       #
       #   class Person < ActiveRecord::Base
       #     validates_absence_of :first_name

data/lib/active_model/validations/acceptance.rb

@@ -90,7 +90,7 @@ module ActiveModel
       #
       # If the database column does not exist, the +terms_of_service+ attribute
       # is entirely virtual. This check is performed only if +terms_of_service+
-      # is not +nil+ and by default on save.
+      # is not +nil+.
       #
       # Configuration options:
       # * <tt>:message</tt> - A custom error message (default is: "must be

data/lib/active_model/validations/callbacks.rb

@@ -2,12 +2,12 @@
 
 module ActiveModel
   module Validations
-    # == Active \Model \Validation \Callbacks
+    # = Active \Model \Validation \Callbacks
     #
-    # Provides an interface for any class to have +before_validation+ and
-    # +after_validation+ callbacks.
+    # Provides an interface for any class to have ClassMethods#before_validation and
+    # ClassMethods#after_validation callbacks.
     #
-    # First, include ActiveModel::Validations::Callbacks from the class you are
+    # First, include +ActiveModel::Validations::Callbacks+ from the class you are
     # creating:
     #
     #   class MyModel

data/lib/active_model/validations/clusivity.rb

@@ -1,10 +1,13 @@
 # frozen_string_literal: true
 
+require "active_model/validations/resolve_value"
 require "active_support/core_ext/range"
 
 module ActiveModel
   module Validations
     module Clusivity # :nodoc:
+      include ResolveValue
+
       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"
 
@@ -16,13 +19,7 @@ module ActiveModel
 
     private
       def include?(record, value)
-        members = if delimiter.respond_to?(:call)
-          delimiter.call(record)
-        elsif delimiter.respond_to?(:to_sym)
-          record.send(delimiter)
-        else
-          delimiter
-        end
+        members = resolve_value(record, delimiter)
 
         if value.is_a?(Array)
           value.all? { |v| members.public_send(inclusion_method(members), v) }
@@ -42,7 +39,7 @@ module ActiveModel
       # or DateTime ranges.
       def inclusion_method(enumerable)
         if enumerable.is_a? Range
-          case enumerable.first
+          case enumerable.begin || enumerable.end
           when Numeric, Time, DateTime, Date
             :cover?
           else

data/lib/active_model/validations/comparability.rb

@@ -7,17 +7,6 @@ module ActiveModel
         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,

data/lib/active_model/validations/comparison.rb

@@ -1,11 +1,13 @@
 # frozen_string_literal: true
 
 require "active_model/validations/comparability"
+require "active_model/validations/resolve_value"
 
 module ActiveModel
   module Validations
     class ComparisonValidator < EachValidator # :nodoc:
       include Comparability
+      include ResolveValue
 
       def check_validity!
         unless (options.keys & COMPARE_CHECKS.keys).any?
@@ -16,7 +18,7 @@ module ActiveModel
 
       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)
+          option_value = resolve_value(record, raw_option_value)
 
           if value.nil? || value.blank?
             return record.errors.add(attr_name, :blank, **error_options(value, option_value))
@@ -42,17 +44,23 @@ module ActiveModel
       # 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.
+      #   supplied value. The default error message for this option is _"must be
+      #   greater than %{count}"_.
       # * <tt>:greater_than_or_equal_to</tt> - Specifies the value must be
-      #   greater than or equal to the supplied value.
+      #   greater than or equal to the supplied value. The default error message
+      #   for this option is _"must be greater than or equal to %{count}"_.
       # * <tt>:equal_to</tt> - Specifies the value must be equal to the supplied
-      #   value.
+      #   value. The default error message for this option is _"must be equal to
+      #   %{count}"_.
       # * <tt>:less_than</tt> - Specifies the value must be less than the
-      #   supplied value.
+      #   supplied value. The default error message for this option is _"must be
+      #   less than %{count}"_.
       # * <tt>:less_than_or_equal_to</tt> - Specifies the value must be less
-      #   than or equal to the supplied value.
+      #   than or equal to the supplied value. The default error message for
+      #   this option is _"must be less than or equal to %{count}"_.
       # * <tt>:other_than</tt> - Specifies the value must not be equal to the
-      #   supplied value.
+      #   supplied value. The default error message for this option is _"must be
+      #   other than %{count}"_.
       #
       # There is also a list of default options supported by every validator:
       # +:if+, +:unless+, +:on+, +:allow_nil+, +:allow_blank+, and +:strict+ .

data/lib/active_model/validations/format.rb

@@ -1,14 +1,18 @@
 # frozen_string_literal: true
 
+require "active_model/validations/resolve_value"
+
 module ActiveModel
   module Validations
     class FormatValidator < EachValidator # :nodoc:
+      include ResolveValue
+
       def validate_each(record, attribute, value)
         if options[:with]
-          regexp = option_call(record, :with)
+          regexp = resolve_value(record, options[:with])
           record_error(record, attribute, :with, value) unless regexp.match?(value.to_s)
         elsif options[:without]
-          regexp = option_call(record, :without)
+          regexp = resolve_value(record, options[:without])
           record_error(record, attribute, :without, value) if regexp.match?(value.to_s)
         end
       end
@@ -23,11 +27,6 @@ module ActiveModel
       end
 
       private
-        def option_call(record, name)
-          option = options[name]
-          option.respond_to?(:call) ? option.call(record) : option
-        end
-
         def record_error(record, attribute, name, value)
           record.errors.add(attribute, :invalid, **options.except(name).merge!(value: value))
         end

data/lib/active_model/validations/length.rb

@@ -1,8 +1,12 @@
 # frozen_string_literal: true
 
+require "active_model/validations/resolve_value"
+
 module ActiveModel
   module Validations
     class LengthValidator < EachValidator # :nodoc:
+      include ResolveValue
+
       MESSAGES  = { is: :wrong_length, minimum: :too_short, maximum: :too_long }.freeze
       CHECKS    = { is: :==, minimum: :>=, maximum: :<= }.freeze
 
@@ -11,7 +15,8 @@ module ActiveModel
       def initialize(options)
         if range = (options.delete(:in) || options.delete(:within))
           raise ArgumentError, ":in and :within must be a Range" unless range.is_a?(Range)
-          options[:minimum], options[:maximum] = range.min, range.max
+          options[:minimum] = range.min if range.begin
+          options[:maximum] = (range.exclude_end? ? range.end - 1 : range.end) if range.end
         end
 
         if options[:allow_blank] == false && options[:minimum].nil? && options[:is].nil?
@@ -31,7 +36,9 @@ module ActiveModel
         keys.each do |key|
           value = options[key]
 
-          unless (value.is_a?(Integer) && value >= 0) || value == Float::INFINITY || value.is_a?(Symbol) || value.is_a?(Proc)
+          unless (value.is_a?(Integer) && value >= 0) ||
+                  value == Float::INFINITY || value == -Float::INFINITY ||
+                  value.is_a?(Symbol) || value.is_a?(Proc)
             raise ArgumentError, ":#{key} must be a non-negative Integer, Infinity, Symbol, or Proc"
           end
         end
@@ -45,12 +52,7 @@ module ActiveModel
           next unless check_value = options[key]
 
           if !value.nil? || skip_nil_check?(key)
-            case check_value
-            when Proc
-              check_value = check_value.call(record)
-            when Symbol
-              check_value = record.send(check_value)
-            end
+            check_value = resolve_value(record, check_value)
             next if value_length.public_send(validity_check, check_value)
           end
 

data/lib/active_model/validations/numericality.rb

@@ -1,17 +1,19 @@
 # frozen_string_literal: true
 
 require "active_model/validations/comparability"
+require "active_model/validations/resolve_value"
 require "bigdecimal/util"
 
 module ActiveModel
   module Validations
     class NumericalityValidator < EachValidator # :nodoc:
       include Comparability
+      include ResolveValue
 
       RANGE_CHECKS = { in: :in? }
       NUMBER_CHECKS = { odd: :odd?, even: :even? }
 
-      RESERVED_OPTIONS = COMPARE_CHECKS.keys + NUMBER_CHECKS.keys + RANGE_CHECKS.keys + [:only_integer]
+      RESERVED_OPTIONS = COMPARE_CHECKS.keys + NUMBER_CHECKS.keys + RANGE_CHECKS.keys + [:only_integer, :only_numeric]
 
       INTEGER_REGEX = /\A[+-]?\d+\z/
 
@@ -64,7 +66,7 @@ module ActiveModel
 
     private
       def option_as_number(record, option_value, precision, scale)
-        parse_as_number(option_value(record, option_value), precision, scale)
+        parse_as_number(resolve_value(record, option_value), precision, scale)
       end
 
       def parse_as_number(raw_value, precision, scale)
@@ -90,6 +92,10 @@ module ActiveModel
       end
 
       def is_number?(raw_value, precision, scale)
+        if options[:only_numeric] && !raw_value.is_a?(Numeric)
+          return false
+        end
+
         !parse_as_number(raw_value, precision, scale).nil?
       rescue ArgumentError, TypeError
         false
@@ -110,14 +116,7 @@ module ActiveModel
       end
 
       def allow_only_integer?(record)
-        case options[:only_integer]
-        when Symbol
-          record.send(options[:only_integer])
-        when Proc
-          options[:only_integer].call(record)
-        else
-          options[:only_integer]
-        end
+        resolve_value(record, options[:only_integer])
       end
 
       def prepare_value_for_validation(value, record, attr_name)
@@ -149,10 +148,11 @@ module ActiveModel
 
     module HelperMethods
       # Validates whether the value of the specified attribute is numeric by
-      # trying to convert it to a float with Kernel.Float (if <tt>only_integer</tt>
-      # is +false+) or applying it to the regular expression <tt>/\A[\+\-]?\d+\z/</tt>
-      # (if <tt>only_integer</tt> is set to +true+). Precision of Kernel.Float values
-      # are guaranteed up to 15 digits.
+      # trying to convert it to a float with +Kernel.Float+ (if
+      # <tt>only_integer</tt> is +false+) or applying it to the regular
+      # expression <tt>/\A[\+\-]?\d+\z/</tt> (if <tt>only_integer</tt> is set to
+      # +true+). Precision of +Kernel.Float+ values are guaranteed up to 15
+      # digits.
       #
       #   class Person < ActiveRecord::Base
       #     validates_numericality_of :value, on: :create
@@ -162,24 +162,36 @@ module ActiveModel
       # * <tt>:message</tt> - A custom error message (default is: "is not a number").
       # * <tt>:only_integer</tt> - Specifies whether the value has to be an
       #   integer (default is +false+).
+      # * <tt>:only_numeric</tt> - Specifies whether the value has to be an
+      #   instance of Numeric (default is +false+). The default behavior is to
+      #   attempt parsing the value if it is a String.
       # * <tt>:allow_nil</tt> - Skip validation if attribute is +nil+ (default is
       #   +false+). Notice that for Integer and Float columns empty strings are
       #   converted to +nil+.
       # * <tt>:greater_than</tt> - Specifies the value must be greater than the
-      #   supplied value.
+      #   supplied value. The default error message for this option is _"must be
+      #   greater than %{count}"_.
       # * <tt>:greater_than_or_equal_to</tt> - Specifies the value must be
-      #   greater than or equal the supplied value.
+      #   greater than or equal the supplied value. The default error message
+      #   for this option is _"must be greater than or equal to %{count}"_.
       # * <tt>:equal_to</tt> - Specifies the value must be equal to the supplied
-      #   value.
+      #   value. The default error message for this option is _"must be equal to
+      #   %{count}"_.
       # * <tt>:less_than</tt> - Specifies the value must be less than the
-      #   supplied value.
+      #   supplied value. The default error message for this option is _"must be
+      #   less than %{count}"_.
       # * <tt>:less_than_or_equal_to</tt> - Specifies the value must be less
-      #   than or equal the supplied value.
+      #   than or equal the supplied value. The default error message for this
+      #   option is _"must be less than or equal to %{count}"_.
       # * <tt>:other_than</tt> - Specifies the value must be other than the
-      #   supplied value.
-      # * <tt>:odd</tt> - Specifies the value must be an odd number.
-      # * <tt>:even</tt> - Specifies the value must be an even number.
-      # * <tt>:in</tt> - Check that the value is within a range.
+      #   supplied value. The default error message for this option is _"must be
+      #   other than %{count}"_.
+      # * <tt>:odd</tt> - Specifies the value must be an odd number. The default
+      #   error message for this option is _"must be odd"_.
+      # * <tt>:even</tt> - Specifies the value must be an even number. The
+      #   default error message for this option is _"must be even"_.
+      # * <tt>:in</tt> - Check that the value is within a range. The default
+      #   error message for this option is _"must be in %{count}"_.
       #
       # There is also a list of default options supported by every validator:
       # +:if+, +:unless+, +:on+, +:allow_nil+, +:allow_blank+, and +:strict+ .

data/lib/active_model/validations/presence.rb

@@ -10,7 +10,7 @@ module ActiveModel
 
     module HelperMethods
       # Validates that the specified attributes are not blank (as defined by
-      # Object#blank?). Happens by default on save.
+      # Object#blank?).
       #
       #   class Person < ActiveRecord::Base
       #     validates_presence_of :first_name

data/lib/active_model/validations/resolve_value.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module ActiveModel
+  module Validations
+    module ResolveValue # :nodoc:
+      def resolve_value(record, value)
+        case value
+        when Proc
+          if value.arity == 0
+            value.call
+          else
+            value.call(record)
+          end
+        when Symbol
+          record.send(value)
+        else
+          if value.respond_to?(:call)
+            value.call(record)
+          else
+            value
+          end
+        end
+      end
+    end
+  end
+end