activemodel 5.2.5 → 6.0.4.1

data/lib/active_model/serializers/json.rb

@@ -26,13 +26,13 @@ module ActiveModel
       #   user = User.find(1)
       #   user.as_json
       #   # => { "id" => 1, "name" => "Konata Izumi", "age" => 16,
-      #   #     "created_at" => "2006/08/01", "awesome" => true}
+      #   #     "created_at" => "2006-08-01T17:27:133.000Z", "awesome" => true}
       #
       #   ActiveRecord::Base.include_root_in_json = true
       #
       #   user.as_json
       #   # => { "user" => { "id" => 1, "name" => "Konata Izumi", "age" => 16,
-      #   #                  "created_at" => "2006/08/01", "awesome" => true } }
+      #   #                  "created_at" => "2006-08-01T17:27:13.000Z", "awesome" => true } }
       #
       # This behavior can also be achieved by setting the <tt>:root</tt> option
       # to +true+ as in:
@@ -40,7 +40,7 @@ module ActiveModel
       #   user = User.find(1)
       #   user.as_json(root: true)
       #   # => { "user" => { "id" => 1, "name" => "Konata Izumi", "age" => 16,
-      #   #                  "created_at" => "2006/08/01", "awesome" => true } }
+      #   #                  "created_at" => "2006-08-01T17:27:13.000Z", "awesome" => true } }
       #
       # Without any +options+, the returned Hash will include all the model's
       # attributes.
@@ -48,7 +48,7 @@ module ActiveModel
       #   user = User.find(1)
       #   user.as_json
       #   # => { "id" => 1, "name" => "Konata Izumi", "age" => 16,
-      #   #      "created_at" => "2006/08/01", "awesome" => true}
+      #   #      "created_at" => "2006-08-01T17:27:13.000Z", "awesome" => true}
       #
       # The <tt>:only</tt> and <tt>:except</tt> options can be used to limit
       # the attributes included, and work similar to the +attributes+ method.
@@ -63,14 +63,14 @@ module ActiveModel
       #
       #   user.as_json(methods: :permalink)
       #   # => { "id" => 1, "name" => "Konata Izumi", "age" => 16,
-      #   #      "created_at" => "2006/08/01", "awesome" => true,
+      #   #      "created_at" => "2006-08-01T17:27:13.000Z", "awesome" => true,
       #   #      "permalink" => "1-konata-izumi" }
       #
       # To include associations use <tt>:include</tt>:
       #
       #   user.as_json(include: :posts)
       #   # => { "id" => 1, "name" => "Konata Izumi", "age" => 16,
-      #   #      "created_at" => "2006/08/01", "awesome" => true,
+      #   #      "created_at" => "2006-08-01T17:27:13.000Z", "awesome" => true,
       #   #      "posts" => [ { "id" => 1, "author_id" => 1, "title" => "Welcome to the weblog" },
       #   #                   { "id" => 2, "author_id" => 1, "title" => "So I was thinking" } ] }
       #
@@ -81,7 +81,7 @@ module ActiveModel
       #                                             only: :body } },
       #                              only: :title } })
       #   # => { "id" => 1, "name" => "Konata Izumi", "age" => 16,
-      #   #      "created_at" => "2006/08/01", "awesome" => true,
+      #   #      "created_at" => "2006-08-01T17:27:13.000Z", "awesome" => true,
       #   #      "posts" => [ { "comments" => [ { "body" => "1st post!" }, { "body" => "Second!" } ],
       #   #                     "title" => "Welcome to the weblog" },
       #   #                   { "comments" => [ { "body" => "Don't think too hard" } ],
@@ -93,11 +93,12 @@ module ActiveModel
           include_root_in_json
         end
 
+        hash = serializable_hash(options).as_json
         if root
           root = model_name.element if root == true
-          { root => serializable_hash(options) }
+          { root => hash }
         else
-          serializable_hash(options)
+          hash
         end
       end
 

data/lib/active_model/translation.rb

@@ -64,7 +64,7 @@ module ActiveModel
       defaults << attribute.humanize
 
       options[:default] = defaults
-      I18n.translate(defaults.shift, options)
+      I18n.translate(defaults.shift, **options)
     end
   end
 end

data/lib/active_model/type/big_integer.rb

