iknow_view_models 3.3.1 → 3.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 169b16cc95d420bc248b0d201edecc825ce67cdcaf8a8bc743083685731017bf
-  data.tar.gz: 974ba2af7789e733a3aecdb989e0508147c9d415332398a7ab024d212babef9e
+  metadata.gz: 1e0fb612b3ee4fc28b8bba11d40dfcd2da75775af0c8154a83a913f179824ccd
+  data.tar.gz: 6027d6f5a46e2654432e8c7b28cfcde8d2cb07f523efa7f87be199241246b83e
 SHA512:
-  metadata.gz: a4dc1e63038e01b6af791ef0551f7f79ac19cbe0ba9b47a6d1fa3367200417afe0b3bfaa9951b8c7287c97d821139e217521229c4bdee34c045da70bcbf0d052
-  data.tar.gz: 63bab618289cf6e24e26ffd7be8d6a2a7571d220c1a1c5b05bb45d52c778bab4aff751f4c3853ce58226c1830de3dfebfa0296db8ad070b5e8e696224ccb3bc7
+  metadata.gz: 7301fdf85df162d86aaaa558e136dd1df2f047aec97abd084ba83369cac83b5d1b7904a8d0930c9cfb34a9c08aa49e835f89d0ea5c83eef007dbec4ff92a4b31
+  data.tar.gz: 861f4a2b0ab0eb4a48fa6ef1a2116307dd9d8409508e40c2534cb3e07b6dfe92e843f2eeb4904249d97326d83147eccf3b1757c0200b2ce796aa83eeb1eb3c0f

data/lib/iknow_view_models/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module IknowViewModels
-  VERSION = '3.3.1'
+  VERSION = '3.4.0'
 end

data/lib/view_model.rb

@@ -134,7 +134,7 @@ class ViewModel
     # 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.
-    def eager_includes(serialize_context: new_serialize_context, include_referenced: true)
+    def eager_includes(include_referenced: true)
       {}
     end
 
@@ -267,10 +267,10 @@ class ViewModel
       Base64.urlsafe_encode64(hash, padding: false)
     end
 
-    def preload_for_serialization(viewmodels, serialize_context: new_serialize_context, include_referenced: true, lock: nil)
+    def preload_for_serialization(viewmodels, 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),
+                              type.eager_includes(include_referenced: include_referenced),
                               lock: lock)
       end
     end
@@ -354,8 +354,8 @@ class ViewModel
     context.for_child(self, association_name: member_name)
   end
 
-  def preload_for_serialization(lock: nil, serialize_context: self.class.new_serialize_context)
-    ViewModel.preload_for_serialization([self], lock: lock, serialize_context: serialize_context)
+  def preload_for_serialization(lock: nil)
+    ViewModel.preload_for_serialization([self], lock: lock)
   end
 
   def ==(other)

data/lib/view_model/active_record.rb

@@ -135,7 +135,7 @@ class ViewModel::ActiveRecord < ViewModel::Record
     end
 
     ## Load instances of the viewmodel by id(s)
-    def find(id_or_ids, scope: nil, lock: nil, eager_include: true, serialize_context: new_serialize_context)
+    def find(id_or_ids, scope: nil, lock: nil, eager_include: true)
       find_scope = self.model_class.all
       find_scope = find_scope.order(:id).lock(lock) if lock
       find_scope = find_scope.merge(scope) if scope
@@ -152,19 +152,19 @@ class ViewModel::ActiveRecord < ViewModel::Record
         end
 
         vms = models.map { |m| self.new(m) }
-        ViewModel.preload_for_serialization(vms, lock: lock, serialize_context: serialize_context) if eager_include
+        ViewModel.preload_for_serialization(vms, lock: lock) if eager_include
         vms
       end
     end
 
     ## Load instances of the viewmodel by scope
     ## TODO: is this too much of a encapsulation violation?
-    def load(scope: nil, eager_include: true, lock: nil, serialize_context: new_serialize_context)
+    def load(scope: nil, eager_include: true, lock: nil)
       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
