activemodel 5.1.7 → 5.2.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 176c2e4b4046605da54dbff663e8cca4e615bf2f985f11ce19befb86dd54b6e5
-  data.tar.gz: f94d4e883f254dc43a58abe127653920a852ceb437d2e96163418b3c9f64b273
+  metadata.gz: d7f6668533dd90a9b8c479fc71940522acf40284b4604e8d689d637129e6795a
+  data.tar.gz: 9a519747c7fc021167852457a0e03056bc68351001f61d366d32386afe584d11
 SHA512:
-  metadata.gz: 2571ca4fd35c99bbf91349f87a261a5e4821f8d2ec9172303c1d85536111ce843305bea423b3794e22a800270b9db8e9f97a23d981ab95ebda973547e8b0ad74
-  data.tar.gz: ce929044a81485baad038cfa449ee198720ed326afcb0aa3a782da558c7c4569e7f9ee433043fb5f48ddbbdfb26df75d376f2e1e256da13e80a4350126b06722
+  metadata.gz: 0f5a6ba7be9164544db261136c14337a256ad42cf9776e8364b745a6ff2c90f32f5e7a53e24ddb6032971de7e6bca59cf27808dea11d060ab5c3b20b92baef9d
+  data.tar.gz: b63d763a8de2b5438801b3698f33522cd68f37c22de007d752a4d1d9250b6f2ed31aab780cc07c4179670c863bb517286b85dd77ffb9cdb1624cbf5cbbe3935b

data/CHANGELOG.md

@@ -1,112 +1,198 @@
-## Rails 5.1.7 (March 27, 2019) ##
+## Rails 5.2.8.1 (July 12, 2022) ##
 
 *   No changes.
 
 
-## Rails 5.1.6.2 (March 11, 2019) ##
+## Rails 5.2.8 (May 09, 2022) ##
 
 *   No changes.
 
 
-## Rails 5.1.6.1 (November 27, 2018) ##
+## Rails 5.2.7.1 (April 26, 2022) ##
 
 *   No changes.
 
 
-## Rails 5.1.6 (March 29, 2018) ##
+## Rails 5.2.7 (March 10, 2022) ##
 
 *   No changes.
 
 
-## Rails 5.1.5 (February 14, 2018) ##
+## Rails 5.2.6.3 (March 08, 2022) ##
 
-*   Fix to working before/after validation callbacks on multiple contexts.
+*   No changes.
 
-    *Yoshiyuki Hirano*
 
-## Rails 5.1.4 (September 07, 2017) ##
+## Rails 5.2.6.2 (February 11, 2022) ##
 
 *   No changes.
 
 
-## Rails 5.1.4.rc1 (August 24, 2017) ##
+## Rails 5.2.6.1 (February 11, 2022) ##
 
 *   No changes.
 
 
-## Rails 5.1.3 (August 03, 2017) ##
+## Rails 5.2.6 (May 05, 2021) ##
 
 *   No changes.
 
 
-## Rails 5.1.3.rc3 (July 31, 2017) ##
+## Rails 5.2.5 (March 26, 2021) ##
 
 *   No changes.
 
 
-## Rails 5.1.3.rc2 (July 25, 2017) ##
+## Rails 5.2.4.6 (May 05, 2021) ##
 
 *   No changes.
 
 
-## Rails 5.1.3.rc1 (July 19, 2017) ##
+## Rails 5.2.4.5 (February 10, 2021) ##
 
 *   No changes.
 
 
-## Rails 5.1.2 (June 26, 2017) ##
+## Rails 5.2.4.4 (September 09, 2020) ##
 
-*   Fix regression in numericality validator when comparing Decimal and Float input 
-    values with more scale than the schema.
+*   No changes.
 
-    *Bradley Priest*
+
+## Rails 5.2.4.3 (May 18, 2020) ##
+
+*   No changes.
 
 
-## Rails 5.1.1 (May 12, 2017) ##
+## Rails 5.2.4.2 (March 19, 2020) ##
 
 *   No changes.
 
 
