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
113
114
115
116
117
118
119
120
121
122
123
|
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.
config_attribute :serialized_attributes
self.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
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) #:nodoc:
super
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
def instance_cast_method(attr_name)
if serialized_attributes.include?(attr_name)
"cast_serialized"
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
end
end
end
|
