activerecord 5.2.8 → 7.0.2

data/lib/active_record/attribute_methods/serialization.rb

@@ -7,7 +7,7 @@ module ActiveRecord
 
       class ColumnNotSerializableError < StandardError
         def initialize(name, type)
-          super <<-EOS.strip_heredoc
+          super <<~EOS
             Column `#{name}` of type #{type.class} does not support `serialize` feature.
             Usually it means that you are trying to use `serialize`
             on a column that already implements serialization natively.
@@ -16,15 +16,45 @@ module ActiveRecord
       end
 
       module ClassMethods
-        # If you have an attribute that needs to be saved to the database as an
-        # object, and retrieved as the same object, then specify the name of that
-        # attribute using this method and it will be handled automatically. The
-        # serialization is done through YAML. If +class_name+ is specified, the
-        # serialized object must be of that class on assignment and retrieval.
-        # Otherwise SerializationTypeMismatch will be raised.
+        # If you have an attribute that needs to be saved to the database as a
+        # serialized object, and retrieved by deserializing into the same object,
+        # then specify the name of that attribute using this method and serialization
+        # will be handled automatically.
         #
-        # Empty objects as <tt>{}</tt>, in the case of +Hash+, or <tt>[]</tt>, in the case of
-        # +Array+, will always be persisted as null.
+        # The serialization format may be YAML, JSON, or any custom format using a
+        # custom coder class.
+        #
+        # === Serialization formats
+        #
+        #   serialize attr_name [, class_name_or_coder]
+        #
+        #                        |                           |  database storage   |
+        #   class_name_or_coder  | attribute read/write type | serialized | NULL   |
+        #   ---------------------+---------------------------+------------+--------+
+        #     <not given>        | any value that supports   |    YAML    |        |
+        #                        |   .to_yaml                |            |        |
+        #                        |                           |            |        |
+        #   Array                | Array **                  |    YAML    |  []    |
+        #                        |                           |            |        |
+        #   Hash                 | Hash **                   |    YAML    |  {}    |
+        #                        |                           |            |        |
+        #   JSON                 | any value that supports   |    JSON    |        |
+        #                        |   .to_json                |            |        |
+        #                        |                           |            |        |
+        #   <custom coder class> | any value supported by    |   custom   | custom |
+        #                        | the custom coder class    |            |        |
+        #
+        # ** If +class_name_or_coder+ is +Array+ or +Hash+, values retrieved will
+        # always be of that type, and any value assigned must be of that type or
+        # +SerializationTypeMismatch+ will be raised.
+        #
+        # ==== Custom coders
+        # A custom coder class or module may be given. This must have +self.load+
+        # and +self.dump+ class/module methods. <tt>self.dump(object)</tt> will be called
+        # to serialize an object and should return the serialized value to be
+        # stored in the database (+nil+ to store as +NULL+). <tt>self.load(string)</tt>
+        # will be called to reverse the process and load (unserialize) from the
+        # database.
         #
         # Keep in mind that database adapters handle certain serialization tasks
         # for you. For instance: +json+ and +jsonb+ types in PostgreSQL will be
@@ -38,12 +68,19 @@ module ActiveRecord
         # ==== Parameters
         #
         # * +attr_name+ - The field name that should be serialized.
-        # * +class_name_or_coder+ - Optional, a coder object, which responds to +.load+ and +.dump+
-        #   or a class name that the object type should be equal to.
+        # * +class_name_or_coder+ - Optional, may be be +Array+ or +Hash+ or
+        #   +JSON+ or a custom coder class or module which responds to +.load+
+        #   and +.dump+. See table above.
+        #
+        # ==== Options
+        #
+        # +default+ The default value to use when no value is provided. If this option
+        # is not passed, the previous default value (if any) will be used.
+        # Otherwise, the default will be +nil+.
         #
         # ==== Example
         #
-        #   # Serialize a preferences attribute.
+        #   # Serialize a preferences attribute using YAML coder.
         #   class User < ActiveRecord::Base
         #     serialize :preferences
         #   end