+      ViewModel.preload_for_serialization(vms, lock: lock) if eager_include
       vms
     end
 
@@ -184,7 +184,7 @@ class ViewModel::ActiveRecord < ViewModel::Record
     # 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.
-    def eager_includes(serialize_context: new_serialize_context, include_referenced: true, vm_path: [])
+    def eager_includes(include_referenced: true, vm_path: [])
       association_specs = {}
 
       return nil if vm_path.count(self) > 2
@@ -194,19 +194,10 @@ class ViewModel::ActiveRecord < ViewModel::Record
         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)
+          children = viewmodel.eager_includes(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
@@ -215,13 +206,13 @@ class ViewModel::ActiveRecord < ViewModel::Record
           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)
+            children_by_klass[klass] = vm_class.eager_includes(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)
+          children = viewmodel.eager_includes(include_referenced: include_referenced, vm_path: child_path)
         end
 
         association_specs[association_data.direct_reflection.name.to_s] = children

data/lib/view_model/active_record/association_manipulation.rb

@@ -34,10 +34,7 @@ module ViewModel::ActiveRecord::AssociationManipulation
 
     vms = association_scope.map { |model| associated_viewmodel.new(model) }
 
-    if eager_include
-      child_context = self.context_for_child(association_name, context: serialize_context)
-      ViewModel.preload_for_serialization(vms, serialize_context: child_context)
-    end
+    ViewModel.preload_for_serialization(vms) if eager_include
 
     if association_data.collection?
       vms

data/lib/view_model/active_record/cache.rb

@@ -196,7 +196,7 @@ class ViewModel::ActiveRecord::Cache
     # {id=>serialized_view}. Any references encountered are added to the
     # worklist.
     def load_from_cache(viewmodel_cache, ids)
-      cached_serializations = viewmodel_cache.load(ids, migrated_cache_version(viewmodel_cache), serialize_context: serialize_context)
+      cached_serializations = viewmodel_cache.load(ids, migrated_cache_version(viewmodel_cache))
 
       cached_serializations.each_with_object({}) do |(id, cached_serialization), result|
         add_refs_to_worklist(cached_serialization[:ref_cache])
@@ -255,8 +255,7 @@ class ViewModel::ActiveRecord::Cache
         if viewmodel.class < CacheableView
           cacheable_references = referenced_viewmodels.transform_values { |vm| cacheable_reference(vm) }
           target_cache = viewmodel.class.viewmodel_cache
-          target_cache.store(viewmodel.id, migrated_cache_version(target_cache), data_serialization, cacheable_references,
-                             serialize_context: serialize_context)
+          target_cache.store(viewmodel.id, migrated_cache_version(target_cache), data_serialization, cacheable_references)
         end
 
         result[viewmodel.id] = data_serialization
@@ -279,15 +278,13 @@ class ViewModel::ActiveRecord::Cache
       if ids.present?
         found = viewmodel_class.find(ids,
                                      eager_include: false,
-                                     lock: 'FOR SHARE',
-                                     serialize_context: serialize_context)
+                                     lock: 'FOR SHARE')
         viewmodels.concat(found)
       end
 
       ViewModel.preload_for_serialization(viewmodels,
                                           include_referenced: false,
-                                          lock: 'FOR SHARE',
-                                          serialize_context: serialize_context)
+                                          lock: 'FOR SHARE')
 
       viewmodels
     end
@@ -335,12 +332,12 @@ class ViewModel::ActiveRecord::Cache
   end
 
   # Save the provided serialization and reference data in the cache
-  def store(id, migration_version, data_serialization, ref_cache, serialize_context:)
+  def store(id, migration_version, data_serialization, ref_cache)
     key = key_for(id, migration_version)
     cache_for(migration_version).write(key, { data: data_serialization, ref_cache: ref_cache })
   end
 
-  def load(ids, migration_version, serialize_context:)
+  def load(ids, migration_version)
     keys = ids.map { |id| key_for(id, migration_version) }
     results = cache_for(migration_version).read_multi(keys)
     results.transform_keys! { |key| id_for(key) }

