Class: ViewModel

Inherits:
Object
  • 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

Direct Known Subclasses

ErrorView::ExceptionDetailView, Record

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

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 (readonly)

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
      # try to auto-detect based on class name
      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

Returns:

  • (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 



234
235
236
 
# File 'lib/view_model.rb', line 234

def deserialize_context_class
  ViewModel::DeserializeContext
end

.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!

    # More complex viewmodels can use this hook to track changes to
    # persistent backing models, and record the results. Primitive
    # viewmodels record no changes.
    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)
  # Jbuilder#encode no longer uses MultiJson, but instead calls `.to_json`. In
  # the context of ActiveSupport, we don't want this, because AS replaces the
  # .to_json interface with its own .as_json, which demands that everything is
  # reduced to a Hash before it can be JSON encoded. Using this is not only
  # slightly more expensive in terms of allocations, but also defeats the
  # purpose of our precompiled `CompiledJson` terminals. Instead serialize
  # using OJ with options equivalent to those used by MultiJson.
  Oj.dump(value, mode: :compat, time_format: :ruby, use_to_json: true)
end

.extract_reference_metadata(hash) ⇒ Object 



123
124
125
126
 
# File 'lib/view_model.rb', line 123

def extract_reference_metadata(hash)
  ViewModel::Schemas.verify_schema!(ViewModel::Schemas::VIEWMODEL_REFERENCE, hash)
  hash.delete(ViewModel::REFERENCE_ATTRIBUTE)
end

.extract_reference_only_metadata(hash) ⇒ Object 



115
116
117
118
119
120
121
 
# File 'lib/view_model.rb', line 115

def extract_reference_only_metadata(hash)
  ViewModel::Schemas.verify_schema!(ViewModel::Schemas::VIEWMODEL_UPDATE, hash)
  id             = hash.delete(ViewModel::ID_ATTRIBUTE)
  type_name      = hash.delete(ViewModel::TYPE_ATTRIBUTE)

  Metadata.new(id, type_name, nil, false, false)
end

.extract_viewmodel_metadata(hash) ⇒ Object

In deserialization, verify and extract metadata from a provided hash.



104
105
106
107
108
109
110
111
112
113
 
# File 'lib/view_model.rb', line 104

def extract_viewmodel_metadata(hash)
  ViewModel::Schemas.verify_schema!(ViewModel::Schemas::VIEWMODEL_UPDATE, hash)
  id             = hash.delete(ViewModel::ID_ATTRIBUTE)
  type_name      = hash.delete(ViewModel::TYPE_ATTRIBUTE)
  schema_version = hash.delete(ViewModel::VERSION_ATTRIBUTE)
  new            = hash.delete(ViewModel::NEW_ATTRIBUTE) { false }
  migrated       = hash.delete(ViewModel::MIGRATED_ATTRIBUTE) { false }

  Metadata.new(id, type_name, schema_version, new, migrated)
end

.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

Returns:

  • (Boolean) 


128
129
130
131
132
 
# File 'lib/view_model.rb', line 128

def is_update_hash?(hash) # rubocop:disable Naming/PredicateName
  ViewModel::Schemas.verify_schema!(ViewModel::Schemas::VIEWMODEL_UPDATE, hash)
  hash.has_key?(ViewModel::ID_ATTRIBUTE) &&
    !hash.fetch(ViewModel::ActiveRecord::NEW_ATTRIBUTE, false)
end

.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.

Returns:

  • (Boolean) 


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(',')
  # We want a short hash value, as this will be used in cache keys
  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 



226
227
228
 
# File 'lib/view_model.rb', line 226

def serialize_context_class
  ViewModel::SerializeContext
end

.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.

Returns:

  • (Boolean) 


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