-## Rails 5.1.0 (April 27, 2017) ##
+## Rails 5.2.4.1 (December 18, 2019) ##
+
+*   No changes.
+
+
+## Rails 5.2.4 (November 27, 2019) ##
+
+*   Type cast falsy boolean symbols on boolean attribute as false.
 
-*   The original string assigned to a model attribute is no longer incorrectly
-    frozen.
+    Fixes #35676.
 
-    Fixes #24185, #28718.
+    *Ryuta Kamizono*
 
-    *Matthew Draper*
 
-*   Avoid converting integer as a string into float.
+## Rails 5.2.3 (March 27, 2019) ##
+
+*   Fix date value when casting a multiparameter date hash to not convert
+    from Gregorian date to Julian date.
+
+    Before:
+
+        Day.new({"day(1i)"=>"1", "day(2i)"=>"1", "day(3i)"=>"1"})
+        => #<Day id: nil, day: "0001-01-03", created_at: nil, updated_at: nil>
+
+    After:
+
+        Day.new({"day(1i)"=>"1", "day(2i)"=>"1", "day(3i)"=>"1"})
+        => #<Day id: nil, day: "0001-01-01", created_at: nil, updated_at: nil>
+
+    Fixes #28521.
+
+    *Sayan Chakraborty*
+
+*   Fix numericality equality validation of `BigDecimal` and `Float`
+    by casting to `BigDecimal` on both ends of the validation.
+
+    *Gannon McGibbon*
+
+
+## Rails 5.2.2.1 (March 11, 2019) ##
+
+*   No changes.
 
-    *namusyaka*
 
-*   Remove deprecated behavior that halts callbacks when the return is false.
+## Rails 5.2.2 (December 04, 2018) ##
 
-    *Rafael Mendonça França*
+*   Fix numericality validator to still use value before type cast except Active Record.
 
-*   Remove unused `ActiveModel::TestCase` class.
+    Fixes #33651, #33686.
 
-    *Yuji Yaginuma*
+    *Ryuta Kamizono*
 
-*   Moved DecimalWithoutScale, Text, and UnsignedInteger from Active Model to Active Record
 
-    *Iain Beeston*
+## Rails 5.2.1.1 (November 27, 2018) ##
 
-*   Allow indifferent access in `ActiveModel::Errors`.
+*   No changes.
+
+
+## Rails 5.2.1 (August 07, 2018) ##
+
+*   No changes.
+
+
+## Rails 5.2.0 (April 09, 2018) ##
+
+*   Do not lose all multiple `:includes` with options in serialization.
+
+    *Mike Mangino*
+
+*   Models using the attributes API with a proc default can now be marshalled.
+
+    Fixes #31216.
+
+    *Sean Griffin*
+
+*   Fix to working before/after validation callbacks on multiple contexts.
+
+    *Yoshiyuki Hirano*
+
+*   Execute `ConfirmationValidator` validation when `_confirmation`'s value is `false`.
+
+    *bogdanvlviv*
+
+*   Allow passing a Proc or Symbol to length validator options.
+
+    *Matt Rohrer*
+
+*   Add method `#merge!` for `ActiveModel::Errors`.
+
+    *Jahfer Husain*
+
+*   Fix regression in numericality validator when comparing Decimal and Float input
+    values with more scale than the schema.
+
+    *Bradley Priest*
 
-    `#include?`, `#has_key?`, `#key?`, `#delete` and `#full_messages_for`.
+*   Fix methods `#keys`, `#values` in `ActiveModel::Errors`.
 
-    *Kenichi Kamiya*
+    Change `#keys` to only return the keys that don't have empty messages.
 
-*   Removed deprecated `:tokenizer` in the length validator.
+    Change `#values` to only return the not empty values.
 
-    *Rafael Mendonça França*
+    Example:
 
-*   Removed deprecated methods in `ActiveModel::Errors`.
+        # Before
+        person = Person.new
+        person.errors.keys     # => []
+        person.errors.values   # => []
+        person.errors.messages # => {}
+        person.errors[:name]   # => []
+        person.errors.messages # => {:name => []}
+        person.errors.keys     # => [:name]
+        person.errors.values   # => [[]]
 