data/lib/view_model/active_record/collection_nested_controller.rb

@@ -50,7 +50,7 @@ module ViewModel::ActiveRecord::CollectionNestedController
         raise ViewModel::DeserializationError::InvalidSyntax.new('Can not provide both `before` and `after` anchors for a collection append')
       end
 
-      owner_view = owner_viewmodel.find(owner_viewmodel_id, eager_include: false, lock: lock_owner, serialize_context: serialize_context)
+      owner_view = owner_viewmodel.find(owner_viewmodel_id, eager_include: false, lock: lock_owner)
 
       assoc_view = owner_view.append_associated(association_name,
                                                 update_hash,
@@ -60,7 +60,7 @@ module ViewModel::ActiveRecord::CollectionNestedController
                                                 deserialize_context: deserialize_context)
       ViewModel::Callbacks.wrap_serialize(owner_view, context: serialize_context) do
         child_context = owner_view.context_for_child(association_name, context: serialize_context)
-        ViewModel.preload_for_serialization(assoc_view, serialize_context: child_context)
+        ViewModel.preload_for_serialization(assoc_view)
         assoc_view = yield(assoc_view) if block_given?
         prerender_viewmodel(assoc_view, serialize_context: child_context)
       end
@@ -71,7 +71,7 @@ module ViewModel::ActiveRecord::CollectionNestedController
 
   def disassociate(serialize_context: new_serialize_context, deserialize_context: new_deserialize_context, lock_owner: nil)
     owner_viewmodel.transaction do
-      owner_view = owner_viewmodel.find(owner_viewmodel_id, eager_include: false, lock: lock_owner, serialize_context: serialize_context)
+      owner_view = owner_viewmodel.find(owner_viewmodel_id, eager_include: false, lock: lock_owner)
       owner_view.delete_associated(association_name, viewmodel_id, type: viewmodel_class, deserialize_context: deserialize_context)
       render_viewmodel(nil)
     end

data/lib/view_model/active_record/controller.rb

@@ -22,7 +22,7 @@ module ViewModel::ActiveRecord::Controller
   def show(scope: nil, viewmodel_class: self.viewmodel_class, serialize_context: new_serialize_context(viewmodel_class: viewmodel_class))
     view = nil
     pre_rendered = viewmodel_class.transaction do
-      view = viewmodel_class.find(viewmodel_id, scope: scope, serialize_context: serialize_context)
+      view = viewmodel_class.find(viewmodel_id, scope: scope)
       view = yield(view) if block_given?
       prerender_viewmodel(view, serialize_context: serialize_context)
     end
@@ -33,7 +33,7 @@ module ViewModel::ActiveRecord::Controller
   def index(scope: nil, viewmodel_class: self.viewmodel_class, serialize_context: new_serialize_context(viewmodel_class: viewmodel_class))
     views = nil
     pre_rendered = viewmodel_class.transaction do
-      views = viewmodel_class.load(scope: scope, serialize_context: serialize_context)
+      views = viewmodel_class.load(scope: scope)
       views = yield(views) if block_given?
       prerender_viewmodel(views, serialize_context: serialize_context)
     end
@@ -47,7 +47,7 @@ module ViewModel::ActiveRecord::Controller
     view = nil
     pre_rendered = viewmodel_class.transaction do
       view = viewmodel_class.deserialize_from_view(update_hash, references: refs, deserialize_context: deserialize_context)
-      ViewModel.preload_for_serialization(view, serialize_context: serialize_context)
+      ViewModel.preload_for_serialization(view)
       view = yield(view) if block_given?
       prerender_viewmodel(view, serialize_context: serialize_context)
     end
@@ -57,7 +57,7 @@ module ViewModel::ActiveRecord::Controller
 
   def destroy(serialize_context: new_serialize_context, deserialize_context: new_deserialize_context)
     viewmodel_class.transaction do
