Class: ViewModel::ActiveRecord

Inherits:
Record show all
Includes:
AssociationManipulation
Defined in:
lib/view_model/active_record/update_context.rb,
lib/view_model/active_record.rb,
lib/view_model/active_record/update_data.rb,
lib/view_model/active_record/update_operation.rb

Overview

Partially parsed tree of user-specified update hashes, created during deserialization.

Defined Under Namespace

Modules: AssociationManipulation, CollectionNestedController, Controller, ControllerBase, NestedControllerBase, SingularNestedController Classes: AbstractCollectionUpdate, AssociationData, Cache, Cloner, FunctionalUpdate, OwnedCollectionUpdate, ReferencedCollectionUpdate, UpdateContext, UpdateData, UpdateOperation, Visitor

Constant Summary collapse

FUNCTIONAL_UPDATE_TYPE =

for functional updates

'_update'
ACTIONS_ATTRIBUTE = 
'actions'
VALUES_ATTRIBUTE = 
'values'
BEFORE_ATTRIBUTE = 
'before'
AFTER_ATTRIBUTE = 
'after'

Constants inherited from ViewModel

ID_ATTRIBUTE, MIGRATED_ATTRIBUTE, NEW_ATTRIBUTE, REFERENCE_ATTRIBUTE, TYPE_ATTRIBUTE, VERSION_ATTRIBUTE

Class Attribute Summary collapse

Instance Attribute Summary collapse

Attributes inherited from Record

#changed_attributes, #model, #previous_changes

Class Method Summary collapse

Instance Method Summary collapse

Methods included from AssociationManipulation

#append_associated, #delete_associated, #load_associated, #replace_associated

Methods inherited from Record

#==, attribute, #attribute_changed!, #changed_nested_children?, #changed_referenced_children?, deserialize_members_from_view, for_new_model, #hash, #id, inherited, initialize_as_viewmodel_record, member_names, model_class, #model_is_new!, #nested_children_changed!, #new_model?, #referenced_children_changed!, resolve_viewmodel, #serialize_view, #stable_id?, #validate!

Methods inherited from ViewModel

#==, accepts_schema_version?, add_view_alias, attribute, attributes, #blame_reference, deserialize_context_class, deserialize_members_from_view, encode_json, extract_reference_metadata, extract_reference_only_metadata, extract_viewmodel_metadata, #hash, #id, inherited, initialize_as_viewmodel, is_update_hash?, lock_attribute_inheritance, member_names, #model, new_deserialize_context, new_serialize_context, preload_for_serialization, #preload_for_serialization, root!, root?, schema_hash, schema_versions, #serialize, serialize, serialize_as_reference, serialize_context_class, serialize_to_hash, #serialize_view, #stable_id?, #to_hash, #to_json, #to_reference, #validate!, #view_name

Constructor Details

#initialize ⇒ ActiveRecord

Returns a new instance of ActiveRecord.



272
273
274
275
276
 
# File 'lib/view_model/active_record.rb', line 272

def initialize(*)
  super
  model_is_new! if model.new_record?
  @changed_associations = []
end

Class Attribute Details

._list_attribute_name ⇒ Object (readonly)

Returns the value of attribute _list_attribute_name.



37
38
39
 
# File 'lib/view_model/active_record.rb', line 37

def _list_attribute_name
  @_list_attribute_name
end

.synthetic ⇒ Object

Returns the value of attribute synthetic.



38
39
40
 
# File 'lib/view_model/active_record.rb', line 38

def synthetic
  @synthetic
end

Instance Attribute Details

#changed_associations ⇒ Object (readonly)

Returns the value of attribute changed_associations.



34
35
36
 
# File 'lib/view_model/active_record.rb', line 34

def changed_associations
  @changed_associations
end

Class Method Details

._association_data(association_name) ⇒ Object

internal

Raises:

  • (ArgumentError) 


264
265
266
267
268
269
 
# File 'lib/view_model/active_record.rb', line 264

def _association_data(association_name)
  association_data = self._members[association_name.to_s]
  raise ArgumentError.new("Invalid association '#{association_name}'") unless association_data.is_a?(AssociationData)

  association_data
end

._list_member? ⇒ Boolean

Returns:

  • (Boolean) 


62
63
64
 
# File 'lib/view_model/active_record.rb', line 62

def _list_member?
  _list_attribute_name.present?
end

.acts_as_list(attr = :position) ⇒ Object

