activemodel 6.0.3.3 → 6.1.1

data/lib/active_model/gem_version.rb

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

data/lib/active_model/lint.rb

@@ -101,7 +101,7 @@ module ActiveModel
       # locale. If no error is present, the method should return an empty array.
       def test_errors_aref
         assert_respond_to model, :errors
-        assert model.errors[:hello].is_a?(Array), "errors#[] should return an Array"
+        assert_equal [], model.errors[:hello], "errors#[] should return an empty Array"
       end
 
       private

data/lib/active_model/naming.rb

@@ -8,7 +8,7 @@ module ActiveModel
   class Name
     include Comparable
 
-    attr_reader :singular, :plural, :element, :collection,
+    attr_accessor :singular, :plural, :element, :collection,
       :singular_route_key, :route_key, :param_key, :i18n_key,
       :name
 
@@ -166,7 +166,7 @@ module ActiveModel
 
       raise ArgumentError, "Class name cannot be blank. You need to supply a name argument when anonymous class given" if @name.blank?
 
-      @unnamespaced = @name.sub(/^#{namespace.name}::/, "") if namespace
+      @unnamespaced = @name.delete_prefix("#{namespace.name}::") if namespace
       @klass        = klass
       @singular     = _singularize(@name)
       @plural       = ActiveSupport::Inflector.pluralize(@singular)

data/lib/active_model/nested_error.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "active_model/error"
+require "forwardable"
+
+module ActiveModel
+  class NestedError < Error
+    def initialize(base, inner_error, override_options = {})
+      @base = base
+      @inner_error = inner_error
+      @attribute = override_options.fetch(:attribute) { inner_error.attribute }
+      @type = override_options.fetch(:type) { inner_error.type }
+      @raw_type = inner_error.raw_type
+      @options = inner_error.options
+    end
+
+    attr_reader :inner_error
+
+    extend Forwardable
+    def_delegators :@inner_error, :message
+  end
+end

data/lib/active_model/railtie.rb

@@ -14,7 +14,7 @@ module ActiveModel
     end
 
     initializer "active_model.i18n_customize_full_message" do
-      ActiveModel::Errors.i18n_customize_full_message = config.active_model.delete(:i18n_customize_full_message) || false
+      ActiveModel::Error.i18n_customize_full_message = config.active_model.delete(:i18n_customize_full_message) || false
     end
   end
 end

data/lib/active_model/secure_password.rb

@@ -45,19 +45,19 @@ module ActiveModel
       #   end
       #
       #   user = User.new(name: 'david', password: '', password_confirmation: 'nomatch')
-      #   user.save                                                       # => false, password required
+      #   user.save                                                  # => false, password required
       #   user.password = 'mUc3m00RsqyRe'
-      #   user.save                                                       # => false, confirmation doesn't match
+      #   user.save                                                  # => false, confirmation doesn't match
       #   user.password_confirmation = 'mUc3m00RsqyRe'
-      #   user.save                                                       # => true
+      #   user.save                                                  # => true
       #   user.recovery_password = "42password"
-      #   user.recovery_password_digest                                   # => "$2a$04$iOfhwahFymCs5weB3BNH/uXkTG65HR.qpW.bNhEjFP3ftli3o5DQC"
-      #   user.save                                                       # => true
-      #   user.authenticate('notright')                                   # => false
-      #   user.authenticate('mUc3m00RsqyRe')                              # => user
-      #   user.authenticate_recovery_password('42password')               # => user
-      #   User.find_by(name: 'david').try(:authenticate, 'notright')      # => false
-      #   User.find_by(name: 'david').try(:authenticate, 'mUc3m00RsqyRe') # => user
+      #   user.recovery_password_digest                              # => "$2a$04$iOfhwahFymCs5weB3BNH/uXkTG65HR.qpW.bNhEjFP3ftli3o5DQC"
+      #   user.save                                                  # => true
+      #   user.authenticate('notright')                              # => false
+      #   user.authenticate('mUc3m00RsqyRe')                         # => user
+      #   user.authenticate_recovery_password('42password')          # => user
+      #   User.find_by(name: 'david')&.authenticate('notright')      # => false
+      #   User.find_by(name: 'david')&.authenticate('mUc3m00RsqyRe') # => user
       def has_secure_password(attribute = :password, validations: true)
         # Load bcrypt gem only when has_secure_password is used.
         # This is to avoid ActiveModel (and by extension the entire framework)
@@ -79,7 +79,7 @@ module ActiveModel
           # when there is an error, the message is added to the password attribute instead
           # so that the error message will make sense to the end-user.
           validate do |record|
-            record.errors.add(attribute, :blank) unless record.send("#{attribute}_digest").present?
+            record.errors.add(attribute, :blank) unless record.public_send("#{attribute}_digest").present?
           end
 
           validates_length_of attribute, maximum: ActiveModel::SecurePassword::MAX_PASSWORD_LENGTH_ALLOWED
@@ -94,11 +94,11 @@ module ActiveModel
 
         define_method("#{attribute}=") do |unencrypted_password|
           if unencrypted_password.nil?
-            self.send("#{attribute}_digest=", nil)
+            self.public_send("#{attribute}_digest=", nil)
           elsif !unencrypted_password.empty?
             instance_variable_set("@#{attribute}", unencrypted_password)
             cost = ActiveModel::SecurePassword.min_cost ? BCrypt::Engine::MIN_COST : BCrypt::Engine.cost
-            self.send("#{attribute}_digest=", BCrypt::Password.create(unencrypted_password, cost: cost))
+            self.public_send("#{attribute}_digest=", BCrypt::Password.create(unencrypted_password, cost: cost))
           end
         end
 
@@ -117,7 +117,7 @@ module ActiveModel
         #   user.authenticate_password('notright')      # => false
         #   user.authenticate_password('mUc3m00RsqyRe') # => user
         define_method("authenticate_#{attribute}") do |unencrypted_password|
-          attribute_digest = send("#{attribute}_digest")
+          attribute_digest = public_send("#{attribute}_digest")
           BCrypt::Password.new(attribute_digest).is_password?(unencrypted_password) && self
         end
 

data/lib/active_model/serialization.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
-require "active_support/core_ext/hash/except"
-require "active_support/core_ext/hash/slice"
+require "active_support/core_ext/enumerable"
 
 module ActiveModel
   # == Active \Model \Serialization
@@ -124,17 +123,17 @@ module ActiveModel
     #   user.serializable_hash(include: { notes: { only: 'title' }})
     #   # => {"name" => "Napoleon", "notes" => [{"title"=>"Battle of Austerlitz"}]}
     def serializable_hash(options = nil)
-      options ||= {}
-
       attribute_names = attributes.keys
+
+      return serializable_attributes(attribute_names) if options.blank?
+
       if only = options[:only]
         attribute_names &= Array(only).map(&:to_s)
       elsif except = options[:except]
         attribute_names -= Array(except).map(&:to_s)
       end
 
-      hash = {}
-      attribute_names.each { |n| hash[n] = read_attribute_for_serialization(n) }
+      hash = serializable_attributes(attribute_names)
 
       Array(options[:methods]).each { |m| hash[m.to_s] = send(m) }
 
@@ -168,6 +167,10 @@ module ActiveModel
       #   end
       alias :read_attribute_for_serialization :send
 
+      def serializable_attributes(attribute_names)
+        attribute_names.index_with { |n| read_attribute_for_serialization(n) }
+      end
+
       # Add associations specified via the <tt>:include</tt> option.
       #
       # Expects a block that takes as arguments:

data/lib/active_model/serializers/json.rb

@@ -42,6 +42,13 @@ module ActiveModel
       #   # => { "user" => { "id" => 1, "name" => "Konata Izumi", "age" => 16,
       #   #                  "created_at" => "2006-08-01T17:27:13.000Z", "awesome" => true } }
       #
+      # If you prefer, <tt>:root</tt> may also be set to a custom string key instead as in:
+      #
+      #   user = User.find(1)
+      #   user.as_json(root: "author")
+      #   # => { "author" => { "id" => 1, "name" => "Konata Izumi", "age" => 16,
+      #   #                  "created_at" => "2006-08-01T17:27:13.000Z", "awesome" => true } }
+      #
       # Without any +options+, the returned Hash will include all the model's
       # attributes.
       #

data/lib/active_model/type/date_time.rb

@@ -35,8 +35,8 @@ module ActiveModel
         end
 
         def value_from_multiparameter_assignment(values_hash)
-          missing_parameters = (1..3).select { |key| !values_hash.key?(key) }
-          if missing_parameters.any?
+          missing_parameters = [1, 2, 3].delete_if { |key| values_hash.key?(key) }
+          unless missing_parameters.empty?
             raise ArgumentError, "Provided hash #{values_hash} doesn't contain necessary keys: #{missing_parameters}"
           end
           super

data/lib/active_model/type/float.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "active_support/core_ext/object/try"
+
 module ActiveModel
   module Type
     class Float < Value # :nodoc:

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

@@ -4,12 +4,12 @@ module ActiveModel
   module Type
     module Helpers # :nodoc: all
       class AcceptsMultiparameterTime < Module
-        def initialize(defaults: {})
-          define_method(:serialize) do |value|
+        module InstanceMethods
+          def serialize(value)
             super(cast(value))
           end
 
-          define_method(:cast) do |value|
+          def cast(value)
             if value.is_a?(Hash)
               value_from_multiparameter_assignment(value)
             else
@@ -17,7 +17,7 @@ module ActiveModel
             end
           end
 
-          define_method(:assert_valid_value) do |value|
+          def assert_valid_value(value)
             if value.is_a?(Hash)
               value_from_multiparameter_assignment(value)
             else
@@ -25,17 +25,21 @@ module ActiveModel
             end
           end
 
-          define_method(:value_constructed_by_mass_assignment?) do |value|
+          def value_constructed_by_mass_assignment?(value)
             value.is_a?(Hash)
           end
+        end
+
+        def initialize(defaults: {})
+          include InstanceMethods
 
           define_method(:value_from_multiparameter_assignment) do |values_hash|
             defaults.each do |k, v|
               values_hash[k] ||= v
             end
             return unless values_hash[1] && values_hash[2] && values_hash[3]
-            values = values_hash.sort.map(&:last)
-            ::Time.send(default_timezone, *values)
+            values = values_hash.sort.map!(&:last)
+            ::Time.public_send(default_timezone, *values)
           end
           private :value_from_multiparameter_assignment
         end

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

@@ -9,13 +9,18 @@ module ActiveModel
         end
 
         def cast(value)
-          value = \
+          # Checks whether the value is numeric. Spaceship operator
+          # will return nil if value is not numeric.
+          value = if value <=> 0
+            value
+          else
             case value
             when true then 1
             when false then 0
-            when ::String then value.presence
-            else value
+            else value.presence
             end
+          end
+
           super(value)
         end
 

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

@@ -11,10 +11,10 @@ module ActiveModel
           value = apply_seconds_precision(value)
 
           if value.acts_like?(:time)
-            zone_conversion_method = is_utc? ? :getutc : :getlocal
-
-            if value.respond_to?(zone_conversion_method)
-              value = value.send(zone_conversion_method)
+            if is_utc?
+              value = value.getutc if value.respond_to?(:getutc) && !value.utc?
+            else
+              value = value.getlocal if value.respond_to?(:getlocal)
             end
           end
 
@@ -52,27 +52,37 @@ module ActiveModel
               time = ::Time.utc(year, mon, mday, hour, min, sec, microsec) rescue nil
               return unless time
 
-              time -= offset
+              time -= offset unless offset == 0
               is_utc? ? time : time.getlocal
+            elsif is_utc?
+              ::Time.utc(year, mon, mday, hour, min, sec, microsec) rescue nil
             else
-              ::Time.public_send(default_timezone, year, mon, mday, hour, min, sec, microsec) rescue nil
+              ::Time.local(year, mon, mday, hour, min, sec, microsec) rescue nil
             end
           end
 
-          ISO_DATETIME = /\A(\d{4})-(\d\d)-(\d\d) (\d\d):(\d\d):(\d\d)(\.\d+)?\z/
+          ISO_DATETIME = /
+            \A
+            (\d{4})-(\d\d)-(\d\d)(?:T|\s)            # 2020-06-20T
+            (\d\d):(\d\d):(\d\d)(?:\.(\d{1,6})\d*)?  # 10:20:30.123456
+            (?:(Z(?=\z)|[+-]\d\d)(?::?(\d\d))?)?     # +09:00
+            \z
+          /x
 
-          # Doesn't handle time zones.
           def fast_string_to_time(string)
-            if string =~ ISO_DATETIME
-              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
+            return unless ISO_DATETIME =~ string
+
+            usec = $7.to_i
+            usec_len = $7&.length
+            if usec_len&.< 6
+              usec *= 10**(6 - usec_len)
             end
+
+            if $8
+              offset = $8 == "Z" ? 0 : $8.to_i * 3600 + $9.to_i * 60
+            end
+
+            new_time($1.to_i, $2.to_i, $3.to_i, $4.to_i, $5.to_i, $6.to_i, usec, offset)
           end
       end
     end

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

@@ -7,7 +7,7 @@ module ActiveModel
     module Helpers # :nodoc: all
       module Timezone
         def is_utc?
-          ::Time.zone_default.nil? || ::Time.zone_default =~ "UTC"
+          ::Time.zone_default.nil? || ::Time.zone_default.match?("UTC")
         end
 
         def default_timezone

data/lib/active_model/type/immutable_string.rb

@@ -3,28 +3,32 @@
 module ActiveModel
   module Type
     class ImmutableString < Value # :nodoc:
+      def initialize(**args)
+        @true  = -(args.delete(:true)&.to_s  || "t")
+        @false = -(args.delete(:false)&.to_s || "f")
+        super
+      end
+
       def type
         :string
       end
 
       def serialize(value)
         case value
-        when ::Numeric, ActiveSupport::Duration then value.to_s
-        when true then "t"
-        when false then "f"
+        when ::Numeric, ::Symbol, ActiveSupport::Duration then value.to_s
+        when true then @true
+        when false then @false
         else super
         end
       end
 
       private
         def cast_value(value)
-          result = \
-            case value
-            when true then "t"
-            when false then "f"
-            else value.to_s
-            end
-          result.freeze
+          case value
+          when true then @true
+          when false then @false
+          else value.to_s.freeze
+          end
         end
     end
   end

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
@@ -28,15 +28,24 @@ module ActiveModel
         ensure_in_range(super)
       end
 
+      def serializable?(value)
+        cast_value = cast(value)
+        in_range?(cast_value) && super
+      end
+
       private
         attr_reader :range
 
+        def in_range?(value)
+          !value || range.member?(value)
+        end
+
         def cast_value(value)
           value.to_i rescue nil
         end
 
         def ensure_in_range(value)
-          if value && !range.cover?(value)
+          unless in_range?(value)
             raise ActiveModel::RangeError, "#{value} is out of range for #{self.class} with limit #{_limit} bytes"
           end
           value

data/lib/active_model/type/registry.rb

@@ -8,9 +8,16 @@ module ActiveModel
         @registrations = []
       end
 
+      def initialize_dup(other)
+        @registrations = @registrations.dup
+        super
+      end
+
       def register(type_name, klass = nil, **options, &block)
-        block ||= proc { |_, *args| klass.new(*args) }
-        block.ruby2_keywords if block.respond_to?(:ruby2_keywords)
+        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
 
@@ -31,8 +38,8 @@ module ActiveModel
           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