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
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
|
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, instance_accessor: false
self.serialized_attributes = {}
end
module ClassMethods
##
# :method: serialized_attributes
#
# Returns a hash of all the attributes that have been specified for
# serialization as keys and their class restriction as values.
# 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
# <tt>SerializationTypeMismatch</tt> will be raised.
#
# A notable side effect of serialized attributes is that the model will
# be updated on every save, even if it is not dirty.
#
# ==== 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)
include Behavior
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
end
class Type # :nodoc:
def initialize(column)
@column = column
end
def type_cast(value)
if value.state == :serialized
value.unserialized_value @column.type_cast value.value
else
value.unserialized_value
end
end
def type
@column.type
end
def accessor
ActiveRecord::Store::IndifferentHashAccessor
end
end
class Attribute < Struct.new(:coder, :value, :state) # :nodoc:
def unserialized_value(v = value)
state == :serialized ? unserialize(v) : value
end
def serialized_value
state == :unserialized ? serialize : value
end
def unserialize(v)
self.state = :unserialized
self.value = coder.load(v)
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
module ClassMethods # :nodoc:
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)
end
end
attributes
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 self.class.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
def typecasted_attribute_value(name)
if self.class.serialized_attributes.include?(name)
@attributes[name].serialized_value
else
super
end
end
end
end
end
end
|
