activemodel 4.2.0 → 6.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 0d16f8919f81db8eadf49f60bc8a4ae705bfa7d2
-  data.tar.gz: dae2d1dcc05714b21558f04cb03de8ee964e3490
+SHA256:
+  metadata.gz: 1caa114ce8c604cb9ac388ef4ebbfd796f8ff253799322db9fa714193bca6821
+  data.tar.gz: 49f8fb7f47a3154022161dee9871d6aba46f7750b3381e690e37d7ff2663ef48
 SHA512:
-  metadata.gz: 038b122e38dd5b82f015060bfeae6252f8d0edfa2e0cf3f545a5f8219b312bcc3740b4836d74d0afaf761a60a6cadd2e81ee47d3fb2066a386fb395f1461bacf
-  data.tar.gz: f4e3cfa3a0575f8da3cb1ab965140edd06243c8943d0a988be55c0b8115218087a555673c0df4d09dd1fd9c9a92a9ff4c29051179d4a4812b77156edb757ab63
+  metadata.gz: 26271099e8c36f89e1ee19fcb3469be914240ea887f15aba4d0de79b3db57f17d8467f523010330ba4f70e4df01d14398a6db7687df0a9be674f17ffd284be5d
+  data.tar.gz: e32d32dac693b8cae0445b2b9634345688b4010ecd4cbda054288934b4d0aeb353486415b55934e2c298fc8ab09655712ede1214e175ef4b67fe8af80926bb86

data/CHANGELOG.md

@@ -1,61 +1,73 @@
-*   Passwords with spaces only allowed in `ActiveModel::SecurePassword`.
+## Rails 6.1.0 (December 09, 2020) ##
 
-    Presence validation can be used to restore old behavior.
+*   Pass in `base` instead of `base_class` to Error.human_attribute_name
 
-    *Yevhene Shemet*
+    This is useful in cases where the `human_attribute_name` method depends
+    on other attributes' values of the class under validation to derive what the
+    attribute name should be.
 
-*   Validate options passed to `ActiveModel::Validations.validate`.
+    *Filipe Sabella*
 
-    Preventing, in many cases, the simple mistake of using `validate` instead of `validates`.
+*   Deprecate marshalling load from legacy attributes format.
 
-    *Sonny Michaud*
+    *Ryuta Kamizono*
 
-*   Deprecate `reset_#{attribute}` in favor of `restore_#{attribute}`.
+*   `*_previously_changed?` accepts `:from` and `:to` keyword arguments like `*_changed?`.
 
-    These methods may cause confusion with the `reset_changes`, which has
-    different behaviour.
+        topic.update!(status: :archived)
+        topic.status_previously_changed?(from: "active", to: "archived")
+        # => true
 
-    *Rafael Mendonça França*
+    *George Claghorn*
 
-*   Deprecate `ActiveModel::Dirty#reset_changes` in favor of `#clear_changes_information`.
+*   Raise FrozenError when trying to write attributes that aren't backed by the database on an object that is frozen:
 
-    Method's name is causing confusion with the `reset_#{attribute}` methods.
-    While `reset_name` sets the value of the name attribute to previous value
-    `reset_changes` only discards the changes.
+        class Animal
+          include ActiveModel::Attributes
+          attribute :age
+        end
 
-    *Rafael Mendonça França*
+        animal = Animal.new
+        animal.freeze
+        animal.age = 25 # => FrozenError, "can't modify a frozen Animal"
 
-*   Added `restore_attributes` method to `ActiveModel::Dirty` API which restores
-    the value of changed attributes to previous value.
+    *Josh Brody*
 
-    *Igor G.*
+*   Add `*_previously_was` attribute methods when dirty tracking. Example:
 
-*   Allow proc and symbol as values for `only_integer` of `NumericalityValidator`
+        pirate.update(catchphrase: "Ahoy!")
+        pirate.previous_changes["catchphrase"] # => ["Thar She Blows!", "Ahoy!"]
+        pirate.catchphrase_previously_was # => "Thar She Blows!"
 
-    *Robin Mehner*
+    *DHH*
 