@@ -6,7 +6,6 @@ module ActiveModel
   module Type
     class BigInteger < Integer # :nodoc:
       private
-
         def max_value
           ::Float::INFINITY
         end

data/lib/active_model/type/binary.rb

@@ -40,7 +40,7 @@ module ActiveModel
         alias_method :to_str, :to_s
 
         def hex
-          @value.unpack("H*")[0]
+          @value.unpack1("H*")
         end
 
         def ==(other)

data/lib/active_model/type/boolean.rb

@@ -34,7 +34,6 @@ module ActiveModel
       end
 
       private
-
         def cast_value(value)
           if value == ""
             nil

data/lib/active_model/type/date.rb

@@ -10,16 +10,11 @@ module ActiveModel
         :date
       end
 
-      def serialize(value)
-        cast(value)
-      end
-
       def type_cast_for_schema(value)
         value.to_s(:db).inspect
       end
 
       private
-
         def cast_value(value)
           if value.is_a?(::String)
             return if value.empty?

data/lib/active_model/type/date_time.rb

@@ -13,12 +13,7 @@ module ActiveModel
         :datetime
       end
 
-      def serialize(value)
-        super(cast(value))
-      end
-
       private
-
         def cast_value(value)
           return apply_seconds_precision(value) unless value.is_a?(::String)
           return if value.empty?
@@ -40,9 +35,9 @@ module ActiveModel
         end
 
         def value_from_multiparameter_assignment(values_hash)
-          missing_parameter = (1..3).detect { |key| !values_hash.key?(key) }
-          if missing_parameter
-            raise ArgumentError, missing_parameter
+          missing_parameters = (1..3).select { |key| !values_hash.key?(key) }
+          if missing_parameters.any?
+            raise ArgumentError, "Provided hash #{values_hash} doesn't contain necessary keys: #{missing_parameters}"
           end
           super
         end

data/lib/active_model/type/decimal.rb

@@ -17,7 +17,6 @@ module ActiveModel
       end
 
       private
-
         def cast_value(value)
           casted_value = \
             case value

data/lib/active_model/type/float.rb

@@ -18,10 +18,7 @@ module ActiveModel
         end
       end
 
-      alias serialize cast
-
       private
-
         def cast_value(value)
           case value
           when ::Float then value

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

@@ -5,6 +5,10 @@ module ActiveModel
     module Helpers # :nodoc: all
       class AcceptsMultiparameterTime < Module
         def initialize(defaults: {})
+          define_method(:serialize) do |value|
+            super(cast(value))
+          end
+
           define_method(:cast) do |value|
             if value.is_a?(Hash)
               value_from_multiparameter_assignment(value)

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

@@ -4,6 +4,10 @@ module ActiveModel
   module Type
     module Helpers # :nodoc: all
       module Numeric
+        def serialize(value)
+          cast(value)
+        end
+
         def cast(value)
           value = \
             case value
@@ -20,17 +24,19 @@ module ActiveModel
         end
 
         private
-
           def number_to_non_number?(old_value, new_value_before_type_cast)
-            old_value != nil && non_numeric_string?(new_value_before_type_cast)
+            old_value != nil && non_numeric_string?(new_value_before_type_cast.to_s)
           end
 
           def non_numeric_string?(value)
             # 'wibble'.to_i will give zero, we want to make sure
             # that we aren't marking int zero to string zero as
             # changed.
-            !/\A[-+]?\d+/.match?(value.to_s)
+            !NUMERIC_REGEX.match?(value)
           end
+
+          NUMERIC_REGEX = /\A\s*[+-]?\d/
+          private_constant :NUMERIC_REGEX
       end
     end
   end

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

@@ -22,10 +22,17 @@ module ActiveModel
         end
 
         def apply_seconds_precision(value)
-          return value unless precision && value.respond_to?(:usec)
-          number_of_insignificant_digits = 6 - precision
+          return value unless precision && value.respond_to?(:nsec)
+
+          number_of_insignificant_digits = 9 - precision
           round_power = 10**number_of_insignificant_digits
-          value.change(usec: value.usec - value.usec % round_power)
+          rounded_off_nsec = value.nsec % round_power
+
+          if rounded_off_nsec > 0
+            value.change(nsec: value.nsec - rounded_off_nsec)
+          else
+            value
+          end
         end
 
         def type_cast_for_schema(value)
