activerecord 3.2.19 → 5.0.0

data/lib/active_record/attribute_methods/serialization.rb

@@ -3,115 +3,62 @@ module ActiveRecord
     module Serialization
       extend ActiveSupport::Concern
 
-      included do
-        # Returns a hash of all the attributes that have been specified for serialization as
-        # keys and their class restriction as values.
-        class_attribute :serialized_attributes
-        self.serialized_attributes = {}
-      end
-
-      class Attribute < Struct.new(:coder, :value, :state)
-        def unserialized_value
-          state == :serialized ? unserialize : value
-        end
-
-        def serialized_value
-          state == :unserialized ? serialize : value
-        end
-
-        def unserialize
-          self.state = :unserialized
-          self.value = coder.load(value)
-        end
-
-        def serialize
-          self.state = :serialized
-          self.value = coder.dump(value)
-        end
-      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 retrieval or SerializationTypeMismatch will be raised.
+        # 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.
+        #
+        # Empty objects as <tt>{}</tt>, in the case of +Hash+, or <tt>[]</tt>, in the case of
+        # +Array+, will always be persisted as null.
+        #
+        # Keep in mind that database adapters handle certain serialization tasks
+        # for you. For instance: +json+ and +jsonb+ types in PostgreSQL will be
+        # converted between JSON object/array syntax and Ruby +Hash+ or +Array+
+        # objects transparently. There is no need to use #serialize in this
+        # case.
+        #
+        # For more complex cases, such as conversion to or from your application
+        # domain objects, consider using the ActiveRecord::Attributes API.
         #
         # ==== Parameters
         #
         # * +attr_name+ - The field name that should be serialized.
-        # * +class_name+ - Optional, class name that the object type should be equal to.
+        # * +class_name_or_coder+ - Optional, a coder object, which responds to `.load` / `.dump`
+        #   or a class name that the object type should be equal to.
         #
         # ==== Example
-        #   # Serialize a preferences attribute
+        #
+        #   # Serialize a preferences attribute.
         #   class User < ActiveRecord::Base
         #     serialize :preferences
         #   end
-        def serialize(attr_name, class_name = Object)
-          coder = if [:load, :dump].all? { |x| class_name.respond_to?(x) }
-                    class_name
+        #
+        #   # Serialize preferences using JSON as coder.
+        #   class User < ActiveRecord::Base
+        #     serialize :preferences, JSON
+        #   end
+        #
+        #   # Serialize preferences as Hash using YAML coder.
+        #   class User < ActiveRecord::Base
+        #     serialize :preferences, Hash
+        #   end
+        def serialize(attr_name, class_name_or_coder = Object)
+          # 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.
+          coder = if class_name_or_coder == ::JSON
+                    Coders::JSON
+                  elsif [:load, :dump].all? { |x| class_name_or_coder.respond_to?(x) }
+                    class_name_or_coder
                   else
-                    Coders::YAMLColumn.new(class_name)
+                    Coders::YAMLColumn.new(class_name_or_coder)
                   end
 
-          # merge new serialized attribute and create new hash to ensure that each class in inheritance hierarchy
-          # has its own hash of own serialized attributes
-          self.serialized_attributes = serialized_attributes.merge(attr_name.to_s => coder)
-        end
-
-        def initialize_attributes(attributes, options = {}) #:nodoc:
-          serialized = (options.delete(:serialized) { true }) ? :serialized : :unserialized
-          super(attributes, options)
-
-          serialized_attributes.each do |key, coder|
-            if attributes.key?(key)
-              attributes[key] = Attribute.new(coder, attributes[key], serialized)
-            end
-          end
-
-          attributes
-        end
-
-        private
-
-        def attribute_cast_code(attr_name)
-          if serialized_attributes.include?(attr_name)
-            "v.unserialized_value"
-          else
-            super
-          end
-        end
-      end
-
-      def type_cast_attribute_for_write(column, value)
-        if column && coder = self.class.serialized_attributes[column.name]
-          Attribute.new(coder, value, :unserialized)
-        else
-          super
-        end
-      end
-
-      def _field_changed?(attr, old, value)
-        if self.class.serialized_attributes.include?(attr)
-          old != value
-        else
-          super
-        end
-      end
-
-      def read_attribute_before_type_cast(attr_name)
-        if serialized_attributes.include?(attr_name)
-          super.unserialized_value
-        else
-          super
-        end
-      end
-
-      def attributes_before_type_cast
-        super.dup.tap do |attributes|
-          self.class.serialized_attributes.each_key do |key|
-            if attributes.key?(key)
-              attributes[key] = attributes[key].unserialized_value
-            end
+          decorate_attribute_type(attr_name, :serialize) do |type|
+            Type::Serialized.new(type, coder)
           end
         end
       end

data/lib/active_record/attribute_methods/time_zone_conversion.rb

@@ -1,64 +1,115 @@
-require 'active_support/core_ext/class/attribute'
-require 'active_support/core_ext/object/inclusion'
+require 'active_support/core_ext/string/strip'
 
 module ActiveRecord
   module AttributeMethods
     module TimeZoneConversion
+      class TimeZoneConverter < DelegateClass(Type::Value) # :nodoc:
+        def deserialize(value)
+          convert_time_to_time_zone(super)
+        end
+
+        def cast(value)
+          return if value.nil?
+
+          if value.is_a?(Hash)
+            set_time_zone_without_conversion(super)
+          elsif value.respond_to?(:in_time_zone)
+            begin
+              super(user_input_in_time_zone(value)) || super
+            rescue ArgumentError
+              nil
+            end
+          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)
+            value
+          else
+            map_avoiding_infinite_recursion(value) { |v| convert_time_to_time_zone(v) }
+          end
+        end
+
+        def set_time_zone_without_conversion(value)
+          ::Time.zone.local_to_utc(value).in_time_zone
+        end
+
+        def map_avoiding_infinite_recursion(value)
+          map(value) do |v|
+            if value.equal?(v)
+              nil
+            else
+              yield(v)
+            end
+          end
+        end
+      end
+
       extend ActiveSupport::Concern
 
       included do
-        cattr_accessor :time_zone_aware_attributes, :instance_writer => false
+        mattr_accessor :time_zone_aware_attributes, instance_writer: false
         self.time_zone_aware_attributes = false
 
-        class_attribute :skip_time_zone_conversion_for_attributes, :instance_writer => false
+        class_attribute :skip_time_zone_conversion_for_attributes, instance_writer: false
         self.skip_time_zone_conversion_for_attributes = []
+
+        class_attribute :time_zone_aware_types, instance_writer: false
+        self.time_zone_aware_types = [:datetime, :not_explicitly_configured]
       end
 
       module ClassMethods
-        protected
-          # The enhanced read method automatically converts the UTC time stored in the database to the time
-          # zone stored in Time.zone.
-          def attribute_cast_code(attr_name)
-            column = columns_hash[attr_name]
-
-            if create_time_zone_conversion_attribute?(attr_name, column)
-              typecast             = "v = #{super}"
-              time_zone_conversion = "v.acts_like?(:time) ? v.in_time_zone : v"
+        private
 
-              "((#{typecast}) && (#{time_zone_conversion}))"
-            else
-              super
+        def inherited(subclass)
+          # 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
+          super
+        end
 
