activemodel 5.2.4.1 → 6.0.1

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/date.rb

@@ -10,10 +10,6 @@ module ActiveModel
         :date
       end
 
-      def serialize(value)
-        cast(value)
-      end
-
       def type_cast_for_schema(value)
         value.to_s(:db).inspect
       end

data/lib/active_model/type/date_time.rb

@@ -13,10 +13,6 @@ module ActiveModel
         :datetime
       end
 
-      def serialize(value)
-        super(cast(value))
-      end
-
       private
 
         def cast_value(value)
@@ -40,9 +36,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/float.rb

@@ -18,8 +18,6 @@ module ActiveModel
         end
       end
 
-      alias serialize cast
-
       private
 
         def cast_value(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
@@ -22,15 +26,18 @@ module ActiveModel
         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)
@@ -58,7 +65,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/integer.rb

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

@@ -23,13 +23,8 @@ module ActiveModel
         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
@@ -59,10 +54,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

@@ -16,8 +16,8 @@ module ActiveModel
         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?
 

data/lib/active_model/validations.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
 require "active_support/core_ext/array/extract_options"
-require "active_support/core_ext/hash/keys"
-require "active_support/core_ext/hash/except"
 
 module ActiveModel
   # == Active \Model \Validations

data/lib/active_model/validations/acceptance.rb

@@ -17,7 +17,8 @@ module ActiveModel
       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 +26,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/clusivity.rb

@@ -32,7 +32,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/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

@@ -99,11 +99,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
+        /\A0[xX]/.match?(raw_value.to_s)
       end
 
       def filtered_options(value)

data/lib/active_model/validations/validates.rb

@@ -63,7 +63,7 @@ module ActiveModel
       # and strings in shortcut form.
       #
       #   validates :email, format: /@/
-      #   validates :gender, inclusion: %w(male female)
+      #   validates :role, inclusion: %(admin contributor)
       #   validates :password, length: 6..20
       #
       # When using shortcut form, ranges and arrays are passed to your
@@ -116,7 +116,7 @@ module ActiveModel
           key = "#{key.to_s.camelize}Validator"
 
           begin
-            validator = key.include?("::".freeze) ? key.constantize : const_get(key)
+            validator = key.include?("::") ? key.constantize : const_get(key)
           rescue NameError
             raise ArgumentError, "Unknown validator: '#{key}'"
           end

data/lib/active_model/validator.rb

@@ -90,7 +90,7 @@ module ActiveModel
   #   class MyValidator < ActiveModel::Validator
   #     def initialize(options={})
   #       super
-  #       options[:class].send :attr_accessor, :custom_attribute
+  #       options[:class].attr_accessor :custom_attribute
   #     end
   #   end
   class Validator

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activemodel
 version: !ruby/object:Gem::Version
-  version: 5.2.4.1
+  version: 6.0.1
 platform: ruby
 authors:
 - David Heinemeier Hansson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-12-18 00:00:00.000000000 Z
+date: 2019-11-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 5.2.4.1
+        version: 6.0.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 5.2.4.1
+        version: 6.0.1
 description: A toolkit for building modeling frameworks like Active Record. Rich support
   for attributes, callbacks, validations, serialization, internationalization, and
   testing.
@@ -97,12 +97,15 @@ files:
 - lib/active_model/validations/with.rb
 - lib/active_model/validator.rb
 - lib/active_model/version.rb
-homepage: http://rubyonrails.org
+homepage: https://rubyonrails.org
 licenses:
 - MIT
 metadata:
-  source_code_uri: https://github.com/rails/rails/tree/v5.2.4.1/activemodel
-  changelog_uri: https://github.com/rails/rails/blob/v5.2.4.1/activemodel/CHANGELOG.md
+  bug_tracker_uri: https://github.com/rails/rails/issues
+  changelog_uri: https://github.com/rails/rails/blob/v6.0.1/activemodel/CHANGELOG.md
+  documentation_uri: https://api.rubyonrails.org/v6.0.1/
+  mailing_list_uri: https://groups.google.com/forum/#!forum/rubyonrails-talk
+  source_code_uri: https://github.com/rails/rails/tree/v6.0.1/activemodel
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -111,7 +114,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.2.2
+      version: 2.5.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="