-      view = viewmodel_class.find(viewmodel_id, eager_include: false, serialize_context: serialize_context)
+      view = viewmodel_class.find(viewmodel_id, eager_include: false)
       view.destroy!(deserialize_context: deserialize_context)
     end
     render_viewmodel(nil)

data/lib/view_model/active_record/nested_controller_base.rb

@@ -12,10 +12,10 @@ module ViewModel::ActiveRecord::NestedControllerBase
   def show_association(scope: nil, serialize_context: new_serialize_context, lock_owner: nil)
     associated_views = nil
     pre_rendered = owner_viewmodel.transaction do
-      owner_view = owner_viewmodel.find(owner_viewmodel_id, eager_include: false, lock: lock_owner, serialize_context: serialize_context)
+      owner_view = owner_viewmodel.find(owner_viewmodel_id, eager_include: false, lock: lock_owner)
       ViewModel::Callbacks.wrap_serialize(owner_view, context: serialize_context) do
         # Association manipulation methods construct child contexts internally
-        associated_views = owner_view.load_associated(association_name, scope: scope, serialize_context: serialize_context)
+        associated_views = owner_view.load_associated(association_name, scope: scope)
 
         associated_views = yield(associated_views) if block_given?
 
@@ -32,7 +32,7 @@ module ViewModel::ActiveRecord::NestedControllerBase
     pre_rendered = owner_viewmodel.transaction do
       update_hash, refs = parse_viewmodel_updates
 
-      owner_view = owner_viewmodel.find(owner_viewmodel_id, eager_include: false, lock: lock_owner, serialize_context: serialize_context)
+      owner_view = owner_viewmodel.find(owner_viewmodel_id, eager_include: false, lock: lock_owner)
 
       association_view = owner_view.replace_associated(association_name, update_hash,
                                                        references: refs,
@@ -40,7 +40,7 @@ module ViewModel::ActiveRecord::NestedControllerBase
 
       ViewModel::Callbacks.wrap_serialize(owner_view, context: serialize_context) do
         child_context = owner_view.context_for_child(association_name, context: serialize_context)
-        ViewModel.preload_for_serialization(association_view, serialize_context: child_context)
+        ViewModel.preload_for_serialization(association_view)
         association_view = yield(association_view) if block_given?
         prerender_viewmodel(association_view, serialize_context: child_context)
       end
@@ -51,7 +51,7 @@ module ViewModel::ActiveRecord::NestedControllerBase
 
   def destroy_association(collection, serialize_context: new_serialize_context, deserialize_context: new_deserialize_context, lock_owner: nil)
     if lock_owner
-      owner_viewmodel.find(owner_viewmodel_id, eager_include: false, lock: lock_owner, serialize_context: serialize_context)
+      owner_viewmodel.find(owner_viewmodel_id, eager_include: false, lock: lock_owner)
     end
 
     empty_update = collection ? [] : nil

data/test/unit/view_model/active_record/has_many_through_poly_test.rb

@@ -118,7 +118,7 @@ class ViewModel::ActiveRecord::HasManyThroughPolyTest < ActiveSupport::TestCase
   def test_loading_batching
     context = ParentView.new_serialize_context
     log_queries do
-      parent_views = ParentView.load(serialize_context: context)
+      parent_views = ParentView.load
       serialize(parent_views, serialize_context: context)
     end
 

data/test/unit/view_model/active_record/has_many_through_test.rb

@@ -112,7 +112,7 @@ class ViewModel::ActiveRecord::HasManyThroughTest < ActiveSupport::TestCase
   def test_loading_batching
     context = ParentView.new_serialize_context
     log_queries do
-      parent_views = ParentView.load(serialize_context: context)
+      parent_views = ParentView.load
       serialize(parent_views, serialize_context: context)
     end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: iknow_view_models
 version: !ruby/object:Gem::Version
-  version: 3.3.1
+  version: 3.4.0
 platform: ruby
 authors:
 - iKnow Team
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-04-28 00:00:00.000000000 Z
+date: 2021-06-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord