activemodel 5.2.3 → 6.0.0.rc2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8b7a48a8632cd04a47cb21f650b4fff342c211176eec7e4e6fcc2baa0afd05a5
-  data.tar.gz: 170909099c8c1cd1fb72bbb9763dbba6356079c19b2a13511891f092b1045a4b
+  metadata.gz: b62a3079c9aa82727030259ac3f47b1f1e8a4292f9b02d7dff3351c59bd7504c
+  data.tar.gz: a85c9b29228edce13de7f632a0275af7343869c3b77df89645fbd78554bd43cb
 SHA512:
-  metadata.gz: d27c5bc840d55391b7e7388372a75216aeb3de80f896c35db3fdb681f231755be985d1c8504c5fb5dd5a08d465bf36ecef3318da5c796e1736217117498cd808
-  data.tar.gz: e6315cbe00493bf2d109f307dc86df73f157e4cc1c0869443409c3d428736033d0ee40722dd95750035969bafcc63cb4ea609785538afa99bbd5af7ad8cd96ad
+  metadata.gz: 3889c892dd0584c45062c6c802ad41b473076afe732f8958bf1014d3802a555acb80bb7cceb8209c1bf628a798b36d3ffbec2226adc39349b75174ede9115e3a
+  data.tar.gz: 5084f8019c592585e9ac1d739d100ae6c65f3cb6a003982cd9916d322f586a876bd2c1c9fe14c727b170dae8dc2df78a71547bf3695e7cdbe8753a07ebdffeb6

data/CHANGELOG.md

@@ -1,114 +1,157 @@
-## Rails 5.2.3 (March 27, 2019) ##
+## Rails 6.0.0.rc2 (July 22, 2019) ##
 
-*   Fix date value when casting a multiparameter date hash to not convert
-    from Gregorian date to Julian date.
+*   No changes.
 
-    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>
+## Rails 6.0.0.rc1 (April 24, 2019) ##
 
-    After:
+*   Type cast falsy boolean symbols on boolean attribute as false.
 
-        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 #35676.
 
-    Fixes #28521.
+    *Ryuta Kamizono*
 
-    *Sayan Chakraborty*
+*   Change how validation error translation strings are fetched: The new behavior
+    will first try the more specific keys, including doing locale fallback, then try
+    the less specific ones.
 
-*   Fix numericality equality validation of `BigDecimal` and `Float`
-    by casting to `BigDecimal` on both ends of the validation.
+    For example, this is the order in which keys will now be tried for a `blank`
+    error on a `product`'s `title` attribute with current locale set to `en-US`:
 
-    *Gannon McGibbon*
+        en-US.activerecord.errors.models.product.attributes.title.blank
+        en-US.activerecord.errors.models.product.blank
+        en-US.activerecord.errors.messages.blank
 
+        en.activerecord.errors.models.product.attributes.title.blank
+        en.activerecord.errors.models.product.blank
+        en.activerecord.errors.messages.blank
 
-## Rails 5.2.2.1 (March 11, 2019) ##
+        en-US.errors.attributes.title.blank
+        en-US.errors.messages.blank
 
-*   No changes.
+        en.errors.attributes.title.blank
+        en.errors.messages.blank
 
+    *Hugo Vacher*
 
-## Rails 5.2.2 (December 04, 2018) ##
 
-*   Fix numericality validator to still use value before type cast except Active Record.
+## Rails 6.0.0.beta3 (March 11, 2019) ##
 
-    Fixes #33651, #33686.
+*   No changes.
 
-    *Ryuta Kamizono*
 
+## Rails 6.0.0.beta2 (February 25, 2019) ##
 
-## Rails 5.2.1.1 (November 27, 2018) ##
+*   Fix date value when casting a multiparameter date hash to not convert
+    from Gregorian date to Julian date.
 
-*   No changes.
+    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>
 
-## Rails 5.2.1 (August 07, 2018) ##
+    After:
 
-*   No changes.
+        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 year value when casting a multiparameter time hash.
 
+    When assigning a hash to a time attribute that's missing a year component
+    (e.g. a `time_select` with `:ignore_date` set to `true`) then the year
+    defaults to 1970 instead of the expected 2000. This results in the attribute
+    changing as a result of the save.
 
-## Rails 5.2.0 (April 09, 2018) ##
+    Before:
+    ```
+    event = Event.new(start_time: { 4 => 20, 5 => 30 })
+    event.start_time # => 1970-01-01 20:30:00 UTC
+    event.save
+    event.reload
+    event.start_time # => 2000-01-01 20:30:00 UTC
+    ```
 
-*   Do not lose all multiple `:includes` with options in serialization.
+    After:
+    ```
+    event = Event.new(start_time: { 4 => 20, 5 => 30 })
+    event.start_time # => 2000-01-01 20:30:00 UTC
+    event.save
+    event.reload
+    event.start_time # => 2000-01-01 20:30:00 UTC
+    ```
 
-    *Mike Mangino*
+    *Andrew White*
 
-*   Models using the attributes API with a proc default can now be marshalled.
 
-    Fixes #31216.
+## Rails 6.0.0.beta1 (January 18, 2019) ##
 
-    *Sean Griffin*
+*   Add `ActiveModel::Errors#of_kind?`.
 
-*   Fix to working before/after validation callbacks on multiple contexts.
+    *bogdanvlviv*, *Rafael Mendonça França*
 
-    *Yoshiyuki Hirano*
+*   Fix numericality equality validation of `BigDecimal` and `Float`
+    by casting to `BigDecimal` on both ends of the validation.
 
-*   Execute `ConfirmationValidator` validation when `_confirmation`'s value is `false`.
+    *Gannon McGibbon*
 
-    *bogdanvlviv*
+*   Add `#slice!` method to `ActiveModel::Errors`.
 
-*   Allow passing a Proc or Symbol to length validator options.
+    *Daniel López Prat*
 
-    *Matt Rohrer*
+*   Fix numericality validator to still use value before type cast except Active Record.
 
-*   Add method `#merge!` for `ActiveModel::Errors`.
+    Fixes #33651, #33686.
 
-    *Jahfer Husain*
+    *Ryuta Kamizono*
 
-*   Fix regression in numericality validator when comparing Decimal and Float input
-    values with more scale than the schema.
+*   Fix `ActiveModel::Serializers::JSON#as_json` method for timestamps.
 
-    *Bradley Priest*
+    Before:
+    ```
+    contact = Contact.new(created_at: Time.utc(2006, 8, 1))
+    contact.as_json["created_at"] # => 2006-08-01 00:00:00 UTC
+    ```
 
-*   Fix methods `#keys`, `#values` in `ActiveModel::Errors`.
+    After:
+    ```
+    contact = Contact.new(created_at: Time.utc(2006, 8, 1))
+    contact.as_json["created_at"] # => "2006-08-01T00:00:00.000Z"
+    ```
 
-    Change `#keys` to only return the keys that don't have empty messages.
+    *Bogdan Gusiev*
 
-    Change `#values` to only return the not empty values.
+*   Allows configurable attribute name for `#has_secure_password`. This
+    still defaults to an attribute named 'password', causing no breaking
+    change. There is a new method `#authenticate_XXX` where XXX is the
+    configured attribute name, making the existing `#authenticate` now an
+    alias for this when the attribute is the default 'password'.
 
     Example:
 