@@ -37,7 +44,6 @@ module ActiveModel
         end
 
         private
-
           def new_time(year, mon, mday, hour, min, sec, microsec, offset = nil)
             # Treat 0000-00-00 00:00:00 as nil.
             return if year.nil? || (year == 0 && mon == 0 && mday == 0)
@@ -58,7 +64,13 @@ module ActiveModel
           # Doesn't handle time zones.
           def fast_string_to_time(string)
             if string =~ ISO_DATETIME
-              microsec = ($7.to_r * 1_000_000).to_i
+              microsec_part = $7
+              if microsec_part && microsec_part.start_with?(".") && microsec_part.length == 7
+                microsec_part[0] = ""
+                microsec = microsec_part.to_i
+              else
+                microsec = (microsec_part.to_r * 1_000_000).to_i
+              end
               new_time $1.to_i, $2.to_i, $3.to_i, $4.to_i, $5.to_i, $6.to_i, microsec
             end
           end

data/lib/active_model/type/immutable_string.rb

@@ -17,7 +17,6 @@ module ActiveModel
       end
 
       private
-
         def cast_value(value)
           result = \
             case value

data/lib/active_model/type/integer.rb

@@ -9,7 +9,7 @@ module ActiveModel
       # 4 bytes means an integer as opposed to smallint etc.
       DEFAULT_LIMIT = 4
 
-      def initialize(*)
+      def initialize(*, **)
         super
         @range = min_value...max_value
       end
@@ -19,39 +19,27 @@ module ActiveModel
       end
 
       def deserialize(value)
-        return if value.nil?
+        return if value.blank?
         value.to_i
       end
 
       def serialize(value)
-        result = cast(value)
-        if result
-          ensure_in_range(result)
-        end
-        result
+        return if value.is_a?(::String) && non_numeric_string?(value)
+        ensure_in_range(super)
       end
 
-      # TODO Change this to private once we've dropped Ruby 2.2 support.
-      # Workaround for Ruby 2.2 "private attribute?" warning.
-      protected
-
-        attr_reader :range
-
       private
+        attr_reader :range
 
         def cast_value(value)
-          case value
-          when true then 1
-          when false then 0
-          else
-            value.to_i rescue nil
-          end
+          value.to_i rescue nil
         end
 
         def ensure_in_range(value)
-          unless range.cover?(value)
+          if value && !range.cover?(value)
             raise ActiveModel::RangeError, "#{value} is out of range for #{self.class} with limit #{_limit} bytes"
           end
+          value
         end
 
         def max_value

data/lib/active_model/type/registry.rb

@@ -9,34 +9,32 @@ module ActiveModel
       end
 
       def register(type_name, klass = nil, **options, &block)
-        block ||= proc { |_, *args| klass.new(*args) }
+        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)
       end
 
-      def lookup(symbol, *args)
-        registration = find_registration(symbol, *args)
+      def lookup(symbol, *args, **kwargs)
+        registration = find_registration(symbol, *args, **kwargs)
 
         if registration
-          registration.call(self, symbol, *args)
+          registration.call(self, symbol, *args, **kwargs)
         else
           raise ArgumentError, "Unknown type #{symbol.inspect}"
         end
       end
 
-      # TODO Change this to private once we've dropped Ruby 2.2 support.
-      # Workaround for Ruby 2.2 "private attribute?" warning.
-      protected
-
-        attr_reader :registrations
-
       private
+        attr_reader :registrations
 
         def registration_klass
           Registration
         end
 
-        def find_registration(symbol, *args)
-          registrations.find { |r| r.matches?(symbol, *args) }
+        def find_registration(symbol, *args, **kwargs)
+          registrations.find { |r| r.matches?(symbol, *args, **kwargs) }
         end
     end
 
@@ -59,10 +57,7 @@ module ActiveModel
         type_name == name
       end
 
-      # TODO Change this to private once we've dropped Ruby 2.2 support.
-      # Workaround for Ruby 2.2 "private attribute?" warning.
-      protected
-
+      private
         attr_reader :name, :block
     end
   end

data/lib/active_model/type/string.rb

@@ -12,12 +12,11 @@ module ActiveModel
       end
 
       private
-
         def cast_value(value)
           case value
           when ::String then ::String.new(value)
