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
|
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
# 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.
#
# ==== 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
def serialized_attributes
message = "Instance level serialized_attributes method is deprecated, please use class level method."
ActiveSupport::Deprecation.warn message
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) # :nodoc:
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
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)
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
|