active_model_serializers 0.8.3 → 0.10.0.rc1

Sign up to get free protection for your applications and to get access to all the features.
Files changed (77) hide show
  1. checksums.yaml +4 -4
  2. data/.gitignore +3 -0
  3. data/.travis.yml +19 -20
  4. data/CHANGELOG.md +8 -67
  5. data/CONTRIBUTING.md +31 -0
  6. data/Gemfile +14 -1
  7. data/{MIT-LICENSE.txt → LICENSE.txt} +3 -2
  8. data/README.md +166 -495
  9. data/Rakefile +6 -12
  10. data/active_model_serializers.gemspec +21 -19
  11. data/lib/action_controller/serialization.rb +28 -27
  12. data/lib/active_model/serializer/adapter/fragment_cache.rb +78 -0
  13. data/lib/active_model/serializer/adapter/json/fragment_cache.rb +15 -0
  14. data/lib/active_model/serializer/adapter/json.rb +52 -0
  15. data/lib/active_model/serializer/adapter/json_api/fragment_cache.rb +22 -0
  16. data/lib/active_model/serializer/adapter/json_api.rb +152 -0
  17. data/lib/active_model/serializer/adapter/null.rb +11 -0
  18. data/lib/active_model/serializer/adapter.rb +87 -0
  19. data/lib/active_model/serializer/array_serializer.rb +32 -0
  20. data/lib/active_model/serializer/configuration.rb +13 -0
  21. data/lib/active_model/serializer/fieldset.rb +40 -0
  22. data/lib/active_model/{serializers → serializer}/version.rb +1 -1
  23. data/lib/active_model/serializer.rb +179 -436
  24. data/lib/active_model_serializers.rb +9 -86
  25. data/lib/generators/serializer/USAGE +0 -3
  26. data/lib/generators/serializer/serializer_generator.rb +1 -6
  27. data/lib/generators/serializer/templates/serializer.rb +2 -13
  28. data/test/action_controller/adapter_selector_test.rb +51 -0
  29. data/test/action_controller/explicit_serializer_test.rb +110 -0
  30. data/test/action_controller/json_api_linked_test.rb +173 -0
  31. data/test/{serialization_scope_name_test.rb → action_controller/serialization_scope_name_test.rb} +7 -11
  32. data/test/action_controller/serialization_test.rb +365 -0
  33. data/test/adapter/fragment_cache_test.rb +27 -0
  34. data/test/adapter/json/belongs_to_test.rb +41 -0
  35. data/test/adapter/json/collection_test.rb +59 -0
  36. data/test/adapter/json/has_many_test.rb +36 -0
  37. data/test/adapter/json_api/belongs_to_test.rb +147 -0
  38. data/test/adapter/json_api/collection_test.rb +89 -0
  39. data/test/adapter/json_api/has_many_embed_ids_test.rb +45 -0
  40. data/test/adapter/json_api/has_many_explicit_serializer_test.rb +98 -0
  41. data/test/adapter/json_api/has_many_test.rb +106 -0
  42. data/test/adapter/json_api/has_one_test.rb +59 -0
  43. data/test/adapter/json_api/linked_test.rb +257 -0
  44. data/test/adapter/json_test.rb +34 -0
  45. data/test/adapter/null_test.rb +25 -0
  46. data/test/adapter_test.rb +43 -0
  47. data/test/array_serializer_test.rb +21 -67
  48. data/test/fixtures/poro.rb +206 -0
  49. data/test/serializers/adapter_for_test.rb +50 -0
  50. data/test/serializers/associations_test.rb +106 -0
  51. data/test/serializers/attribute_test.rb +23 -0
  52. data/test/serializers/attributes_test.rb +28 -0
  53. data/test/serializers/cache_test.rb +128 -0
  54. data/test/serializers/configuration_test.rb +15 -0
  55. data/test/serializers/fieldset_test.rb +26 -0
  56. data/test/{generators_test.rb → serializers/generators_test.rb} +1 -27
  57. data/test/serializers/meta_test.rb +78 -0
  58. data/test/serializers/options_test.rb +21 -0
  59. data/test/serializers/serializer_for_test.rb +56 -0
  60. data/test/serializers/urls_test.rb +26 -0
  61. data/test/test_helper.rb +22 -13
  62. metadata +101 -42
  63. data/DESIGN.textile +0 -586
  64. data/Gemfile.edge +0 -9
  65. data/bench/perf.rb +0 -43
  66. data/cruft.md +0 -19
  67. data/lib/active_model/array_serializer.rb +0 -104
  68. data/lib/active_model/serializer/associations.rb +0 -233
  69. data/lib/active_record/serializer_override.rb +0 -16
  70. data/lib/generators/resource_override.rb +0 -13
  71. data/test/association_test.rb +0 -592
  72. data/test/caching_test.rb +0 -96
  73. data/test/no_serialization_scope_test.rb +0 -34
  74. data/test/serialization_test.rb +0 -392
  75. data/test/serializer_support_test.rb +0 -51
  76. data/test/serializer_test.rb +0 -1465
  77. data/test/test_fakes.rb +0 -217