-          when true then "t".freeze
-          when false then "f".freeze
+          when true then "t"
+          when false then "f"
           else value.to_s
           end
         end

data/lib/active_model/type/time.rb

@@ -6,17 +6,13 @@ module ActiveModel
       include Helpers::Timezone
       include Helpers::TimeValue
       include Helpers::AcceptsMultiparameterTime.new(
-        defaults: { 1 => 1970, 2 => 1, 3 => 1, 4 => 0, 5 => 0 }
+        defaults: { 1 => 2000, 2 => 1, 3 => 1, 4 => 0, 5 => 0 }
       )
 
       def type
         :time
       end
 
-      def serialize(value)
-        super(cast(value))
-      end
-
       def user_input_in_time_zone(value)
         return unless value.present?
 
@@ -33,7 +29,6 @@ module ActiveModel
       end
 
       private
-
         def cast_value(value)
           return apply_seconds_precision(value) unless value.is_a?(::String)
           return if value.empty?

data/lib/active_model/type/value.rb

@@ -114,7 +114,6 @@ module ActiveModel
       end
 
       private
-
         # Convenience method for types which do not need separate type casting
         # behavior for user and database inputs. Called by Value#cast for
         # values except +nil+.

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#blank?). Happens by default on save.
+      # Object#present?). Happens by default on save.
       #
       #   class Person < ActiveRecord::Base
       #     validates_absence_of :first_name

data/lib/active_model/validations/acceptance.rb

@@ -15,9 +15,9 @@ module ActiveModel
       end
 
       private
-
         def setup!(klass)
-          klass.include(LazilyDefineAttributes.new(AttributeDefinition.new(attributes)))
+          define_attributes = LazilyDefineAttributes.new(attributes)
+          klass.include(define_attributes) unless klass.included_modules.include?(define_attributes)
         end
 
         def acceptable_option?(value)
@@ -25,50 +25,57 @@ module ActiveModel
         end
 
         class LazilyDefineAttributes < Module
-          def initialize(attribute_definition)
+          def initialize(attributes)
+            @attributes = attributes.map(&:to_s)
+          end
+
+          def included(klass)
+            @lock = Mutex.new
+            mod = self
+
             define_method(:respond_to_missing?) do |method_name, include_private = false|
-              super(method_name, include_private) || attribute_definition.matches?(method_name)
+              mod.define_on(klass)
+              super(method_name, include_private) || mod.matches?(method_name)
             end
 
             define_method(:method_missing) do |method_name, *args, &block|
-              if attribute_definition.matches?(method_name)
-                attribute_definition.define_on(self.class)
+              mod.define_on(klass)
+              if mod.matches?(method_name)
                 send(method_name, *args, &block)
               else
                 super(method_name, *args, &block)
               end
             end
           end
-        end
-
-        class AttributeDefinition
-          def initialize(attributes)
-            @attributes = attributes.map(&:to_s)
-          end
 
           def matches?(method_name)
-            attr_name = convert_to_reader_name(method_name)
-            attributes.include?(attr_name)
+            attr_name = method_name.to_s.chomp("=")
+            attributes.any? { |name| name == attr_name }
           end
 
           def define_on(klass)
-            attr_readers = attributes.reject { |name| klass.attribute_method?(name) }
-            attr_writers = attributes.reject { |name| klass.attribute_method?("#{name}=") }
-            klass.send(:attr_reader, *attr_readers)
-            klass.send(:attr_writer, *attr_writers)
-          end
+            @lock&.synchronize do
+              return unless @lock
 
-          # TODO Change this to private once we've dropped Ruby 2.2 support.
-          # Workaround for Ruby 2.2 "private attribute?" warning.
-          protected
+              attr_readers = attributes.reject { |name| klass.attribute_method?(name) }
+              attr_writers = attributes.reject { |name| klass.attribute_method?("#{name}=") }
 
-            attr_reader :attributes
+              attr_reader(*attr_readers)
+              attr_writer(*attr_writers)
 
-          private
+              remove_method :respond_to_missing?
+              remove_method :method_missing
 
-            def convert_to_reader_name(method_name)
-              method_name.to_s.chomp("=")
+              @lock = nil
             end
+          end
+
+          def ==(other)
+            self.class == other.class && attributes == other.attributes
+          end
+
+          protected
+            attr_reader :attributes
         end
     end
 