Specifies that the model backing this viewmodel is a member of an ‘acts_as_manual_list` collection.



48
49
50
51
52
53
54
55
56
57
58
59
60
 
# File 'lib/view_model/active_record.rb', line 48

def acts_as_list(attr = :position)
  @_list_attribute_name = attr

  @generated_accessor_module.module_eval do
    define_method('_list_attribute') do
      model.public_send(attr)
    end

    define_method('_list_attribute=') do |x|
      model.public_send(:"#{attr}=", x)
    end
  end
end

.association(association_name, as: nil, viewmodel: nil, viewmodels: nil, external: false, read_only: false, through: nil, through_order_attr: nil) ⇒ Object

Adds an association from the model to this viewmodel. The associated model will be recursively (de)serialized by its own viewmodel type, which will be inferred from the model name, or may be explicitly specified.

An association to a root viewmodel type will be serialized with an indirect reference, while a child viewmodel type will be directly nested.

  • as sets the name of the association in the viewmodel

  • viewmodel, viewmodels specifies the viewmodel(s) to use for the association

  • external indicates an association external to the view. Externalized associations are not included in (de)serializations of the parent, and must be independently manipulated using ‘AssociationManipulation`. External associations may only be made to root viewmodels.

  • through names an ActiveRecord association that will be used like an ActiveRecord has_many:through:.

  • through_order_attr the through model is ordered by the given attribute (only applies to when through is set).



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
 
# File 'lib/view_model/active_record.rb', line 88

def association(association_name,
                as: nil,
                viewmodel: nil,
                viewmodels: nil,
                external: false,
                read_only: false,
                through: nil,
                through_order_attr: nil)

  vm_association_name = (as || association_name).to_s

  if through
    direct_association_name   = through
    indirect_association_name = association_name
  else
    direct_association_name   = association_name
    indirect_association_name = nil
  end

  target_viewmodels = Array.wrap(viewmodel || viewmodels)

  association_data = AssociationData.new(
    owner:                     self,
    association_name:          vm_association_name,
    direct_association_name:   direct_association_name,
    indirect_association_name: indirect_association_name,
    target_viewmodels:         target_viewmodels,
    external:                  external,
    read_only:                 read_only,
    through_order_attr:        through_order_attr)

  _members[vm_association_name] = association_data

  @generated_accessor_module.module_eval do
    define_method vm_association_name do
      _read_association(vm_association_name)
    end

    define_method :"serialize_#{vm_association_name}" do |json, serialize_context: self.class.new_serialize_context|
      _serialize_association(vm_association_name, json, serialize_context: serialize_context)
    end
  end
end

.associations(*assocs, **args) ⇒ Object

Specify multiple associations at once



133
134
135
 
# File 'lib/view_model/active_record.rb', line 133

def associations(*assocs, **args)
  assocs.each { |assoc| association(assoc, **args) }
end

.cacheable!(**opts) ⇒ Object 



258
259
260
261
 
# File 'lib/view_model/active_record.rb', line 258

def cacheable!(**opts)
  include ViewModel::ActiveRecord::Cache::CacheableView
  create_viewmodel_cache!(**opts)
end

.deep_schema_version(include_referenced: true, include_external: true) ⇒ Object 



250
251
252
253
254
255
256
 
# File 'lib/view_model/active_record.rb', line 250

def deep_schema_version(include_referenced: true, include_external: true)
  (@deep_schema_version ||= {})[[include_referenced, include_external]] ||=
    begin
      vms = dependent_viewmodels(include_referenced: include_referenced, include_external: include_external)
      ViewModel.schema_versions(vms).freeze
    end
end

.dependent_viewmodels(seen = Set.new, include_referenced: true, include_external: true) ⇒ Object 



232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
 
# File 'lib/view_model/active_record.rb', line 232

def dependent_viewmodels(seen = Set.new, include_referenced: true, include_external: true)
  return if seen.include?(self)

  seen << self

  _members.each_value do |data|
    next unless data.is_a?(AssociationData)
    next unless include_referenced || !data.referenced?
    next unless include_external   || !data.external?

    data.viewmodel_classes.each do |vm|
      vm.dependent_viewmodels(seen, include_referenced: include_referenced, include_external: include_external)
    end
  end

  seen
end

.deserialize_from_view(subtree_hash_or_hashes, references: {}, deserialize_context: new_deserialize_context) ⇒ Object 



171
172
173
174
175
176
177
178
179
180
181
182
 
# File 'lib/view_model/active_record.rb', line 171