@@ -57,7 +94,29 @@ module ActiveRecord
         #   class User < ActiveRecord::Base
         #     serialize :preferences, Hash
         #   end
-        def serialize(attr_name, class_name_or_coder = Object)
+        #
+        #   # Serialize preferences using a custom coder.
+        #   class Rot13JSON
+        #     def self.rot13(string)
+        #       string.tr("a-zA-Z", "n-za-mN-ZA-M")
+        #     end
+        #
+        #     # returns serialized string that will be stored in the database
+        #     def self.dump(object)
+        #       ActiveSupport::JSON.encode(object).rot13
+        #     end
+        #
+        #     # reverses the above, turning the serialized string from the database
+        #     # back into its original value
+        #     def self.load(string)
+        #       ActiveSupport::JSON.decode(string.rot13)
+        #     end
+        #   end
+        #
+        #   class User < ActiveRecord::Base
+        #     serialize :preferences, Rot13JSON
+        #   end
+        def serialize(attr_name, class_name_or_coder = Object, **options)
           # When ::JSON is used, force it to go through the Active Support JSON encoder
           # to ensure special objects (e.g. Active Record models) are dumped correctly
           # using the #as_json hook.
@@ -69,17 +128,17 @@ module ActiveRecord
             Coders::YAMLColumn.new(attr_name, class_name_or_coder)
           end
 
-          decorate_attribute_type(attr_name, :serialize) do |type|
-            if type_incompatible_with_serialize?(type, class_name_or_coder)
-              raise ColumnNotSerializableError.new(attr_name, type)
+          attribute(attr_name, **options) do |cast_type|
+            if type_incompatible_with_serialize?(cast_type, class_name_or_coder)
+              raise ColumnNotSerializableError.new(attr_name, cast_type)
             end
 
-            Type::Serialized.new(type, coder)
+            cast_type = cast_type.subtype if Type::Serialized === cast_type
+            Type::Serialized.new(cast_type, coder)
           end
         end
 
         private
-
           def type_incompatible_with_serialize?(type, class_name)
             type.is_a?(ActiveRecord::Type::Json) && class_name == ::JSON ||
               type.respond_to?(:type_cast_array, true) && class_name == ::Array

data/lib/active_record/attribute_methods/time_zone_conversion.rb

@@ -1,9 +1,15 @@
 # frozen_string_literal: true
 
+require "active_support/core_ext/object/try"
+
 module ActiveRecord
   module AttributeMethods
     module TimeZoneConversion
       class TimeZoneConverter < DelegateClass(Type::Value) # :nodoc:
+        def self.new(subtype)
+          self === subtype ? subtype : super
+        end
+
         def deserialize(value)
           convert_time_to_time_zone(super)
         end
@@ -19,19 +25,20 @@ module ActiveRecord
             rescue ArgumentError
               nil
             end
+          elsif value.respond_to?(:infinite?) && value.infinite?
+            value
           else
             map_avoiding_infinite_recursion(super) { |v| cast(v) }
           end
         end
 
         private
-
           def convert_time_to_time_zone(value)
             return if value.nil?
 
             if value.acts_like?(:time)
               value.in_time_zone
-            elsif value.is_a?(::Float)
+            elsif value.respond_to?(:infinite?) && value.infinite?
               value
             else
               map_avoiding_infinite_recursion(value) { |v| convert_time_to_time_zone(v) }
@@ -56,29 +63,20 @@ module ActiveRecord
       extend ActiveSupport::Concern
 
       included do
-        mattr_accessor :time_zone_aware_attributes, instance_writer: false, default: false
-
+        class_attribute :time_zone_aware_attributes, instance_writer: false, default: false
         class_attribute :skip_time_zone_conversion_for_attributes, instance_writer: false, default: []
         class_attribute :time_zone_aware_types, instance_writer: false, default: [ :datetime, :time ]
       end
 
       module ClassMethods # :nodoc:
-        private
-
-          def inherited(subclass)
-            super
-            # We need to apply this decorator here, rather than on module inclusion. The closure
-            # created by the matcher would otherwise evaluate for `ActiveRecord::Base`, not the
-            # sub class being decorated. As such, changes to `time_zone_aware_attributes`, or
-            # `skip_time_zone_conversion_for_attributes` would not be picked up.
-            subclass.class_eval do
-              matcher = ->(name, type) { create_time_zone_conversion_attribute?(name, type) }
-              decorate_matching_attribute_types(matcher, :_time_zone_conversion) do |type|
-                TimeZoneConverter.new(type)
-              end
-            end
+        def define_attribute(name, cast_type, **)
+          if create_time_zone_conversion_attribute?(name, cast_type)
+            cast_type = TimeZoneConverter.new(cast_type)
           end
+          super
+        end
 
+        private
           def create_time_zone_conversion_attribute?(name, cast_type)
             enabled_for_column = time_zone_aware_attributes &&
               !skip_time_zone_conversion_for_attributes.include?(name.to_sym)

data/lib/active_record/attribute_methods/write.rb

@@ -6,26 +6,22 @@ module ActiveRecord
       extend ActiveSupport::Concern
 
       included do
-        attribute_method_suffix "="
+        attribute_method_suffix "=", parameters: "value"
       end
 
       module ClassMethods # :nodoc:
         private
-
-          def define_method_attribute=(name)
-            safe_name = name.unpack("h*".freeze).first
-            ActiveRecord::AttributeMethods::AttrNames.set_name_cache safe_name, name
-            sync_with_transaction_state = "sync_with_transaction_state" if name == primary_key
-
-            generated_attribute_methods.module_eval <<-STR, __FILE__, __LINE__ + 1
-              def __temp__#{safe_name}=(value)
-                name = ::ActiveRecord::AttributeMethods::AttrNames::ATTR_#{safe_name}
-                #{sync_with_transaction_state}
-                _write_attribute(name, value)
+          def define_method_attribute=(name, owner:)
+            ActiveModel::AttributeMethods::AttrNames.define_attribute_accessor_method(
+              owner, name, writer: true,
+            ) do |temp_method_name, attr_name_expr|
+              owner.define_cached_method("#{name}=", as: temp_method_name, namespace: :active_record) do |batch|
+                batch <<
+                  "def #{temp_method_name}(value)" <<
+                  "  _write_attribute(#{attr_name_expr}, value)" <<
+                  "end"
               end
-              alias_method #{(name + '=').inspect}, :__temp__#{safe_name}=
-              undef_method :__temp__#{safe_name}=
-            STR
+            end
           end
       end
 
@@ -33,36 +29,21 @@ module ActiveRecord
       # specified +value+. Empty strings for Integer and Float columns are
       # turned into +nil+.
       def write_attribute(attr_name, value)
-        name = if self.class.attribute_alias?(attr_name)
-          self.class.attribute_alias(attr_name).to_s
-        else
-          attr_name.to_s
-        end
+        name = attr_name.to_s
+        name = self.class.attribute_aliases[name] || name
 
-        primary_key = self.class.primary_key
-        name = primary_key if name == "id".freeze && primary_key
-        sync_with_transaction_state if name == primary_key
-        _write_attribute(name, value)
+        name = @primary_key if name == "id" && @primary_key
+        @attributes.write_from_user(name, value)
       end
 
       # This method exists to avoid the expensive primary_key check internally, without
       # breaking compatibility with the write_attribute API
       def _write_attribute(attr_name, value) # :nodoc:
-        @attributes.write_from_user(attr_name.to_s, value)
-        value
+        @attributes.write_from_user(attr_name, value)
       end
 
-      private
-        def write_attribute_without_type_cast(attr_name, value)
-          name = attr_name.to_s
-          @attributes.write_cast_value(name, value)
-          value
-        end
-
-        # Handle *= for method_missing.
-        def attribute=(attribute_name, value)
-          _write_attribute(attribute_name, value)
-        end
+      alias :attribute= :_write_attribute
+      private :attribute=
     end
   end
 end