@@ -1,515 +1,258 @@
1
- require "active_support/core_ext/class/attribute"
2
- require "active_support/core_ext/module/anonymous"
3
- require 'active_support/dependencies'
4
- require 'active_support/descendants_tracker'
1
+ require 'thread_safe'
5
2
 
6
3
  module ActiveModel
7
- # Active Model Serializer
8
- #
9
- # Provides a basic serializer implementation that allows you to easily
10
- # control how a given object is going to be serialized. On initialization,
11
- # it expects two objects as arguments, a resource and options. For example,
12
- # one may do in a controller:
13
- #
14
- # PostSerializer.new(@post, :scope => current_user).to_json
15
- #
16
- # The object to be serialized is the +@post+ and the current user is passed
17
- # in for authorization purposes.
18
- #
19
- # We use the scope to check if a given attribute should be serialized or not.
20
- # For example, some attributes may only be returned if +current_user+ is the
21
- # author of the post:
22
- #
23
- # class PostSerializer < ActiveModel::Serializer
24
- # attributes :title, :body
25
- # has_many :comments
26
- #
27
- # private
28
- #
29
- # def attributes
30
- # hash = super
31
- # hash.merge!(:email => post.email) if author?
32
- # hash
33
- # end
34
- #
35
- # def author?
36
- # post.author == scope
37
- # end
38
- # end
39
- #
40
4
  class Serializer
41
- extend ActiveSupport::DescendantsTracker
5
+ extend ActiveSupport::Autoload
6
+ autoload :Configuration
7
+ autoload :ArraySerializer
8
+ autoload :Adapter
9
+ include Configuration
42
10
 
43
- INCLUDE_METHODS = {}
44
- INSTRUMENT = { :serialize => :"serialize.serializer", :associations => :"associations.serializer" }
11
+ class << self
12
+ attr_accessor :_attributes
13
+ attr_accessor :_attributes_keys
14
+ attr_accessor :_associations
15
+ attr_accessor :_urls
16
+ attr_accessor :_cache
17
+ attr_accessor :_fragmented
18
+ attr_accessor :_cache_key
19
+ attr_accessor :_cache_only
20
+ attr_accessor :_cache_except
21
+ attr_accessor :_cache_options
22
+ end
45
23
 
46
- class IncludeError < StandardError
47
- attr_reader :source, :association
24
+ def self.inherited(base)
25
+ base._attributes = []
26
+ base._attributes_keys = {}
27
+ base._associations = {}
28
+ base._urls = []
29
+ end
48
30
 
49
- def initialize(source, association)
50
- @source, @association = source, association
51
- end
31
+ def self.attributes(*attrs)
32
+ attrs = attrs.first if attrs.first.class == Array
33
+ @_attributes.concat attrs
52
34
 
53
- def to_s
54
- "Cannot serialize #{association} when #{source} does not have a root!"
35
+ attrs.each do |attr|
36
+ define_method attr do
37
+ object && object.read_attribute_for_serialization(attr)
38
+ end unless method_defined?(attr) || _fragmented.respond_to?(attr)
55
39
  end
56
40
  end
57
41
 