-          # Defined for all +datetime+ and +timestamp+ attributes when +time_zone_aware_attributes+ are enabled.
-          # This enhanced write method will automatically convert the time passed to it to the zone stored in Time.zone.
-          def define_method_attribute=(attr_name)
-            if create_time_zone_conversion_attribute?(attr_name, columns_hash[attr_name])
-              method_body, line = <<-EOV, __LINE__ + 1
-                def #{attr_name}=(original_time)
-                  original_time = nil if original_time.blank?
-                  time = original_time
-                  unless time.acts_like?(:time)
-                    time = time.is_a?(String) ? Time.zone.parse(time) : time.to_time rescue time
-                  end
-                  time = time.in_time_zone rescue nil if time
-                  previous_time = attribute_changed?("#{attr_name}") ? changed_attributes["#{attr_name}"] : read_attribute(:#{attr_name})
-                  write_attribute(:#{attr_name}, original_time)
-                  #{attr_name}_will_change! if previous_time != time
-                  @attributes_cache["#{attr_name}"] = time
-                end
-              EOV
-              generated_attribute_methods.module_eval(method_body, __FILE__, line)
-            else
-              super
-            end
-          end
+        def create_time_zone_conversion_attribute?(name, cast_type)
+          enabled_for_column = time_zone_aware_attributes &&
+            !self.skip_time_zone_conversion_for_attributes.include?(name.to_sym)
+          result = enabled_for_column &&
+            time_zone_aware_types.include?(cast_type.type)
 
-        private
-          def create_time_zone_conversion_attribute?(name, column)
-            time_zone_aware_attributes && !self.skip_time_zone_conversion_for_attributes.include?(name.to_sym) && column.type.in?([:datetime, :timestamp])
+          if enabled_for_column &&
+            !result &&
+            cast_type.type == :time &&
+            time_zone_aware_types.include?(:not_explicitly_configured)
+            ActiveSupport::Deprecation.warn(<<-MESSAGE.strip_heredoc)
+              Time columns will become time zone aware in Rails 5.1. This
+              still causes `String`s to be parsed as if they were in `Time.zone`,
+              and `Time`s to be converted to `Time.zone`.
+
+              To keep the old behavior, you must add the following to your initializer:
+
+                  config.active_record.time_zone_aware_types = [:datetime]
+
+              To silence this deprecation warning, add the following:
+
+                  config.active_record.time_zone_aware_types = [:datetime, :time]
+            MESSAGE
           end
+
+          result
+        end
       end
     end
   end

data/lib/active_record/attribute_methods/write.rb

@@ -9,62 +9,51 @@ module ActiveRecord
 
       module ClassMethods
         protected
-          def define_method_attribute=(attr_name)
-            if attr_name =~ ActiveModel::AttributeMethods::NAME_COMPILABLE_REGEXP
-              generated_attribute_methods.module_eval("def #{attr_name}=(new_value); write_attribute('#{attr_name}', new_value); end", __FILE__, __LINE__)
-            else
-              generated_attribute_methods.send(:define_method, "#{attr_name}=") do |new_value|
-                write_attribute(attr_name, new_value)
-              end
+
+        def define_method_attribute=(name)
+          safe_name = name.unpack('h*'.freeze).first
+          ActiveRecord::AttributeMethods::AttrNames.set_name_cache safe_name, name
+
+          generated_attribute_methods.module_eval <<-STR, __FILE__, __LINE__ + 1
+            def __temp__#{safe_name}=(value)
+              name = ::ActiveRecord::AttributeMethods::AttrNames::ATTR_#{safe_name}
+              write_attribute(name, value)
             end
-          end
+            alias_method #{(name + '=').inspect}, :__temp__#{safe_name}=
+            undef_method :__temp__#{safe_name}=
+          STR
+        end
       end
 
-      # Updates the attribute identified by <tt>attr_name</tt> with the specified +value+. Empty strings
-      # for fixnum and float columns are turned into +nil+.
+      # Updates the attribute identified by <tt>attr_name</tt> with the
+      # specified +value+. Empty strings for Integer and Float columns are
+      # turned into +nil+.
       def write_attribute(attr_name, value)
-        attr_name = attr_name.to_s
-        attr_name = self.class.primary_key if attr_name == 'id' && self.class.primary_key
-        @attributes_cache.delete(attr_name)
-        column = column_for_attribute(attr_name)
-
-        unless column || @attributes.has_key?(attr_name)
-          ActiveSupport::Deprecation.warn(
-            "You're trying to create an attribute `#{attr_name}'. Writing arbitrary " \
-            "attributes on a model is deprecated. Please just use `attr_writer` etc."
-          )
-        end
+        write_attribute_with_type_cast(attr_name, value, true)
+      end
 
-        @attributes[attr_name] = type_cast_attribute_for_write(column, value)
+      def raw_write_attribute(attr_name, value) # :nodoc:
+        write_attribute_with_type_cast(attr_name, value, false)
       end
-      alias_method :raw_write_attribute, :write_attribute
 
       private
-        # Handle *= for method_missing.
-        def attribute=(attribute_name, value)
-          write_attribute(attribute_name, value)
-        end
+      # Handle *= for method_missing.
+      def attribute=(attribute_name, value)
+        write_attribute(attribute_name, value)
+      end
 
-        def type_cast_attribute_for_write(column, value)
-          if column && column.number?
-            convert_number_column_value(value)
-          else
-            value
-          end
-        end
+      def write_attribute_with_type_cast(attr_name, value, should_type_cast)
+        attr_name = attr_name.to_s
+        attr_name = self.class.primary_key if attr_name == 'id' && self.class.primary_key
 
-        def convert_number_column_value(value)
-          case value
-          when FalseClass
-            0
-          when TrueClass
-            1
-          when String
-            value.presence
-          else
-            value
-          end
+        if should_type_cast
+          @attributes.write_from_user(attr_name, value)
+        else
+          @attributes.write_cast_value(attr_name, value)
         end
+
+        value
+      end
     end
   end
 end