activemodel 5.1.7 → 5.2.0.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA256:
-  metadata.gz: 176c2e4b4046605da54dbff663e8cca4e615bf2f985f11ce19befb86dd54b6e5
-  data.tar.gz: f94d4e883f254dc43a58abe127653920a852ceb437d2e96163418b3c9f64b273
+SHA1:
+  metadata.gz: 9a527b6fc9e7656a84868c763aec48bb368d7bfd
+  data.tar.gz: 4c6ebab7e83916520a612437380b074e002f37e1
 SHA512:
-  metadata.gz: 2571ca4fd35c99bbf91349f87a261a5e4821f8d2ec9172303c1d85536111ce843305bea423b3794e22a800270b9db8e9f97a23d981ab95ebda973547e8b0ad74
-  data.tar.gz: ce929044a81485baad038cfa449ee198720ed326afcb0aa3a782da558c7c4569e7f9ee433043fb5f48ddbbdfb26df75d376f2e1e256da13e80a4350126b06722
+  metadata.gz: 0671a93f14567ade18a581e3e0c848771e002261eccddcb703aa0b77f9574c1a2d2e091f2f295cafc37ce20e220dc01488b99e14653fb10d4415f4658c5396fb
+  data.tar.gz: 1385ef9675c0c9fd44b6acd88f55d3a25db8c0a5e42607b5ae12908e883aea9882c2fa42bcee5e50e585f1c46e023629878ef3bc40764ccb473efc32c81aaec4

data/CHANGELOG.md

@@ -1,112 +1,51 @@
-## Rails 5.1.7 (March 27, 2019) ##
+## Rails 5.2.0.beta1 (November 27, 2017) ##
 
-*   No changes.
+*   Execute `ConfirmationValidator` validation when `_confirmation`'s value is `false`.
 
+    *bogdanvlviv*
 
-## Rails 5.1.6.2 (March 11, 2019) ##
+*   Allow passing a Proc or Symbol to length validator options.
 
-*   No changes.
+    *Matt Rohrer*
 
+*   Add method `#merge!` for `ActiveModel::Errors`.
 
-## Rails 5.1.6.1 (November 27, 2018) ##
+    *Jahfer Husain*
 
-*   No changes.
-
-
-## Rails 5.1.6 (March 29, 2018) ##
-
-*   No changes.
-
-
-## Rails 5.1.5 (February 14, 2018) ##
-
-*   Fix to working before/after validation callbacks on multiple contexts.
-
-    *Yoshiyuki Hirano*
-
-## Rails 5.1.4 (September 07, 2017) ##
-
-*   No changes.
-
-
-## Rails 5.1.4.rc1 (August 24, 2017) ##
-
-*   No changes.
-
-
-## Rails 5.1.3 (August 03, 2017) ##
-
-*   No changes.
-
-
-## Rails 5.1.3.rc3 (July 31, 2017) ##
-
-*   No changes.
-
-
-## Rails 5.1.3.rc2 (July 25, 2017) ##
-
-*   No changes.
-
-
-## Rails 5.1.3.rc1 (July 19, 2017) ##
-
-*   No changes.
-
-
-## Rails 5.1.2 (June 26, 2017) ##
-
-*   Fix regression in numericality validator when comparing Decimal and Float input 
+*   Fix regression in numericality validator when comparing Decimal and Float input
     values with more scale than the schema.
 
     *Bradley Priest*
 
+*   Fix methods `#keys`, `#values` in `ActiveModel::Errors`.
 
-## Rails 5.1.1 (May 12, 2017) ##
-
-*   No changes.
-
-
-## Rails 5.1.0 (April 27, 2017) ##
-
-*   The original string assigned to a model attribute is no longer incorrectly
-    frozen.
-
-    Fixes #24185, #28718.
-
-    *Matthew Draper*
-
-*   Avoid converting integer as a string into float.
-
-    *namusyaka*
-
-*   Remove deprecated behavior that halts callbacks when the return is false.
-
-    *Rafael Mendonça França*
-
-*   Remove unused `ActiveModel::TestCase` class.
-
-    *Yuji Yaginuma*
-
-*   Moved DecimalWithoutScale, Text, and UnsignedInteger from Active Model to Active Record
-
-    *Iain Beeston*
-
-*   Allow indifferent access in `ActiveModel::Errors`.
-
-    `#include?`, `#has_key?`, `#key?`, `#delete` and `#full_messages_for`.
-
-    *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/README.rdoc

@@ -246,7 +246,7 @@ Source code can be downloaded as part of the Rails project on GitHub
 
 Active Model is released under the MIT license:
 
-* http://www.opensource.org/licenses/MIT
+* https://opensource.org/licenses/MIT
 
 
 == Support

data/lib/active_model.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 #--
 # Copyright (c) 2004-2017 David Heinemeier Hansson
 #
@@ -28,6 +30,8 @@ require "active_model/version"
 module ActiveModel
   extend ActiveSupport::Autoload
 
+  autoload :Attribute
+  autoload :Attributes
   autoload :AttributeAssignment
   autoload :AttributeMethods
   autoload :BlockValidator, "active_model/validator"
@@ -43,6 +47,7 @@ module ActiveModel
   autoload :SecurePassword
   autoload :Serialization
   autoload :Translation
+  autoload :Type
   autoload :Validations
   autoload :Validator
 
@@ -68,5 +73,5 @@ module ActiveModel
 end
 
 ActiveSupport.on_load(:i18n) do
-  I18n.load_path << File.dirname(__FILE__) + "/active_model/locale/en.yml"
+  I18n.load_path << File.expand_path("active_model/locale/en.yml", __dir__)
 end

data/lib/active_model/attribute.rb

@@ -0,0 +1,243 @@
+# 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
+      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 with_type(type)
+          self.class.new(name, type)
+        end
+      end
+
+      private_constant :FromDatabase, :FromUser, :Null, :Uninitialized, :WithCastValue
+  end
+end

data/lib/active_model/attribute/user_provided_default.rb

@@ -0,0 +1,30 @@
+# 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
+
+      protected
+
+        attr_reader :user_provided_value
+    end
+  end
+end