def deserialize_from_view(subtree_hash_or_hashes, references: {}, deserialize_context: new_deserialize_context)
  model_class.transaction do
    ViewModel::Utils.wrap_one_or_many(subtree_hash_or_hashes) do |subtree_hashes|
      root_update_data, referenced_update_data = UpdateData.parse_hashes(subtree_hashes, references)

      _updated_viewmodels =
        UpdateContext
          .build!(root_update_data, referenced_update_data, root_type: self)
          .run!(deserialize_context: deserialize_context)
    end
  end
end

.eager_includes(serialize_context: new_serialize_context, include_referenced: true, vm_path: []) ⇒ Object

Constructs a preload specification of the required models for serializing/deserializing this view. Cycles in the schema will be broken after two layers of eager loading.



187
188
189
190
191
192
193
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
225
226
227
228
229
230
 
# File 'lib/view_model/active_record.rb', line 187

def eager_includes(serialize_context: new_serialize_context, include_referenced: true, vm_path: [])
  association_specs = {}

  return nil if vm_path.count(self) > 2

  child_path = vm_path + [self]
  _members.each do |assoc_name, association_data|
    next unless association_data.is_a?(AssociationData)
    next if association_data.external?

    child_context =
      if self.synthetic
        serialize_context
      elsif association_data.referenced?
        serialize_context.for_references
      else
        serialize_context.for_child(nil, association_name: assoc_name)
      end

    case
    when association_data.through?
      viewmodel = association_data.direct_viewmodel
      children = viewmodel.eager_includes(serialize_context: child_context, include_referenced: include_referenced, vm_path: child_path)

    when !include_referenced && association_data.referenced?
      children = nil # Load up to the root viewmodel, but no further

    when association_data.polymorphic?
      children_by_klass = {}
      association_data.viewmodel_classes.each do |vm_class|
        klass = vm_class.model_class.name
        children_by_klass[klass] = vm_class.eager_includes(serialize_context: child_context, include_referenced: include_referenced, vm_path: child_path)
      end
      children = DeepPreloader::PolymorphicSpec.new(children_by_klass)

    else
      viewmodel = association_data.viewmodel_class
      children = viewmodel.eager_includes(serialize_context: child_context, include_referenced: include_referenced, vm_path: child_path)
    end

    association_specs[association_data.direct_reflection.name.to_s] = children
  end
  DeepPreloader::Spec.new(association_specs)
end

.find(id_or_ids, scope: nil, lock: nil, eager_include: true, serialize_context: new_serialize_context) ⇒ Object

Load instances of the viewmodel by id(s)



138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
 
# File 'lib/view_model/active_record.rb', line 138

def find(id_or_ids, scope: nil, lock: nil, eager_include: true, serialize_context: new_serialize_context)
  find_scope = self.model_class.all
  find_scope = find_scope.order(:id).lock(lock) if lock
  find_scope = find_scope.merge(scope) if scope

  ViewModel::Utils.wrap_one_or_many(id_or_ids) do |ids|
    models = find_scope.where(id: ids).to_a

    if models.size < ids.size
      missing_ids = ids - models.map(&:id)
      if missing_ids.present?
        raise ViewModel::DeserializationError::NotFound.new(
                missing_ids.map { |id| ViewModel::Reference.new(self, id) })
      end
    end

    vms = models.map { |m| self.new(m) }
    ViewModel.preload_for_serialization(vms, lock: lock, serialize_context: serialize_context) if eager_include
    vms
  end
end

.load(scope: nil, eager_include: true, lock: nil, serialize_context: new_serialize_context) ⇒ Object

Load instances of the viewmodel by scope TODO: is this too much of a encapsulation violation?



162
163
164
165
166
167
168
169
 
# File 'lib/view_model/active_record.rb', line 162

def load(scope: nil, eager_include: true, lock: nil, serialize_context: new_serialize_context)
  load_scope = self.model_class.all
  load_scope = load_scope.lock(lock) if lock
  load_scope = load_scope.merge(scope) if scope
  vms = load_scope.map { |model| self.new(model) }
  ViewModel.preload_for_serialization(vms, lock: lock, serialize_context: serialize_context) if eager_include
  vms
end

.should_register? ⇒ Boolean

Returns:

  • (Boolean) 


42
43
44
 
# File 'lib/view_model/active_record.rb', line 42

def should_register?
  super && !synthetic
end

Instance Method Details

#_read_association(association_name) ⇒ Object 



340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
 
# File 'lib/view_model/active_record.rb', line 340

def _read_association(association_name)
  association_data = self.class._association_data(association_name)

  associated = model.public_send(association_data.direct_reflection.name)
  return nil if associated.nil?

  case
  when association_data.through?
    # associated here are join-table models; we need to get the far side out
    join_models = associated

    if association_data.direct_viewmodel._list_member?
      attr = association_data.direct_viewmodel._list_attribute_name
      join_models = join_models.sort_by { |j| j[attr] }
    end

    join_models.map do |through_model|
      model = through_model.public_send(association_data.indirect_reflection.name)
      association_data.viewmodel_class_for_model!(model.class).new(model)
    end

  when association_data.collection?
    associated_viewmodel_class = association_data.viewmodel_class
    associated_viewmodels = associated.map { |x| associated_viewmodel_class.new(x) }
    if associated_viewmodel_class._list_member?
      associated_viewmodels.sort_by!(&:_list_attribute)
    end
    associated_viewmodels

  else
    associated_viewmodel_class = association_data.viewmodel_class_for_model!(associated.class)
    associated_viewmodel_class.new(associated)
  end
end

#_serialize_association(association_name, json, serialize_context:) ⇒ Object 



375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
 
# File 'lib/view_model/active_record.rb', line 375

def _serialize_association(association_name, json, serialize_context:)
  associated = self.public_send(association_name)
  association_data = self.class._association_data(association_name)

  json.set! association_name do
    case
    when associated.nil?
      json.null!
    when association_data.referenced?
      if association_data.collection?
        json.array!(associated) do |target|
          self.class.serialize_as_reference(target, json, serialize_context: serialize_context)
        end
      else
        self.class.serialize_as_reference(associated, json, serialize_context: serialize_context)
      end
    else
      self.class.serialize(associated, json, serialize_context: serialize_context)
    end
  end
end

#association_changed!(association_name) ⇒ Object 



305
306
307
308
309
310
311
312
313
314
315
316
317
 
# File 'lib/view_model/active_record.rb', line 305

def association_changed!(association_name)
  association_name = association_name.to_s

  association_data = self.class._association_data(association_name)

  if association_data.read_only?
    raise ViewModel::DeserializationError::ReadOnlyAssociation.new(association_name, blame_reference)
  end

  unless @changed_associations.include?(association_name)
    @changed_associations << association_name
  end
end

#associations_changed? ⇒ Boolean

Returns:

  • (Boolean) 


319
320
321
 
# File 'lib/view_model/active_record.rb', line 319

def associations_changed?
  @changed_associations.present?
end

#changes ⇒ Object

Additionally pass ‘changed_associations` while constructing changes.



324
325
326
327
328
329
330
331
332
 
# File 'lib/view_model/active_record.rb', line 324

def changes
  ViewModel::Changes.new(
    new:                         new_model?,
    changed_attributes:          changed_attributes,
    changed_associations:        changed_associations,
    changed_nested_children:     changed_nested_children?,
    changed_referenced_children: changed_referenced_children?,
  )
end

#clear_changes! ⇒ Object 



334
335
336
337
338
 
# File 'lib/view_model/active_record.rb', line 334

def clear_changes!
  super.tap do
    @changed_associations = []
  end
end

#context_for_child(member_name, context:) ⇒ Object 



397
398
399
400
401
402
403
404
405
406
407
408
409
 
# File 'lib/view_model/active_record.rb', line 397

def context_for_child(member_name, context:)
  # Synthetic viewmodels don't exist as far as the traversal context is
  # concerned: pass through the child context received from the parent
  return context if self.class.synthetic

  # associations to roots start a new tree
  member_data = self.class._members[member_name.to_s]
  if member_data.association? && member_data.referenced?
    return context.for_references
  end

  super
end

#destroy!(deserialize_context: self.class.new_deserialize_context) ⇒ Object 



294
295
296
297
298
299
300
301
302
303
 
# File 'lib/view_model/active_record.rb', line 294

def destroy!(deserialize_context: self.class.new_deserialize_context)
  model_class.transaction do
    ViewModel::Callbacks.wrap_deserialize(self, deserialize_context: deserialize_context) do |hook_control|
      changes = ViewModel::Changes.new(deleted: true)
      deserialize_context.run_callback(ViewModel::Callbacks::Hook::OnChange, self, changes: changes)
      hook_control.record_changes(changes)
      model.destroy!
    end
  end
end

#serialize_members(json, serialize_context: self.class.new_serialize_context) ⇒ Object 



278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
 
# File 'lib/view_model/active_record.rb', line 278

def serialize_members(json, serialize_context: self.class.new_serialize_context)
  self.class._members.each do |member_name, member_data|
    next if member_data.association? && member_data.external?

    member_context =
      case member_data
      when AssociationData
        self.context_for_child(member_name, context: serialize_context)
      else
        serialize_context
      end

    self.public_send("serialize_#{member_name}", json, serialize_context: member_context)
  end
end