Skip to content
This repository
tree: c7ef6b62c0
Fetching contributors…

Cannot retrieve contributors at this time

file 112 lines (97 sloc) 3.616 kb
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112
module ActiveRecord
  module AttributeMethods
    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.
        #
        # ==== Parameters
        #
        # * +attr_name+ - The field name that should be serialized.
        # * +class_name+ - Optional, class name that the object type should be equal to.
        #
        # ==== Example
        # # 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
                  else
                    Coders::YAMLColumn.new(class_name)
                  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 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
          end
        end
      end
    end
  end
end
Something went wrong with that request. Please try again.