1 files changed, 76 insertions, 46 deletions

diff --git a/activerecord/lib/active_record/attribute_methods/serialization.rb b/activerecord/lib/active_record/attribute_methods/serialization.rb
index 7efef73472..bdda5bc009 100644
--- a/activerecord/lib/active_record/attribute_methods/serialization.rb
+++ b/activerecord/lib/active_record/attribute_methods/serialization.rb
@@ -6,30 +6,10 @@ module ActiveRecord
       included do
         # Returns a hash of all the attributes that have been specified for serialization as
         # keys and their class restriction as values.
-        config_attribute :serialized_attributes
+        class_attribute :serialized_attributes, instance_accessor: false
         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.
@@ -47,6 +27,8 @@ module ActiveRecord
         #     serialize :preferences
         #   end
         def serialize(attr_name, class_name = Object)
+          include Behavior
+
           coder = if [:load, :dump].all? { |x| class_name.respond_to?(x) }
                     class_name
                   else
@@ -57,43 +39,91 @@ module ActiveRecord
           # has its own hash of own serialized attributes
           self.serialized_attributes = serialized_attributes.merge(attr_name.to_s => coder)
         end
+      end
+
+      def serialized_attributes
+        ActiveSupport::Deprecation.warn("Instance level serialized_attributes method is deprecated, please use class level method.")
+        defined?(@serialized_attributes) ? @serialized_attributes : self.class.serialized_attributes
+      end
+
+      class Type # :nodoc:
+        def initialize(column)
+          @column = column
+        end
+
+        def type_cast(value)
+          value.unserialized_value
+        end
+
+        def type
+          @column.type
+        end
+      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
+
+      # This is only added to the model when serialize is called, which
+      # ensures we do not make things slower when serialization is not used.
+      module Behavior #:nodoc:
+        extend ActiveSupport::Concern
 
-        def initialize_attributes(attributes) #:nodoc:
-          super
+        module ClassMethods
+          def initialize_attributes(attributes, options = {})
+            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)
+            serialized_attributes.each do |key, coder|
+              if attributes.key?(key)
+                attributes[key] = Attribute.new(coder, attributes[key], serialized)
+              end
             end
+
+            attributes
           end
 
-          attributes
-        end
+          private
 
-        private
+          def attribute_cast_code(attr_name)
+            if serialized_attributes.include?(attr_name)
+              "v.unserialized_value"
+            else
+              super
+            end
+          end
+        end
 
-        def attribute_cast_code(attr_name)
-          if serialized_attributes.include?(attr_name)
-            "v.unserialized_value"
+        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
-      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 read_attribute_before_type_cast(attr_name)
-        if serialized_attributes.include?(attr_name)
-          super.unserialized_value
-        else
-          super
+        def read_attribute_before_type_cast(attr_name)
+          if self.class.serialized_attributes.include?(attr_name)
+            super.unserialized_value
+          else
+            super
+          end
         end
       end
     end