58
- class_attribute :_attributes
59
- self._attributes = {}
60
-
61
- class_attribute :_associations
62
- self._associations = {}
63
-
64
- class_attribute :_root
65
- class_attribute :_embed
66
- self._embed = :objects
67
- class_attribute :_root_embed
68
-
69
- class_attribute :cache
70
- class_attribute :perform_caching
42
+ def self.attribute(attr, options = {})
43
+ key = options.fetch(:key, attr)
44
+ @_attributes_keys[attr] = {key: key} if key != attr
45
+ @_attributes.concat [key]
46
+ define_method key do
47
+ object.read_attribute_for_serialization(attr)
48
+ end unless method_defined?(key) || _fragmented.respond_to?(attr)
49
+ end
71
50
 
72
- class << self
73
- # set perform caching like root
74
- def cached(value = true)
75
- self.perform_caching = value
76
- end
51
+ def self.fragmented(serializer)
52
+ @_fragmented = serializer
53
+ end
77
54
 
78
- # Define attributes to be used in the serialization.
79
- def attributes(*attrs)
55
+ # Enables a serializer to be automatically cached
56
+ def self.cache(options = {})
57
+ @_cache = ActionController::Base.cache_store if Rails.configuration.action_controller.perform_caching
58
+ @_cache_key = options.delete(:key)
59
+ @_cache_only = options.delete(:only)
60
+ @_cache_except = options.delete(:except)
61
+ @_cache_options = (options.empty?) ? nil : options
62
+ end
80
63
 
81
- self._attributes = _attributes.dup
64
+ # Defines an association in the object should be rendered.
65
+ #
66
+ # The serializer object should implement the association name
67
+ # as a method which should return an array when invoked. If a method
68
+ # with the association name does not exist, the association name is
69
+ # dispatched to the serialized object.
70
+ def self.has_many(*attrs)
71
+ associate(:has_many, attrs)
72
+ end
82
73
 
83
- attrs.each do |attr|
84
- if Hash === attr
85
- attr.each {|attr_real, key| attribute attr_real, :key => key }
86
- else
87
- attribute attr
88
- end
89
- end
90
- end
74
+ # Defines an association in the object that should be rendered.
75
+ #
76
+ # The serializer object should implement the association name
77
+ # as a method which should return an object when invoked. If a method
78
+ # with the association name does not exist, the association name is
79
+ # dispatched to the serialized object.
80
+ def self.belongs_to(*attrs)
81
+ associate(:belongs_to, attrs)
82
+ end
91
83
 
92
- def attribute(attr, options={})
93
- self._attributes = _attributes.merge(attr.is_a?(Hash) ? attr : {attr => options[:key] || attr.to_s.gsub(/\?$/, '').to_sym})
84
+ # Defines an association in the object should be rendered.
85
+ #
86
+ # The serializer object should implement the association name
87
+ # as a method which should return an object when invoked. If a method
88
+ # with the association name does not exist, the association name is
89
+ # dispatched to the serialized object.
90
+ def self.has_one(*attrs)
91
+ associate(:has_one, attrs)
92
+ end
94
93
 
95
- attr = attr.keys[0] if attr.is_a? Hash
94
+ def self.associate(type, attrs) #:nodoc:
95
+ options = attrs.extract_options!
96
+ self._associations = _associations.dup
96
97
 
98
+ attrs.each do |attr|
97
99
  unless method_defined?(attr)
98
100
  define_method attr do
99
- object.read_attribute_for_serialization(attr.to_sym)
101
+ object.send attr
100
102
  end
101
103
  end
102
104
 
103
- define_include_method attr
104
-
105
- # protect inheritance chains and open classes
106
- # if a serializer inherits from another OR
107
- # attributes are added later in a classes lifecycle
108
- # poison the cache
109
- define_method :_fast_attributes do
110
- raise NameError
111
- end
112
-
105
+ self._associations[attr] = {type: type, association_options: options}
113
106
  end
107
+ end
114
108
 