-*   `has_secure_password` now verifies that the given password is less than 72
-    characters if validations are enabled.
+*   Encapsulate each validation error as an Error object.
 
-    Fixes #14591.
+    The `ActiveModel`’s `errors` collection is now an array of these Error
+    objects, instead of messages/details hash.
 
-    *Akshay Vishnoi*
+    For each of these `Error` object, its `message` and `full_message` methods
+    are for generating error messages. Its `details` method would return error’s
+    extra parameters, found in the original `details` hash.
 
-*   Remove deprecated `Validator#setup` without replacement.
+    The change tries its best at maintaining backward compatibility, however
+    some edge cases won’t be covered, like `errors#first` will return `ActiveModel::Error` and manipulating
+    `errors.messages` and `errors.details` hashes directly will have no effect. Moving forward,
+    please convert those direct manipulations to use provided API methods instead.
 
-    See #10716.
+    The list of deprecated methods and their planned future behavioral changes at the next major release are:
 
-    *Kuldeep Aggarwal*
+    * `errors#slice!` will be removed.
+    * `errors#each` with the `key, value` two-arguments block will stop working, while the `error` single-argument block would return `Error` object.
+    * `errors#values` will be removed.
+    * `errors#keys` will be removed.
+    * `errors#to_xml` will be removed.
+    * `errors#to_h` will be removed, and can be replaced with `errors#to_hash`.
+    * Manipulating `errors` itself as a hash will have no effect (e.g. `errors[:foo] = 'bar'`).
+    * Manipulating the hash returned by `errors#messages` (e.g. `errors.messages[:foo] = 'bar'`) will have no effect.
+    * Manipulating the hash returned by `errors#details` (e.g. `errors.details[:foo].clear`) will have no effect.
 
-*   Add plural and singular form for length validator's default messages.
+    *lulalala*
 
-    *Abd ar-Rahman Hamid*
 
