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, 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?, #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.



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

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) 


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

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 



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

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

.deep_schema_version(include_referenced: true) ⇒ Object 



243
244
245
246
247
248
249
250
 
# File 'lib/view_model/active_record.rb', line 243

def deep_schema_version(include_referenced: true)
  (@deep_schema_version ||= {})[include_referenced] ||=
    begin
      dependent_viewmodels(include_referenced: include_referenced).each_with_object({}) do |view, h|
        h[view.view_name] = view.schema_version
      end
    end
end

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



227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
 
# File 'lib/view_model/active_record.rb', line 227

def dependent_viewmodels(seen = Set.new, include_referenced: 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?
    data.viewmodel_classes.each do |vm|
      vm.dependent_viewmodels(seen, include_referenced: include_referenced)
    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) ⇒ Object

Constructs a preload specification of the required models for serializing/deserializing this view.



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

def eager_includes(serialize_context: new_serialize_context, include_referenced: true)
  association_specs = {}
  _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)

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



334
335
336
337
338
339
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
 
# File 'lib/view_model/active_record.rb', line 334

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
    if association_data.direct_viewmodel._list_member?
      associated.order(association_data.direct_viewmodel._list_attribute_name)
    end

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



366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
 
# File 'lib/view_model/active_record.rb', line 366

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 



299
300
301
302
303
304
305
306
307
308
309
310
311
 
# File 'lib/view_model/active_record.rb', line 299

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) 


313
314
315
 
# File 'lib/view_model/active_record.rb', line 313

def associations_changed?
  @changed_associations.present?
end

#changes ⇒ Object

Additionally pass ‘changed_associations` while constructing changes.



318
319
320
321
322
323
324
325
326
 
# File 'lib/view_model/active_record.rb', line 318

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 



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

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

#context_for_child(member_name, context:) ⇒ Object 



388
389
390
391
392
393
394
395
396
397
398
399
400
 
# File 'lib/view_model/active_record.rb', line 388

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 



288
289
290
291
292
293
294
295
296
297
 
# File 'lib/view_model/active_record.rb', line 288

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 



272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
 
# File 'lib/view_model/active_record.rb', line 272

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