115
- def associate(klass, attrs) #:nodoc:
116
- options = attrs.extract_options!
117
- self._associations = _associations.dup
118
-
119
- attrs.each do |attr|
120
- unless method_defined?(attr)
121
- define_method attr do
122
- object.send attr
123
- end
124
- end
125
-
126
- define_include_method attr
127
-
128
- self._associations[attr] = klass.refine(attr, options)
129
- end
130
- end
131
-
132
- def define_include_method(name)
133
- method = "include_#{name}?".to_sym
134
-
135
- INCLUDE_METHODS[name] = method
136
-
137
- unless method_defined?(method)
138
- define_method method do
139
- true
140
- end
141
- end
142
- end
143
-
144
- # Defines an association in the object should be rendered.
145
- #
146
- # The serializer object should implement the association name
147
- # as a method which should return an array when invoked. If a method
148
- # with the association name does not exist, the association name is
149
- # dispatched to the serialized object.
150
- def has_many(*attrs)
151
- associate(Associations::HasMany, attrs)
152
- end
153
-
154
- # Defines an association in the object should be rendered.
155
- #
156
- # The serializer object should implement the association name
157
- # as a method which should return an object when invoked. If a method
158
- # with the association name does not exist, the association name is
159
- # dispatched to the serialized object.
160
- def has_one(*attrs)
161
- associate(Associations::HasOne, attrs)
162
- end
163
-
164
- # Return a schema hash for the current serializer. This information
165
- # can be used to generate clients for the serialized output.
166
- #
167
- # The schema hash has two keys: +attributes+ and +associations+.
168
- #
169
- # The +attributes+ hash looks like this:
170
- #
171
- # { :name => :string, :age => :integer }
172
- #
173
- # The +associations+ hash looks like this:
174
- # { :posts => { :has_many => :posts } }
175
- #
176
- # If :key is used:
177
- #
178
- # class PostsSerializer < ActiveModel::Serializer
179
- # has_many :posts, :key => :my_posts
180
- # end
181
- #
182
- # the hash looks like this:
183
- #
184
- # { :my_posts => { :has_many => :posts }
185
- #
186
- # This information is extracted from the serializer's model class,
187
- # which is provided by +SerializerClass.model_class+.
188
- #
189
- # The schema method uses the +columns_hash+ and +reflect_on_association+
190
- # methods, provided by default by ActiveRecord. You can implement these
191
- # methods on your custom models if you want the serializer's schema method
192
- # to work.
193
- #
194
- # TODO: This is currently coupled to Active Record. We need to
195
- # figure out a way to decouple those two.
196
- def schema
197
- klass = model_class
198
- columns = klass.columns_hash
199
-
200
- attrs = {}
201
- _attributes.each do |name, key|
202
- if column = columns[name.to_s]
203
- attrs[key] = column.type
204
- else
205
- # Computed attribute (method on serializer or model). We cannot
206
- # infer the type, so we put nil, unless specified in the attribute declaration
207
- if name != key
208
- attrs[name] = key
209
- else
210
- attrs[key] = nil
211
- end
212
- end
213
- end
214
-
215
- associations = {}
216
- _associations.each do |attr, association_class|
217
- association = association_class.new(attr, self)
218
-
219
- if model_association = klass.reflect_on_association(association.name)
220
- # Real association.
221
- associations[association.key] = { model_association.macro => model_association.name }
222
- else
223
- # Computed association. We could infer has_many vs. has_one from
224
- # the association class, but that would make it different from
225
- # real associations, which read has_one vs. belongs_to from the
226
- # model.
227
- associations[association.key] = nil
228
- end
229
- end
109
+ def self.url(attr)
110
+ @_urls.push attr
111
+ end
230
112
 
231
- { :attributes => attrs, :associations => associations }
232
- end
113
+ def self.urls(*attrs)
114
+ @_urls.concat attrs
115
+ end
233
116
 
234
- # The model class associated with this serializer.
235
- def model_class
236
- name.sub(/Serializer$/, '').constantize
117
+ def self.serializer_for(resource, options = {})
118
+ if resource.respond_to?(:to_ary)
119
+ config.array_serializer
120
+ else
121
+ options
122
+ .fetch(:association_options, {})
123
+ .fetch(:serializer, get_serializer_for(resource.class))
237
124
  end
125
+ end
238
126
 
239
- # Define how associations should be embedded.
240
- #
241
- # embed :objects # Embed associations as full objects
242
- # embed :ids # Embed only the association ids
243
- # embed :ids, :include => true # Embed the association ids and include objects in the root
244
- #
245
- def embed(type, options={})
246
- self._embed = type
247
- self._root_embed = true if options[:include]
127
+ def self.adapter
128
+ adapter_class = case config.adapter
129
+ when Symbol
130
+ ActiveModel::Serializer::Adapter.adapter_class(config.adapter)
131
+ when Class
132
+ config.adapter
248
133
  end
249
-
250
- # Defines the root used on serialization. If false, disables the root.
251
- def root(name)
252
- self._root = name
134
+ unless adapter_class
135
+ valid_adapters = Adapter.constants.map { |klass| ":#{klass.to_s.downcase}" }
136
+ raise ArgumentError, "Unknown adapter: #{config.adapter}. Valid adapters are: #{valid_adapters}"
253
137
  end
254
- alias_method :root=, :root
255
-
256
- # Used internally to create a new serializer object based on controller
257
- # settings and options for a given resource. These settings are typically
258
- # set during the request lifecycle or by the controller class, and should
259
- # not be manually defined for this method.
260
- def build_json(controller, resource, options)
261
- default_options = controller.send(:default_serializer_options) || {}
262
- options = default_options.merge(options || {})
263
-
264
- serializer = options.delete(:serializer) ||
265
- (resource.respond_to?(:active_model_serializer) &&
266
- resource.active_model_serializer)
267
-
268
- return serializer unless serializer
269
-
270
- if resource.respond_to?(:to_ary)
271
- unless serializer <= ActiveModel::ArraySerializer
272
- raise ArgumentError.new("#{serializer.name} is not an ArraySerializer. " +
273
- "You may want to use the :each_serializer option instead.")
274
- end
275
-
276
- if options[:root] != false && serializer.root != false
277
- # the serializer for an Array is ActiveModel::ArraySerializer
278
- options[:root] ||= serializer.root || controller.controller_name
279
- end
280
- end
281
138
 
282
- options[:scope] = controller.serialization_scope unless options.has_key?(:scope)
283
- options[:scope_name] = controller._serialization_scope
284
- options[:url_options] = controller.url_options
285
-
286
- serializer.new(resource, options)
287
- end
139
+ adapter_class
288
140
  end
289
141
 
290
- attr_reader :object, :options
291
-
292
- def initialize(object, options={})
293
- @object, @options = object, options
294
-
295
- scope_name = @options[:scope_name]
296
- if scope_name && !respond_to?(scope_name)
297
- self.class.class_eval do
298
- define_method scope_name, lambda { scope }
299
- end
300
- end
142
+ def self._root
143
+ @@root ||= false
301
144
  end
302
145
 
303
- def root_name
304
- return false if self._root == false
305
-
306
- class_name = self.class.name.demodulize.underscore.sub(/_serializer$/, '').to_sym unless self.class.name.blank?
307
-
308
- if self._root == true
309
- class_name
310
- else
311
- self._root || class_name
312
- end
146
+ def self._root=(root)
147
+ @@root = root
313
148
  end
314
149
 
315
- def url_options
316
- @options[:url_options] || {}
150
+ def self.root_name
151
+ name.demodulize.underscore.sub(/_serializer$/, '') if name
317
152
  end
318
153
 
319
- def meta_key
320
- @options[:meta_key].try(:to_sym) || :meta
321
- end
154
+ attr_accessor :object, :root, :meta, :meta_key, :scope
322
155
 
323
- def include_meta(hash)
324
- hash[meta_key] = @options[:meta] if @options.has_key?(:meta)
325
- end
156
+ def initialize(object, options = {})
157
+ @object = object
158
+ @options = options
159
+ @root = options[:root] || (self.class._root ? self.class.root_name : false)
160
+ @meta = options[:meta]
161
+ @meta_key = options[:meta_key]
162
+ @scope = options[:scope]
326
163
 