-*   Introduce `validate` as an alias for `valid?`.
-
-    This is more intuitive when you want to run validations but don't care about
-    the return value.
-
-    *Henrik Nyh*
-
-Please check [4-1-stable](https://github.com/rails/rails/blob/4-1-stable/activemodel/CHANGELOG.md) for previous changes.
+Please check [6-0-stable](https://github.com/rails/rails/blob/6-0-stable/activemodel/CHANGELOG.md) for previous changes.

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2004-2014 David Heinemeier Hansson
+Copyright (c) 2004-2020 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

@@ -5,6 +5,8 @@ They allow for Action Pack helpers to interact with non-Active Record models,
 for example. Active Model also helps with building custom ORMs for use outside of
 the Rails framework.
 
+You can read more about Active Model in the {Active Model Basics}[https://edgeguides.rubyonrails.org/active_model_basics.html] guide.
+
 Prior to Rails 3.0, if a plugin or gem developer wanted to have an object
 interact with Action Pack helpers, it was required to either copy chunks of
 code from Rails, or monkey patch entire helpers to make them handle objects
@@ -49,7 +51,7 @@ behavior out of the box:
         send("#{attr}=", nil)
       end
     end
-  
+
     person = Person.new
     person.clear_name
     person.clear_age
@@ -132,7 +134,7 @@ behavior out of the box:
         "Name"
       end
     end
-  
+
     person = Person.new
     person.name = nil
     person.validate!
@@ -154,8 +156,8 @@ behavior out of the box:
 
 * Making objects serializable
 
-  ActiveModel::Serialization provides a standard interface for your object
-  to provide +to_json+ or +to_xml+ serialization.
+  <tt>ActiveModel::Serialization</tt> provides a standard interface for your object
+  to provide +to_json+ serialization.
 
     class SerialPerson
       include ActiveModel::Serialization
@@ -177,13 +179,6 @@ behavior out of the box:
     s = SerialPerson.new
     s.to_json             # => "{\"name\":null}"
 
-    class SerialPerson
-      include ActiveModel::Serializers::Xml
-    end
-
-    s = SerialPerson.new
-    s.to_xml              # => "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<serial-person...
-
   {Learn more}[link:classes/ActiveModel/Serialization.html]
 
 * Internationalization (i18n) support
@@ -205,7 +200,7 @@ behavior out of the box:
       attr_accessor :first_name, :last_name
 
       validates_each :first_name, :last_name do |record, attr, value|
-        record.errors.add attr, 'starts with z.' if value.to_s[0] == ?z
+        record.errors.add attr, "starts with z." if value.start_with?("z")
       end
     end
 
@@ -216,10 +211,10 @@ behavior out of the box:
   {Learn more}[link:classes/ActiveModel/Validations.html]
 
 * Custom validators
-  
+
     class HasNameValidator < ActiveModel::Validator
       def validate(record)
-        record.errors[:name] = "must exist" if record.name.blank?
+        record.errors.add(:name, "must exist") if record.name.blank?
       end
     end
 
@@ -242,31 +237,30 @@ behavior out of the box:
 
 The latest version of Active Model can be installed with RubyGems:
 
-  % [sudo] gem install activemodel
+  $ gem install activemodel
 
 Source code can be downloaded as part of the Rails project on GitHub
 
-* https://github.com/rails/rails/tree/4-2-stable/activemodel
+* https://github.com/rails/rails/tree/master/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
+* https://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
 
 Feature requests should be discussed on the rails-core mailing list here:
 
-* https://groups.google.com/forum/?fromgroups#!forum/rubyonrails-core
-
+* https://discuss.rubyonrails.org/c/rubyonrails-core

data/lib/active_model/attribute/user_provided_default.rb

@@ -0,0 +1,51 @@
+# 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
+
+      private
+        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_before_type_cast, type, value = nil)
+        FromDatabase.new(name, value_before_type_cast, type, nil, value)
+      end
+
+      def from_user(name, value_before_type_cast, type, original_attribute = nil)
+        FromUser.new(name, value_before_type_cast, type, original_attribute)
+      end
+
+      def with_cast_value(name, value_before_type_cast, type)
+        WithCastValue.new(name, value_before_type_cast, 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, value = nil)
+      @name = name
+      @value_before_type_cast = value_before_type_cast
+      @type = type
+      @original_attribute = original_attribute
+      @value = value unless value.nil?
+    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
+
+    def original_value_for_database
+      if assigned?
+        original_attribute.original_value_for_database
+      else
+        _original_value_for_database
+      end
+    end
+
+    private
+      attr_reader :original_attribute
+      alias :assigned? :original_attribute
+
+      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
+        private :_original_value_for_database
+      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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/hash/keys"
+
+module ActiveModel
+  module AttributeAssignment
+    include ActiveModel::ForbiddenAttributesProtection
+
+    # Allows you to set all the attributes by passing in a hash of attributes with
+    # keys matching the attribute names.
+    #
+    # If the passed hash responds to <tt>permitted?</tt> method and the return value
+    # of this method is +false+ an <tt>ActiveModel::ForbiddenAttributesError</tt>
+    # exception is raised.
+    #
+    #   class Cat
+    #     include ActiveModel::AttributeAssignment
+    #     attr_accessor :name, :status
+    #   end
+    #
+    #   cat = Cat.new
+    #   cat.assign_attributes(name: "Gorby", status: "yawning")
+    #   cat.name # => 'Gorby'
+    #   cat.status # => 'yawning'
+    #   cat.assign_attributes(status: "sleeping")
+    #   cat.name # => 'Gorby'
+    #   cat.status # => 'sleeping'
+    def assign_attributes(new_attributes)
+      unless new_attributes.respond_to?(:each_pair)
+        raise ArgumentError, "When assigning attributes, you must pass a hash as an argument, #{new_attributes.class} passed."
+      end
+      return if new_attributes.empty?
+
+      _assign_attributes(sanitize_for_mass_assignment(new_attributes))
+    end
+
+    alias attributes= assign_attributes
+
+    private
+      def _assign_attributes(attributes)
+        attributes.each do |k, v|
+          _assign_attribute(k, v)
+        end
+      end
+
+      def _assign_attribute(k, v)
+        setter = :"#{k}="
+        if respond_to?(setter)
+          public_send(setter, v)
+        else
+          raise UnknownAttributeError.new(self, k.to_s)
+        end
+      end
+  end
+end