Class: ViewModel
- Inherits:
-
Object
show all
- Defined in:
- lib/view_model.rb,
lib/view_model/migrator.rb,
lib/view_model/reference.rb,
lib/view_model/references.rb,
lib/view_model/deserialization_error.rb
Defined Under Namespace
Modules: AfterTransactionRunner, Callbacks, Controller, MigratableView, TestHelpers
Classes: AbstractError, AbstractErrorCollection, AbstractErrorWithBlame, AccessControl, AccessControlError, ActiveRecord, Changes, Config, DeserializationError, DeserializeContext, DownMigrator, Error, ErrorView, GarbageCollection, Metadata, Migration, Migrator, Record, Reference, References, Registry, Schemas, SerializationError, SerializeContext, TraversalContext, UpMigrator, Utils, WrappedExceptionError
Constant Summary
collapse
- REFERENCE_ATTRIBUTE =
'_ref'
- ID_ATTRIBUTE =
'id'
- TYPE_ATTRIBUTE =
'_type'
- VERSION_ATTRIBUTE =
'_version'
- NEW_ATTRIBUTE =
'_new'
- MIGRATED_ATTRIBUTE =
Migrations leave a metadata attribute _migrated on any views that they alter. This attribute is accessible as metadata when deserializing migrated input, and is included in the output serialization sent to clients.
'_migrated'
Class Attribute Summary collapse
Class Method Summary
collapse
-
.accepts_schema_version?(schema_version) ⇒ Boolean
-
.add_view_alias(as) ⇒ Object
-
.attribute(attr, **_args) ⇒ Object
-
.attributes(*attrs, **args) ⇒ Object
ViewModels are typically going to be pretty simple structures.
-
.deserialize_context_class ⇒ Object
-
.deserialize_from_view(hash_data, references: {}, deserialize_context: new_deserialize_context) ⇒ Object
Rebuild this viewmodel from a serialized hash.
-
.deserialize_members_from_view(viewmodel, view_hash, references:, deserialize_context:) ⇒ Object
-
.eager_includes(serialize_context: new_serialize_context, include_referenced: true) ⇒ Object
If this viewmodel represents an AR model, what associations does it make use of? Returns a includes spec appropriate for DeepPreloader, either as AR-style nested hashes or DeepPreloader::Spec.
-
.encode_json(value) ⇒ Object
-
.extract_reference_metadata(hash) ⇒ Object
-
.extract_reference_only_metadata(hash) ⇒ Object
-
.extract_viewmodel_metadata(hash) ⇒ Object
In deserialization, verify and extract metadata from a provided hash.
-
.inherited(subclass) ⇒ Object
-
.initialize_as_viewmodel ⇒ Object
-
.is_update_hash?(hash) ⇒ Boolean
rubocop:disable Naming/PredicateName.
-
.lock_attribute_inheritance ⇒ Object
An abstract viewmodel may want to define attributes to be shared by their subclasses.
-
.member_names ⇒ Object
-
.new_deserialize_context(*args) ⇒ Object
-
.new_serialize_context(*args) ⇒ Object
-
.preload_for_serialization(viewmodels, serialize_context: new_serialize_context, include_referenced: true, lock: nil) ⇒ Object
-
.root! ⇒ Object
-
.root? ⇒ Boolean
ViewModels are either roots or children.
-
.schema_hash(schema_versions) ⇒ Object
-
.schema_versions(viewmodels) ⇒ Object
-
.serialize(target, json, serialize_context: new_serialize_context) ⇒ Object
ViewModel can serialize ViewModels, Arrays and Hashes of ViewModels, and relies on Jbuilder#merge! for other values (e.g. primitives).
-
.serialize_as_reference(target, json, serialize_context: new_serialize_context) ⇒ Object
-
.serialize_context_class ⇒ Object
-
.serialize_to_hash(viewmodel, serialize_context: new_serialize_context) ⇒ Object
Instance Method Summary
collapse
Constructor Details
#initialize(*args) ⇒ ViewModel
Returns a new instance of ViewModel.
268
269
270
271
272
|
# File 'lib/view_model.rb', line 268
def initialize(*args)
self.class._attributes.each_with_index do |attr, idx|
self.public_send(:"#{attr}=", args[idx])
end
end
|
Class Attribute Details
._attributes ⇒ Object
Returns the value of attribute _attributes.
25
26
27
|
# File 'lib/view_model.rb', line 25
def _attributes
@_attributes
end
|
.schema_version ⇒ Object
Returns the value of attribute schema_version.
26
27
28
|
# File 'lib/view_model.rb', line 26
def schema_version
@schema_version
end
|
.view_aliases ⇒ Object
Returns the value of attribute view_aliases.
27
28
29
|
# File 'lib/view_model.rb', line 27
def view_aliases
@view_aliases
end
|
.view_name ⇒ Object
41
42
43
44
45
46
47
48
49
50
|
# File 'lib/view_model.rb', line 41
def view_name
@view_name ||=
begin
match = /(.*)View$/.match(self.name)
raise ArgumentError.new("Could not auto-determine ViewModel name from class name '#{self.name}'") if match.nil?
ViewModel::Registry.default_view_name(match[1])
end
end
|
Class Method Details
.accepts_schema_version?(schema_version) ⇒ Boolean
242
243
244
|
# File 'lib/view_model.rb', line 242
def accepts_schema_version?(schema_version)
schema_version == self.schema_version
end
|
.add_view_alias(as) ⇒ Object
52
53
54
55
|
# File 'lib/view_model.rb', line 52
def add_view_alias(as)
view_aliases << as
ViewModel::Registry.register(self, as: as)
end
|
.attribute(attr, **_args) ⇒ Object
76
77
78
79
80
81
82
83
84
85
86
87
|
# File 'lib/view_model.rb', line 76
def attribute(attr, **_args)
unless attr.is_a?(Symbol)
raise ArgumentError.new('ViewModel attributes must be symbols')
end
attr_accessor attr
define_method("deserialize_#{attr}") do |value, references: {}, deserialize_context: self.class.new_deserialize_context|
self.public_send("#{attr}=", value)
end
_attributes << attr
end
|
.attributes(*attrs, **args) ⇒ Object
ViewModels are typically going to be pretty simple structures. Make it a bit easier to define them: attributes specified this way are given accessors and assigned in order by the default constructor.
72
73
74
|
# File 'lib/view_model.rb', line 72
def attributes(*attrs, **args)
attrs.each { |attr| attribute(attr, **args) }
end
|
.deserialize_context_class ⇒ Object
.deserialize_from_view(hash_data, references: {}, deserialize_context: new_deserialize_context) ⇒ Object
Rebuild this viewmodel from a serialized hash.
188
189
190
191
192
|
# File 'lib/view_model.rb', line 188
def deserialize_from_view(hash_data, references: {}, deserialize_context: new_deserialize_context)
viewmodel = self.new
deserialize_members_from_view(viewmodel, hash_data, references: references, deserialize_context: deserialize_context)
viewmodel
end
|
.deserialize_members_from_view(viewmodel, view_hash, references:, deserialize_context:) ⇒ Object
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
|
# File 'lib/view_model.rb', line 194
def deserialize_members_from_view(viewmodel, view_hash, references:, deserialize_context:)
ViewModel::Callbacks.wrap_deserialize(viewmodel, deserialize_context: deserialize_context) do |hook_control|
if (bad_attrs = view_hash.keys - member_names).present?
causes = bad_attrs.map do |bad_attr|
ViewModel::DeserializationError::UnknownAttribute.new(bad_attr, viewmodel.blame_reference)
end
raise ViewModel::DeserializationError::Collection.for_errors(causes)
end
member_names.each do |attr|
next unless view_hash.has_key?(attr)
viewmodel.public_send("deserialize_#{attr}",
view_hash[attr],
references: references,
deserialize_context: deserialize_context)
end
deserialize_context.run_callback(ViewModel::Callbacks::Hook::BeforeValidate, viewmodel)
viewmodel.validate!
if block_given?
yield(hook_control)
else
hook_control.record_changes(Changes.new)
end
end
end
|
.eager_includes(serialize_context: new_serialize_context, include_referenced: true) ⇒ Object
If this viewmodel represents an AR model, what associations does it make use of? Returns a includes spec appropriate for DeepPreloader, either as AR-style nested hashes or DeepPreloader::Spec.
137
138
139
|
# File 'lib/view_model.rb', line 137
def eager_includes(serialize_context: new_serialize_context, include_referenced: true)
{}
end
|
.encode_json(value) ⇒ Object
176
177
178
179
180
181
182
183
184
185
|
# File 'lib/view_model.rb', line 176
def encode_json(value)
Oj.dump(value, mode: :compat, time_format: :ruby, use_to_json: true)
end
|
In deserialization, verify and extract metadata from a provided hash.
.inherited(subclass) ⇒ Object
30
31
32
33
|
# File 'lib/view_model.rb', line 30
def inherited(subclass)
super
subclass.initialize_as_viewmodel
end
|
.initialize_as_viewmodel ⇒ Object
35
36
37
38
39
|
# File 'lib/view_model.rb', line 35
def initialize_as_viewmodel
@_attributes = []
@schema_version = 1
@view_aliases = []
end
|
.is_update_hash?(hash) ⇒ Boolean
rubocop:disable Naming/PredicateName
.lock_attribute_inheritance ⇒ Object
An abstract viewmodel may want to define attributes to be shared by their subclasses. Redefine ‘_attributes` to close over the current class’s _attributes and ignore children.
92
93
94
95
96
97
|
# File 'lib/view_model.rb', line 92
def lock_attribute_inheritance
_attributes.tap do |attrs|
define_singleton_method(:_attributes) { attrs }
attrs.freeze
end
end
|
.member_names ⇒ Object
99
100
101
|
# File 'lib/view_model.rb', line 99
def member_names
_attributes.map(&:to_s)
end
|
.new_deserialize_context(*args) ⇒ Object
238
239
240
|
# File 'lib/view_model.rb', line 238
def new_deserialize_context(*args)
deserialize_context_class.new(*args)
end
|
.new_serialize_context(*args) ⇒ Object
230
231
232
|
# File 'lib/view_model.rb', line 230
def new_serialize_context(*args)
serialize_context_class.new(*args)
end
|
.preload_for_serialization(viewmodels, serialize_context: new_serialize_context, include_referenced: true, lock: nil) ⇒ Object
259
260
261
262
263
264
265
|
# File 'lib/view_model.rb', line 259
def preload_for_serialization(viewmodels, serialize_context: new_serialize_context, include_referenced: true, lock: nil)
Array.wrap(viewmodels).group_by(&:class).each do |type, views|
DeepPreloader.preload(views.map(&:model),
type.eager_includes(serialize_context: serialize_context, include_referenced: include_referenced),
lock: lock)
end
end
|
.root! ⇒ Object
65
66
67
|
# File 'lib/view_model.rb', line 65
def root!
define_singleton_method(:root?) { true }
end
|
.root? ⇒ Boolean
ViewModels are either roots or children. Root viewmodels may be (de)serialized directly, whereas child viewmodels are always nested within their parent. Associations to root viewmodel types always use indirect references.
61
62
63
|
# File 'lib/view_model.rb', line 61
def root?
false
end
|
.schema_hash(schema_versions) ⇒ Object
252
253
254
255
256
257
|
# File 'lib/view_model.rb', line 252
def schema_hash(schema_versions)
version_string = schema_versions.to_a.sort.join(',')
hash = Digest::SHA256.digest(version_string).byteslice(0, 16)
Base64.urlsafe_encode64(hash, padding: false)
end
|
.schema_versions(viewmodels) ⇒ Object
246
247
248
249
250
|
# File 'lib/view_model.rb', line 246
def schema_versions(viewmodels)
viewmodels.each_with_object({}) do |view, h|
h[view.view_name] = view.schema_version
end
end
|
.serialize(target, json, serialize_context: new_serialize_context) ⇒ Object
ViewModel can serialize ViewModels, Arrays and Hashes of ViewModels, and relies on Jbuilder#merge! for other values (e.g. primitives).
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
|
# File 'lib/view_model.rb', line 143
def serialize(target, json, serialize_context: new_serialize_context)
case target
when ViewModel
target.serialize(json, serialize_context: serialize_context)
when Array
json.array! target do |elt|
serialize(elt, json, serialize_context: serialize_context)
end
when Hash, Struct
json.merge!({})
target.each_pair do |key, value|
json.set! key do
serialize(value, json, serialize_context: serialize_context)
end
end
else
json.merge! target
end
end
|
.serialize_as_reference(target, json, serialize_context: new_serialize_context) ⇒ Object
163
164
165
166
167
168
169
170
|
# File 'lib/view_model.rb', line 163
def serialize_as_reference(target, json, serialize_context: new_serialize_context)
if serialize_context.flatten_references
serialize(target, json, serialize_context: serialize_context)
else
ref = serialize_context.add_reference(target)
json.set!(REFERENCE_ATTRIBUTE, ref)
end
end
|
.serialize_context_class ⇒ Object
.serialize_to_hash(viewmodel, serialize_context: new_serialize_context) ⇒ Object
172
173
174
|
# File 'lib/view_model.rb', line 172
def serialize_to_hash(viewmodel, serialize_context: new_serialize_context)
Jbuilder.new { |json| serialize(viewmodel, json, serialize_context: serialize_context) }.attributes!
end
|
Instance Method Details
#==(other) ⇒ Object
Also known as:
eql?
350
351
352
353
354
|
# File 'lib/view_model.rb', line 350
def ==(other)
other.class == self.class && self.class._attributes.all? do |attr|
other.send(attr) == self.send(attr)
end
end
|
#blame_reference ⇒ Object
When deserializing, if an error occurs within this viewmodel, what viewmodel is reported as to blame. Can be overridden for example when a viewmodel is merged with its parent.
338
339
340
|
# File 'lib/view_model.rb', line 338
def blame_reference
to_reference
end
|
#context_for_child(member_name, context:) ⇒ Object
342
343
344
|
# File 'lib/view_model.rb', line 342
def context_for_child(member_name, context:)
context.for_child(self, association_name: member_name)
end
|
#hash ⇒ Object
358
359
360
361
362
|
# File 'lib/view_model.rb', line 358
def hash
features = self.class._attributes.map { |attr| self.send(attr) }
features << self.class
features.hash
end
|
#id ⇒ Object
Provide a stable way to identify this view through attribute changes. By default views cannot make assumptions about the identity of our attributes, so we fall back on the view’s ‘object_id`. If a viewmodel is backed by a model with a concept of identity, this method should be overridden to use it.
312
313
314
|
# File 'lib/view_model.rb', line 312
def id
object_id
end
|
#model ⇒ Object
ViewModels are often used to serialize ActiveRecord models. For convenience, if necessary we assume that the wrapped model is the first attribute. To change this, override this method.
303
304
305
|
# File 'lib/view_model.rb', line 303
def model
self.public_send(self.class._attributes.first)
end
|
#preload_for_serialization(lock: nil, serialize_context: self.class.new_serialize_context) ⇒ Object
346
347
348
|
# File 'lib/view_model.rb', line 346
def preload_for_serialization(lock: nil, serialize_context: self.class.new_serialize_context)
ViewModel.preload_for_serialization([self], lock: lock, serialize_context: serialize_context)
end
|
#serialize(json, serialize_context: self.class.new_serialize_context) ⇒ Object
Serialize this viewmodel to a jBuilder by calling serialize_view. May be overridden in subclasses to (for example) implement caching.
276
277
278
279
280
|
# File 'lib/view_model.rb', line 276
def serialize(json, serialize_context: self.class.new_serialize_context)
ViewModel::Callbacks.wrap_serialize(self, context: serialize_context) do
serialize_view(json, serialize_context: serialize_context)
end
end
|
#serialize_view(json, serialize_context: self.class.new_serialize_context) ⇒ Object
Render this viewmodel to a jBuilder. Usually overridden in subclasses. Default implementation visits each attribute with Viewmodel.serialize.
292
293
294
295
296
297
298
|
# File 'lib/view_model.rb', line 292
def serialize_view(json, serialize_context: self.class.new_serialize_context)
self.class._attributes.each do |attr|
json.set! attr do
ViewModel.serialize(self.send(attr), json, serialize_context: serialize_context)
end
end
end
|
#stable_id? ⇒ Boolean
Is this viewmodel backed by a model with a stable identity? Used to decide whether the id is included when constructing a ViewModel::Reference from this view.
319
320
321
|
# File 'lib/view_model.rb', line 319
def stable_id?
false
end
|
#to_hash(serialize_context: self.class.new_serialize_context) ⇒ Object
282
283
284
|
# File 'lib/view_model.rb', line 282
def to_hash(serialize_context: self.class.new_serialize_context)
Jbuilder.new { |json| serialize(json, serialize_context: serialize_context) }.attributes!
end
|
#to_json(serialize_context: self.class.new_serialize_context) ⇒ Object
286
287
288
|
# File 'lib/view_model.rb', line 286
def to_json(serialize_context: self.class.new_serialize_context)
ViewModel.encode_json(self.to_hash(serialize_context: serialize_context))
end
|
#to_reference ⇒ Object
325
326
327
|
# File 'lib/view_model.rb', line 325
def to_reference
ViewModel::Reference.new(self.class, (id if stable_id?))
end
|
#validate! ⇒ Object
323
|
# File 'lib/view_model.rb', line 323
def validate!; end
|
#view_name ⇒ Object
Delegate view_name to class in most cases. Polymorphic views may wish to override this to select a specific alias.
331
332
333
|
# File 'lib/view_model.rb', line 331
def view_name
self.class.view_name
end
|