activemodel 6.0.5.1 → 6.1.7.4

data/lib/active_model/gem_version.rb

@@ -8,9 +8,9 @@ module ActiveModel
 
   module VERSION
     MAJOR = 6
-    MINOR = 0
-    TINY  = 5
-    PRE   = "1"
+    MINOR = 1
+    TINY  = 7
+    PRE   = "4"
 
     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,12 @@ module ActiveModel
 
         define_method("#{attribute}=") do |unencrypted_password|
           if unencrypted_password.nil?
-            self.send("#{attribute}_digest=", nil)
+            instance_variable_set("@#{attribute}", 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 +118,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,6 +8,11 @@ module ActiveModel
         @registrations = []
       end
 
+      def initialize_dup(other)
+        @registrations = @registrations.dup
+        super
+      end
+
       def register(type_name, klass = nil, **options, &block)
         unless block_given?
           block = proc { |_, *args| klass.new(*args) }
@@ -16,15 +21,16 @@ module ActiveModel
         registrations << registration_klass.new(type_name, block, **options)
       end
 
-      def lookup(symbol, *args, **kwargs)
-        registration = find_registration(symbol, *args, **kwargs)
+      def lookup(symbol, *args)
+        registration = find_registration(symbol, *args)
 
         if registration
-          registration.call(self, symbol, *args, **kwargs)
+          registration.call(self, symbol, *args)
         else
           raise ArgumentError, "Unknown type #{symbol.inspect}"
         end
       end
+      ruby2_keywords(:lookup) if respond_to?(:ruby2_keywords, true)
 
       private
         attr_reader :registrations
@@ -45,13 +51,10 @@ module ActiveModel
         @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
+      def call(_registry, *args)
+        block.call(*args)
       end
+      ruby2_keywords(:call) if respond_to?(:ruby2_keywords, true)
 
       def matches?(type_name, *args, **kwargs)
         type_name == name

data/lib/active_model/type/string.rb

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

data/lib/active_model/type/value.rb

@@ -11,6 +11,14 @@ module ActiveModel
         @limit = limit
       end
 
+      # Returns true if this type can convert +value+ to a type that is usable
+      # by the database.  For example a boolean type can return +true+ if the
+      # value parameter is a Ruby boolean, but may return +false+ if the value
+      # parameter is some other object.
+      def serializable?(value)
+        true
+      end
+
       def type # :nodoc:
       end
 
@@ -110,7 +118,7 @@ module ActiveModel
         [self.class, precision, scale, limit].hash
       end
 
-      def assert_valid_value(*)
+      def assert_valid_value(_)
       end
 
       private

data/lib/active_model/type.rb

@@ -29,9 +29,10 @@ module ActiveModel
         registry.register(type_name, klass, **options, &block)
       end
 
-      def lookup(*args, **kwargs) # :nodoc:
-        registry.lookup(*args, **kwargs)
+      def lookup(*args) # :nodoc:
+        registry.lookup(*args)
       end
+      ruby2_keywords(:lookup) if respond_to?(:ruby2_keywords, true)
 
       def default_value # :nodoc:
         @default_value ||= Value.new

data/lib/active_model/validations/absence.rb

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

data/lib/active_model/validations/acceptance.rb

@@ -10,7 +10,7 @@ module ActiveModel
 
       def validate_each(record, attribute, value)
         unless acceptable_option?(value)
-          record.errors.add(attribute, :accepted, options.except(:accept, :allow_nil))
+          record.errors.add(attribute, :accepted, **options.except(:accept, :allow_nil))
         end
       end
 

data/lib/active_model/validations/callbacks.rb

@@ -56,14 +56,7 @@ module ActiveModel
         def before_validation(*args, &block)
           options = args.extract_options!
 
-          if options.key?(:on)
-            options = options.dup
-            options[:on] = Array(options[:on])
-            options[:if] = Array(options[:if])
-            options[:if].unshift ->(o) {
-              !(options[:on] & Array(o.validation_context)).empty?
-            }
-          end
+          set_options_for_callback(options)
 
           set_callback(:validation, :before, *args, options, &block)
         end
@@ -99,16 +92,23 @@ module ActiveModel
           options = options.dup
           options[:prepend] = true
 
-          if options.key?(:on)
-            options[:on] = Array(options[:on])
-            options[:if] = Array(options[:if])
-            options[:if].unshift ->(o) {
-              !(options[:on] & Array(o.validation_context)).empty?
-            }
-          end
+          set_options_for_callback(options)
 
           set_callback(:validation, :after, *args, options, &block)
         end
+
+        private
+          def set_options_for_callback(options)
+            if options.key?(:on)
+              options[:on] = Array(options[:on])
+              options[:if] = [
+                ->(o) {
+                  !(options[:on] & Array(o.validation_context)).empty?
+                },
+                *options[:if]
+              ]
+            end
+          end
       end
 
     private

data/lib/active_model/validations/clusivity.rb

@@ -24,7 +24,11 @@ module ActiveModel
           delimiter
         end
 
-        members.send(inclusion_method(members), value)
+        if value.is_a?(Array)
+          value.all? { |v| members.public_send(inclusion_method(members), v) }
+        else
+          members.public_send(inclusion_method(members), value)
+        end
       end
 
       def delimiter

data/lib/active_model/validations/confirmation.rb

@@ -9,10 +9,10 @@ module ActiveModel
       end
 
       def validate_each(record, attribute, value)
-        unless (confirmed = record.send("#{attribute}_confirmation")).nil?
+        unless (confirmed = record.public_send("#{attribute}_confirmation")).nil?
           unless confirmation_value_equal?(record, attribute, value, confirmed)
             human_attribute_name = record.class.human_attribute_name(attribute)
-            record.errors.add(:"#{attribute}_confirmation", :confirmation, options.except(:case_sensitive).merge!(attribute: human_attribute_name))
+            record.errors.add(:"#{attribute}_confirmation", :confirmation, **options.except(:case_sensitive).merge!(attribute: human_attribute_name))
           end
         end
       end