-    `#get`, `#set`, `[]=`, `add_on_empty` and `add_on_blank`.
+        # After
+        person = Person.new
+        person.errors.keys     # => []
+        person.errors.values   # => []
+        person.errors.messages # => {}
+        person.errors[:name]   # => []
+        person.errors.messages # => {:name => []}
+        person.errors.keys     # => []
+        person.errors.values   # => []
 
-    *Rafael Mendonça França*
+    *bogdanvlviv*
 
 
-Please check [5-0-stable](https://github.com/rails/rails/blob/5-0-stable/activemodel/CHANGELOG.md) for previous changes.
+Please check [5-1-stable](https://github.com/rails/rails/blob/5-1-stable/activemodel/CHANGELOG.md) for previous changes.

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2004-2017 David Heinemeier Hansson
+Copyright (c) 2004-2018 David Heinemeier Hansson
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.rdoc

@@ -239,23 +239,23 @@ The latest version of Active Model can be installed with RubyGems:
 
 Source code can be downloaded as part of the Rails project on GitHub
 
-* https://github.com/rails/rails/tree/master/activemodel
+* https://github.com/rails/rails/tree/5-2-stable/activemodel
 
 
 == License
 
 Active Model is released under the MIT license:
 
-* http://www.opensource.org/licenses/MIT
+* https://opensource.org/licenses/MIT
 
 
 == Support
 
-API documentation is at
+API documentation is at:
 
 * http://api.rubyonrails.org
 
-Bug reports can be filed for the Ruby on Rails project here:
+Bug reports for the Ruby on Rails project can be filed here:
 
 * https://github.com/rails/rails/issues
 

data/lib/active_model/attribute/user_provided_default.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "active_model/attribute"
+
+module ActiveModel
+  class Attribute # :nodoc:
+    class UserProvidedDefault < FromUser # :nodoc:
+      def initialize(name, value, type, database_default)
+        @user_provided_value = value
+        super(name, value, type, database_default)
+      end
+
+      def value_before_type_cast
+        if user_provided_value.is_a?(Proc)
+          @memoized_value_before_type_cast ||= user_provided_value.call
+        else
+          @user_provided_value
+        end
+      end
+
+      def with_type(type)
+        self.class.new(name, user_provided_value, type, original_attribute)
+      end
+
+      def marshal_dump
+        result = [
+          name,
+          value_before_type_cast,
+          type,
+          original_attribute,
+        ]
+        result << value if defined?(@value)
+        result
+      end
+
+      def marshal_load(values)
+        name, user_provided_value, type, original_attribute, value = values
+        @name = name
+        @user_provided_value = user_provided_value
+        @type = type
+        @original_attribute = original_attribute
+        if values.length == 5
+          @value = value
+        end
+      end
+
+      protected
+
+        attr_reader :user_provided_value
+    end
+  end
+end

data/lib/active_model/attribute.rb

@@ -0,0 +1,248 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/object/duplicable"
+
+module ActiveModel
+  class Attribute # :nodoc:
+    class << self
+      def from_database(name, value, type)
+        FromDatabase.new(name, value, type)
+      end
+
+      def from_user(name, value, type, original_attribute = nil)
+        FromUser.new(name, value, type, original_attribute)
+      end
+
+      def with_cast_value(name, value, type)
+        WithCastValue.new(name, value, type)
+      end
+
+      def null(name)
+        Null.new(name)
+      end
+
+      def uninitialized(name, type)
+        Uninitialized.new(name, type)
+      end
+    end
+
+    attr_reader :name, :value_before_type_cast, :type
+
+    # This method should not be called directly.
+    # Use #from_database or #from_user
+    def initialize(name, value_before_type_cast, type, original_attribute = nil)
+      @name = name
+      @value_before_type_cast = value_before_type_cast
+      @type = type
+      @original_attribute = original_attribute
+    end
+
+    def value
+      # `defined?` is cheaper than `||=` when we get back falsy values
+      @value = type_cast(value_before_type_cast) unless defined?(@value)
+      @value
+    end
+
+    def original_value
+      if assigned?
+        original_attribute.original_value
+      else
+        type_cast(value_before_type_cast)
+      end
+    end
+
+    def value_for_database
+      type.serialize(value)
+    end
+
+    def changed?
+      changed_from_assignment? || changed_in_place?
+    end
+
+    def changed_in_place?
+      has_been_read? && type.changed_in_place?(original_value_for_database, value)
+    end
+
+    def forgetting_assignment
+      with_value_from_database(value_for_database)
+    end
+
+    def with_value_from_user(value)
+      type.assert_valid_value(value)
+      self.class.from_user(name, value, type, original_attribute || self)
+    end
+
+    def with_value_from_database(value)
+      self.class.from_database(name, value, type)
+    end
+
+    def with_cast_value(value)
+      self.class.with_cast_value(name, value, type)
+    end
+
+    def with_type(type)
+      if changed_in_place?
+        with_value_from_user(value).with_type(type)
+      else
+        self.class.new(name, value_before_type_cast, type, original_attribute)
+      end
+    end
+
+    def type_cast(*)
+      raise NotImplementedError
+    end
+
+    def initialized?
+      true
+    end
+
+    def came_from_user?
+      false
+    end
+
+    def has_been_read?
+      defined?(@value)
+    end
+
+    def ==(other)
+      self.class == other.class &&
+        name == other.name &&
+        value_before_type_cast == other.value_before_type_cast &&
+        type == other.type
+    end
+    alias eql? ==
+
+    def hash
+      [self.class, name, value_before_type_cast, type].hash
+    end
+
+    def init_with(coder)
+      @name = coder["name"]
+      @value_before_type_cast = coder["value_before_type_cast"]
+      @type = coder["type"]
+      @original_attribute = coder["original_attribute"]
+      @value = coder["value"] if coder.map.key?("value")
+    end
+
+    def encode_with(coder)
+      coder["name"] = name
+      coder["value_before_type_cast"] = value_before_type_cast unless value_before_type_cast.nil?
+      coder["type"] = type if type
+      coder["original_attribute"] = original_attribute if original_attribute
+      coder["value"] = value if defined?(@value)
+    end
+
+    protected
+
+      attr_reader :original_attribute
+      alias_method :assigned?, :original_attribute
+
+      def original_value_for_database
+        if assigned?
+          original_attribute.original_value_for_database
+        else
+          _original_value_for_database
+        end
+      end
+
+    private
+      def initialize_dup(other)
+        if defined?(@value) && @value.duplicable?
+          @value = @value.dup
+        end
+      end
+
+      def changed_from_assignment?
+        assigned? && type.changed?(original_value, value, value_before_type_cast)
+      end
+
+      def _original_value_for_database
+        type.serialize(original_value)
+      end
+
+      class FromDatabase < Attribute # :nodoc:
+        def type_cast(value)
+          type.deserialize(value)
+        end
+
+        def _original_value_for_database
+          value_before_type_cast
+        end
+      end
+
+      class FromUser < Attribute # :nodoc:
+        def type_cast(value)
+          type.cast(value)
+        end
+
+        def came_from_user?
+          !type.value_constructed_by_mass_assignment?(value_before_type_cast)
+        end
+      end
+
+      class WithCastValue < Attribute # :nodoc:
+        def type_cast(value)
+          value
+        end
+
+        def changed_in_place?
+          false
+        end
+      end
+
+      class Null < Attribute # :nodoc:
+        def initialize(name)
+          super(name, nil, Type.default_value)
+        end
+
+        def type_cast(*)
+          nil
+        end
+
+        def with_type(type)
+          self.class.with_cast_value(name, nil, type)
+        end
+
+        def with_value_from_database(value)
+          raise ActiveModel::MissingAttributeError, "can't write unknown attribute `#{name}`"
+        end
+        alias_method :with_value_from_user, :with_value_from_database
+        alias_method :with_cast_value, :with_value_from_database
+      end
+
+      class Uninitialized < Attribute # :nodoc:
+        UNINITIALIZED_ORIGINAL_VALUE = Object.new
+
+        def initialize(name, type)
+          super(name, nil, type)
+        end
+
+        def value
+          if block_given?
+            yield name
+          end
+        end
+
+        def original_value
+          UNINITIALIZED_ORIGINAL_VALUE
+        end
+
+        def value_for_database
+        end
+
+        def initialized?
+          false
+        end
+
+        def forgetting_assignment
+          dup
+        end
+
+        def with_type(type)
+          self.class.new(name, type)
+        end
+      end
+
+      private_constant :FromDatabase, :FromUser, :Null, :Uninitialized, :WithCastValue
+  end
+end

data/lib/active_model/attribute_assignment.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/hash/keys"
 
 module ActiveModel
@@ -19,20 +21,22 @@ module ActiveModel
     #   cat = Cat.new
     #   cat.assign_attributes(name: "Gorby", status: "yawning")
     #   cat.name # => 'Gorby'
-    #   cat.status => 'yawning'
+    #   cat.status # => 'yawning'
     #   cat.assign_attributes(status: "sleeping")
     #   cat.name # => 'Gorby'
-    #   cat.status => 'sleeping'
+    #   cat.status # => 'sleeping'
     def assign_attributes(new_attributes)
       if !new_attributes.respond_to?(:stringify_keys)
         raise ArgumentError, "When assigning attributes, you must pass a hash as an argument."
       end
-      return if new_attributes.nil? || new_attributes.empty?
+      return if new_attributes.empty?
 
       attributes = new_attributes.stringify_keys
       _assign_attributes(sanitize_for_mass_assignment(attributes))
     end
 
+    alias attributes= assign_attributes
+
     private
 
       def _assign_attributes(attributes)
@@ -42,8 +46,9 @@ module ActiveModel
       end
 
       def _assign_attribute(k, v)
-        if respond_to?("#{k}=")
-          public_send("#{k}=", v)
+        setter = :"#{k}="
+        if respond_to?(setter)
+          public_send(setter, v)
         else
           raise UnknownAttributeError.new(self, k)
         end

data/lib/active_model/attribute_methods.rb

@@ -1,5 +1,6 @@
+# frozen_string_literal: true
+
 require "concurrent/map"
-require "mutex_m"
 
 module ActiveModel
   # Raised when an attribute is not defined.
@@ -68,9 +69,8 @@ module ActiveModel
     CALL_COMPILABLE_REGEXP = /\A[a-zA-Z_]\w*[!?]?\z/
 
     included do
-      class_attribute :attribute_aliases, :attribute_method_matchers, instance_writer: false
-      self.attribute_aliases = {}
-      self.attribute_method_matchers = [ClassMethods::AttributeMethodMatcher.new]
+      class_attribute :attribute_aliases, instance_writer: false, default: {}
+      class_attribute :attribute_method_matchers, instance_writer: false, default: [ ClassMethods::AttributeMethodMatcher.new ]
     end
 
     module ClassMethods
@@ -328,13 +328,11 @@ module ActiveModel
         attribute_method_matchers_cache.clear
       end
 
-      def generated_attribute_methods #:nodoc:
-        @generated_attribute_methods ||= Module.new {
-          extend Mutex_m
-        }.tap { |mod| include mod }
-      end
-
       private
+        def generated_attribute_methods
+          @generated_attribute_methods ||= Module.new.tap { |mod| include mod }
+        end
+
         def instance_method_already_implemented?(method_name)
           generated_attribute_methods.method_defined?(method_name)
         end
@@ -472,5 +470,9 @@ module ActiveModel
       def missing_attribute(attr_name, stack)
         raise ActiveModel::MissingAttributeError, "missing attribute: #{attr_name}", stack
       end
+
+      def _read_attribute(attr)
+        __send__(attr)
+      end
   end
 end