327
- def to_json(*args)
328
- if perform_caching?
329
- cache.fetch expand_cache_key([self.class.to_s.underscore, cache_key, 'to-json']) do
330
- super
164
+ scope_name = options[:scope_name]
165
+ if scope_name && !respond_to?(scope_name)
166
+ self.class.class_eval do
167
+ define_method scope_name, lambda { scope }
331
168
  end
332
- else
333
- super
334
169
  end
335
170
  end
336
171
 
337
- # Returns a json representation of the serializable
338
- # object including the root.
339
- def as_json(options={})
340
- options ||= {}
341
- if root = options.fetch(:root, @options.fetch(:root, root_name))
342
- @options[:hash] = hash = {}
343
- @options[:unique_values] = {}
344
-
345
- hash.merge!(root => serializable_hash)
346
- include_meta hash
347
- hash
172
+ def json_key
173
+ if root == true || root.nil?
174
+ self.class.root_name
348
175
  else
349
- serializable_hash
176
+ root
350
177
  end
351
178
  end
352
179
 
353
- # Returns a hash representation of the serializable
354
- # object without the root.
355
- def serializable_hash
356
- if perform_caching?
357
- cache.fetch expand_cache_key([self.class.to_s.underscore, cache_key, 'serializable-hash']) do
358
- _serializable_hash
359
- end
360
- else
361
- _serializable_hash
362
- end
180
+ def id
181
+ object.id if object
363
182
  end
364
183
 
365
- def include_associations!
366
- _associations.each_key do |name|
367
- include!(name) if include?(name)
368
- end
184
+ def type
185
+ object.class.to_s.demodulize.underscore.pluralize
369
186
  end
370
187
 
371
- def include?(name)
372
- return false if @options.key?(:only) && !Array(@options[:only]).include?(name)
373
- return false if @options.key?(:except) && Array(@options[:except]).include?(name)
374
- send INCLUDE_METHODS[name]
375
- end
376
-
377
- def include!(name, options={})
378
- # Make sure that if a special options[:hash] was passed in, we generate
379
- # a new unique values hash and don't clobber the original. If the hash
380
- # passed in is the same as the current options hash, use the current
381
- # unique values.
382
- #
383
- # TODO: Should passing in a Hash even be public API here?
384
- unique_values =
385
- if hash = options[:hash]
386
- if @options[:hash] == hash
387
- @options[:unique_values] ||= {}
388
- else
389
- {}
390
- end
188
+ def attributes(options = {})
189
+ attributes =
190
+ if options[:fields]
191
+ self.class._attributes & options[:fields]
391
192
  else
392
- hash = @options[:hash]
393
- @options[:unique_values] ||= {}
193
+ self.class._attributes.dup
394
194
  end
395
195
 
396
- node = options[:node] ||= @node
397
- value = options[:value]
196
+ attributes += options[:required_fields] if options[:required_fields]
398
197
 
399
- if options[:include] == nil
400
- if @options.key?(:include)
401
- options[:include] = @options[:include].include?(name)
402
- elsif @options.include?(:exclude)
403
- options[:include] = !@options[:exclude].include?(name)
404
- end
405
- end
406
-
407
- association_class =
408
- if klass = _associations[name]
409
- klass
410
- elsif value.respond_to?(:to_ary)
411
- Associations::HasMany
198
+ attributes.each_with_object({}) do |name, hash|
199
+ unless self.class._fragmented
200
+ hash[name] = send(name)
412
201
  else
413
- Associations::HasOne
414
- end
415
-
416
- association = association_class.new(name, self, options)
417
-
418
- if association.embed_ids?
419
- node[association.key] = association.serialize_ids
420
-
421
- if association.embed_in_root? && hash.nil?
422
- raise IncludeError.new(self.class, association.name)
423
- elsif association.embed_in_root? && association.embeddable?
424
- merge_association hash, association.root, association.serializables, unique_values
425
- end
426
- elsif association.embed_objects?
427
- node[association.key] = association.serialize
428
- end
429
- end
430
-
431
- # In some cases, an Array of associations is built by merging the associated
432
- # content for all of the children. For instance, if a Post has_many comments,
433
- # which has_many tags, the top-level :tags key will contain the merged list
434
- # of all tags for all comments of the post.
435
- #
436
- # In order to make this efficient, we store a :unique_values hash containing
437
- # a unique list of all of the objects that are already in the Array. This
438
- # avoids the need to scan through the Array looking for entries every time
439
- # we want to merge a new list of values.
440
- def merge_association(hash, key, serializables, unique_values)
441
- already_serialized = (unique_values[key] ||= {})
442
- serializable_hashes = (hash[key] ||= [])
443
-
444
- serializables.each do |serializable|
445
- unless already_serialized.include? serializable.object
446
- already_serialized[serializable.object] = true
447
- serializable_hashes << serializable.serializable_hash
202
+ hash[name] = self.class._fragmented.public_send(name)
448
203
  end