data/lib/active_model/validations/callbacks.rb

@@ -112,7 +112,6 @@ module ActiveModel
       end
 
     private
-
       # Overwrite run validations to include callbacks.
       def run_validations!
         _run_validation_callbacks { super }

data/lib/active_model/validations/clusivity.rb

@@ -15,7 +15,6 @@ module ActiveModel
       end
 
     private
-
       def include?(record, value)
         members = if delimiter.respond_to?(:call)
           delimiter.call(record)
@@ -32,7 +31,7 @@ module ActiveModel
         @delimiter ||= options[:in] || options[:within]
       end
 
-      # In Ruby 2.2 <tt>Range#include?</tt> on non-number-or-time-ish ranges checks all
+      # After Ruby 2.2, <tt>Range#include?</tt> on non-number-or-time-ish ranges checks all
       # possible values in the range for equality, which is slower but more accurate.
       # <tt>Range#cover?</tt> uses the previous logic of comparing a value with the range
       # endpoints, which is fast but is only accurate on Numeric, Time, Date,

data/lib/active_model/validations/confirmation.rb

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

data/lib/active_model/validations/format.rb

@@ -6,7 +6,7 @@ module ActiveModel
       def validate_each(record, attribute, value)
         if options[:with]
           regexp = option_call(record, :with)
-          record_error(record, attribute, :with, value) if value.to_s !~ regexp
+          record_error(record, attribute, :with, value) if !value.to_s&.match?(regexp)
         elsif options[:without]
           regexp = option_call(record, :without)
           record_error(record, attribute, :without, value) if regexp.match?(value.to_s)
@@ -23,7 +23,6 @@ module ActiveModel
       end
 
       private
-
         def option_call(record, name)
           option = options[name]
           option.respond_to?(:call) ? option.call(record) : option

data/lib/active_model/validations/inclusion.rb

@@ -19,7 +19,7 @@ module ActiveModel
       # particular enumerable object.
       #
       #   class Person < ActiveRecord::Base
-      #     validates_inclusion_of :gender, in: %w( m f )
+      #     validates_inclusion_of :role, in: %w( admin contributor )
       #     validates_inclusion_of :age, in: 0..99
       #     validates_inclusion_of :format, in: %w( jpg gif png ), message: "extension %{value} is not included in the list"
       #     validates_inclusion_of :states, in: ->(person) { STATES[person.country] }

data/lib/active_model/validations/length.rb

@@ -32,7 +32,7 @@ module ActiveModel
           value = options[key]
 
           unless (value.is_a?(Integer) && value >= 0) || value == Float::INFINITY || value.is_a?(Symbol) || value.is_a?(Proc)
-            raise ArgumentError, ":#{key} must be a nonnegative Integer, Infinity, Symbol, or Proc"
+            raise ArgumentError, ":#{key} must be a non-negative Integer, Infinity, Symbol, or Proc"
           end
         end
       end

data/lib/active_model/validations/numericality.rb

@@ -13,6 +13,8 @@ module ActiveModel
 
       INTEGER_REGEX = /\A[+-]?\d+\z/
 
+      HEXADECIMAL_REGEX = /\A[+-]?0[xX]/
+
       def check_validity!
         keys = CHECKS.keys - [:odd, :even]
         options.slice(*keys).each do |option, value|
@@ -79,7 +81,6 @@ module ActiveModel
       end
 
     private
-
       def is_number?(raw_value)
         !parse_as_number(raw_value).nil?
       rescue ArgumentError, TypeError
@@ -88,7 +89,7 @@ module ActiveModel
 
       def parse_as_number(raw_value)
         if raw_value.is_a?(Float)
-          raw_value.to_d
+          raw_value.to_d(Float::DIG)
         elsif raw_value.is_a?(Numeric)
           raw_value
         elsif is_integer?(raw_value)
@@ -99,11 +100,11 @@ module ActiveModel
       end
 
       def is_integer?(raw_value)
-        INTEGER_REGEX === raw_value.to_s
+        INTEGER_REGEX.match?(raw_value.to_s)
       end
 
       def is_hexadecimal_literal?(raw_value)
-        /\A0[xX]/ === raw_value.to_s
+        HEXADECIMAL_REGEX.match?(raw_value.to_s)
       end
 
       def filtered_options(value)