-        # 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   # => [[]]
-
-        # 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   # => []
-
-    *bogdanvlviv*
-
-
-Please check [5-1-stable](https://github.com/rails/rails/blob/5-1-stable/activemodel/CHANGELOG.md) for previous changes.
+        class User < ActiveRecord::Base
+          has_secure_password :recovery_password, validations: false
+        end
+
+        user = User.new()
+        user.recovery_password = "42password"
+        user.recovery_password_digest # => "$2a$04$iOfhwahFymCs5weB3BNH/uX..."
+        user.authenticate_recovery_password('42password') # => user
+
+    *Unathi Chonco*
+
+*   Add `config.active_model.i18n_customize_full_message` in order to control whether
+    the `full_message` error format can be overridden at the attribute or model
+    level in the locale files. This is `false` by default.
+
+    *Martin Larochelle*
+
+*   Rails 6 requires Ruby 2.5.0 or newer.
+
+    *Jeremy Daer*, *Kasper Timm Hansen*
+
+
+Please check [5-2-stable](https://github.com/rails/rails/blob/5-2-stable/activemodel/CHANGELOG.md) for previous changes.

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2004-2018 David Heinemeier Hansson
+Copyright (c) 2004-2019 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
@@ -239,7 +241,7 @@ 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/5-2-stable/activemodel
+* https://github.com/rails/rails/tree/master/activemodel
 
 
 == License
@@ -253,7 +255,7 @@ Active Model is released under the MIT license:
 
 API documentation is at:
 
-* http://api.rubyonrails.org
+* https://api.rubyonrails.org
 
 Bug reports for the Ruby on Rails project can be filed here:
 

data/lib/active_model.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 #--
-# Copyright (c) 2004-2018 David Heinemeier Hansson
+# Copyright (c) 2004-2019 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/lib/active_model/attribute.rb

@@ -133,10 +133,6 @@ module ActiveModel
     end
 
     protected
-
-      attr_reader :original_attribute
-      alias_method :assigned?, :original_attribute
-
       def original_value_for_database
         if assigned?
           original_attribute.original_value_for_database
@@ -146,6 +142,9 @@ module ActiveModel
       end
 
     private
+      attr_reader :original_attribute
+      alias :assigned? :original_attribute
+
       def initialize_dup(other)
         if defined?(@value) && @value.duplicable?
           @value = @value.dup

data/lib/active_model/attribute/user_provided_default.rb

@@ -44,8 +44,7 @@ module ActiveModel
         end
       end
 
-      protected
-
+      private
         attr_reader :user_provided_value
     end
   end

data/lib/active_model/attribute_assignment.rb

@@ -27,7 +27,7 @@ module ActiveModel
     #   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."
+        raise ArgumentError, "When assigning attributes, you must pass a hash as an argument, #{new_attributes.class} passed."
       end
       return if new_attributes.empty?
 

data/lib/active_model/attribute_methods.rb

@@ -286,12 +286,12 @@ module ActiveModel
           method_name = matcher.method_name(attr_name)
 
           unless instance_method_already_implemented?(method_name)
-            generate_method = "define_method_#{matcher.method_missing_target}"
+            generate_method = "define_method_#{matcher.target}"
 
             if respond_to?(generate_method, true)
               send(generate_method, attr_name.to_s)
             else
-              define_proxy_call true, generated_attribute_methods, method_name, matcher.method_missing_target, attr_name.to_s
+              define_proxy_call true, generated_attribute_methods, method_name, matcher.target, attr_name.to_s
             end
           end
         end
@@ -352,53 +352,54 @@ module ActiveModel
 
         def attribute_method_matchers_matching(method_name)
           attribute_method_matchers_cache.compute_if_absent(method_name) do
-            # Must try to match prefixes/suffixes first, or else the matcher with no prefix/suffix
-            # will match every time.
+            # Bump plain matcher to last place so that only methods that do not
+            # match any other pattern match the actual attribute name.
+            # This is currently only needed to support legacy usage.
             matchers = attribute_method_matchers.partition(&:plain?).reverse.flatten(1)
-            matchers.map { |method| method.match(method_name) }.compact
+            matchers.map { |matcher| matcher.match(method_name) }.compact
           end
         end
 
         # Define a method `name` in `mod` that dispatches to `send`
         # using the given `extra` args. This falls back on `define_method`
         # and `send` if the given names cannot be compiled.
-        def define_proxy_call(include_private, mod, name, send, *extra)
+        def define_proxy_call(include_private, mod, name, target, *extra)
           defn = if NAME_COMPILABLE_REGEXP.match?(name)
             "def #{name}(*args)"
           else
             "define_method(:'#{name}') do |*args|"
           end
 
-          extra = (extra.map!(&:inspect) << "*args").join(", ".freeze)
+          extra = (extra.map!(&:inspect) << "*args").join(", ")
 
-          target = if CALL_COMPILABLE_REGEXP.match?(send)
-            "#{"self." unless include_private}#{send}(#{extra})"
+          body = if CALL_COMPILABLE_REGEXP.match?(target)
+            "#{"self." unless include_private}#{target}(#{extra})"
           else
-            "send(:'#{send}', #{extra})"
+            "send(:'#{target}', #{extra})"
           end
 
           mod.module_eval <<-RUBY, __FILE__, __LINE__ + 1
             #{defn}
-              #{target}
+              #{body}
             end
           RUBY
         end
 
         class AttributeMethodMatcher #:nodoc:
-          attr_reader :prefix, :suffix, :method_missing_target
+          attr_reader :prefix, :suffix, :target
 
-          AttributeMethodMatch = Struct.new(:target, :attr_name, :method_name)
+          AttributeMethodMatch = Struct.new(:target, :attr_name)
 
           def initialize(options = {})
             @prefix, @suffix = options.fetch(:prefix, ""), options.fetch(:suffix, "")
             @regex = /^(?:#{Regexp.escape(@prefix)})(.*)(?:#{Regexp.escape(@suffix)})$/
-            @method_missing_target = "#{@prefix}attribute#{@suffix}"
+            @target = "#{@prefix}attribute#{@suffix}"
             @method_name = "#{prefix}%s#{suffix}"
           end
 
           def match(method_name)
             if @regex =~ method_name
-              AttributeMethodMatch.new(method_missing_target, $1, method_name)
+              AttributeMethodMatch.new(target, $1)
             end
           end
 
@@ -474,5 +475,43 @@ module ActiveModel
       def _read_attribute(attr)
         __send__(attr)
       end
+
+      module AttrNames # :nodoc:
+        DEF_SAFE_NAME = /\A[a-zA-Z_]\w*\z/
+
+        # We want to generate the methods via module_eval rather than
+        # define_method, because define_method is slower on dispatch.
+        # Evaluating many similar methods may use more memory as the instruction
+        # sequences are duplicated and cached (in MRI).  define_method may
+        # be slower on dispatch, but if you're careful about the closure
+        # created, then define_method will consume much less memory.
+        #
+        # But sometimes the database might return columns with
+        # characters that are not allowed in normal method names (like
+        # 'my_column(omg)'. So to work around this we first define with
+        # the __temp__ identifier, and then use alias method to rename
+        # it to what we want.
+        #
+        # We are also defining a constant to hold the frozen string of
+        # the attribute name. Using a constant means that we do not have
+        # to allocate an object on each call to the attribute method.
+        # Making it frozen means that it doesn't get duped when used to
+        # key the @attributes in read_attribute.
+        def self.define_attribute_accessor_method(mod, attr_name, writer: false)
+          method_name = "#{attr_name}#{'=' if writer}"
+          if attr_name.ascii_only? && DEF_SAFE_NAME.match?(attr_name)
+            yield method_name, "'#{attr_name}'.freeze"
+          else
+            safe_name = attr_name.unpack1("h*")
+            const_name = "ATTR_#{safe_name}"
+            const_set(const_name, attr_name) unless const_defined?(const_name)
+            temp_method_name = "__temp__#{safe_name}#{'=' if writer}"
+            attr_name_expr = "::ActiveModel::AttributeMethods::AttrNames::#{const_name}"
+            yield temp_method_name, attr_name_expr
+            mod.alias_method method_name, temp_method_name
+            mod.undef_method temp_method_name
+          end
+        end
+      end
   end
 end