449
204
  end
450
205
  end
451
206
 
452
- # Returns a hash representation of the serializable
453
- # object attributes.
454
- def attributes
455
- _fast_attributes
456
- rescue NameError
457
- method = "def _fast_attributes\n"
207
+ def each_association(&block)
208
+ self.class._associations.dup.each do |name, association_options|
209
+ next unless object
210
+ association_value = send(name)
458
211
 
459
- method << " h = {}\n"
212
+ serializer_class = ActiveModel::Serializer.serializer_for(association_value, association_options)
460
213
 
461
- _attributes.each do |name,key|
462
- method << " h[:\"#{key}\"] = read_attribute_for_serialization(:\"#{name}\") if include?(:\"#{name}\")\n"
214
+ if serializer_class
215
+ serializer = serializer_class.new(
216
+ association_value,
217
+ options.merge(serializer_from_options(association_options))
218
+ )
219
+ elsif !association_value.nil? && !association_value.instance_of?(Object)
220
+ association_options[:association_options][:virtual_value] = association_value
463
221
  end
464
- method << " h\nend"
465
222
 
466
- self.class.class_eval method
467
- _fast_attributes
223
+ if block_given?
224
+ block.call(name, serializer, association_options[:association_options])
225
+ end
226
+ end
468
227
  end
469
228
 
470
- # Returns options[:scope]
471
- def scope
472
- @options[:scope]
229
+ def serializer_from_options(options)
230
+ opts = {}
231
+ serializer = options.fetch(:association_options, {}).fetch(:serializer, nil)
232
+ opts[:serializer] = serializer if serializer
233
+ opts
473
234
  end
474
235
 
475
- alias :read_attribute_for_serialization :send
476
-
477
- def _serializable_hash
478
- return nil if @object.nil?
479
- @node = attributes
480
- include_associations! if _embed
481
- @node
236
+ def self.serializers_cache
237
+ @serializers_cache ||= ThreadSafe::Cache.new
482
238
  end
483
239
 
484
- def perform_caching?
485
- perform_caching && cache && respond_to?(:cache_key)
486
- end
240
+ private
487
241
 
488
- def expand_cache_key(*args)
489
- ActiveSupport::Cache.expand_cache_key(args)
490
- end
242
+ attr_reader :options
491
243
 
492
- # Use ActiveSupport::Notifications to send events to external systems.
493
- # The event name is: name.class_name.serializer
494
- def instrument(name, payload = {}, &block)
495
- event_name = INSTRUMENT[name]
496
- ActiveSupport::Notifications.instrument(event_name, payload, &block)
497
- end
498
- end
499
-
500
- # DefaultSerializer
501
- #
502
- # Provides a constant interface for all items, particularly
503
- # for ArraySerializer.
504
- class DefaultSerializer
505
- attr_reader :object, :options
244
+ def self.get_serializer_for(klass)
245
+ serializers_cache.fetch_or_store(klass) do
246
+ serializer_class_name = "#{klass.name}Serializer"
247
+ serializer_class = serializer_class_name.safe_constantize
506
248
 
507
- def initialize(object, options={})
508
- @object, @options = object, options
249
+ if serializer_class
250
+ serializer_class
251
+ elsif klass.superclass
252
+ get_serializer_for(klass.superclass)
253
+ end
254
+ end
509
255
  end
510
256
 
511
- def serializable_hash
512
- @object.as_json(@options)
513
- end
514
257
  end
515
258
  end