iknow_view_models 2.10.1 → 3.0.0

data/lib/view_model/active_record/cache/cacheable_view.rb

@@ -12,17 +12,7 @@ module ViewModel::ActiveRecord::Cache::CacheableView
   CacheClearer = Struct.new(:cache, :id) do
     include ViewModel::AfterTransactionRunner
 
-    # It's important that we clear the cache before committing, because we rely
-    # on database locking to prevent cache race conditions. We require
-    # reading/refreshing the cache to obtain a FOR SHARE lock, which means that
-    # a reader must wait for a concurrent writer to commit before continuing to
-    # the cache. If the writer cleared the cache after commit, the reader could
-    # obtain old data before the clear, and then save the old data after it.
-    def before_commit
-      cache.delete(id)
-    end
-
-    def after_rollback
+    def after_transaction
       cache.delete(id)
     end
 
@@ -49,12 +39,12 @@ module ViewModel::ActiveRecord::Cache::CacheableView
     end
   end
 
-  # Clear the cache if the view or its owned children were changed during
+  # Clear the cache if the view or its nested children were changed during
   # deserialization
   def after_deserialize(deserialize_context:, changes:)
     super if defined?(super)
 
-    if !changes.new? && changes.changed_tree?
+    if !changes.new? && changes.changed_nested_tree?
       CacheClearer.new(self.class.viewmodel_cache, id).add_to_transaction
     end
   end

data/lib/view_model/active_record/cache.rb

@@ -198,7 +198,7 @@ class ViewModel::ActiveRecord::Cache
       end
 
       ViewModel.preload_for_serialization(viewmodels,
-                                          include_shared: false,
+                                          include_referenced: false,
                                           lock: "FOR SHARE",
                                           serialize_context: serialize_context)
 
@@ -259,7 +259,7 @@ class ViewModel::ActiveRecord::Cache
   end
 
   def cache_version
-    version_string = @viewmodel_class.deep_schema_version(include_shared: false).to_a.sort.join(',')
+    version_string = @viewmodel_class.deep_schema_version(include_referenced: false).to_a.sort.join(',')
     Base64.urlsafe_encode64(Digest::MD5.digest(version_string))
   end
 end

data/lib/view_model/active_record/cloner.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 # Simple visitor for cloning models through the tree structure defined by
 # ViewModel::ActiveRecord. Owned associations will be followed and cloned, while
-# shared associations will be copied directly. Attributes (including association
-# foreign keys not covered by ViewModel `association`s) will be copied from the
-# original.
+# non-owned referenced associations will be copied directly as references.
+# Attributes (including association foreign keys not covered by ViewModel
+# `association`s) will be copied from the original.
 #
 # To customize, subclasses may define methods `visit_x_view(node, new_model)`
 # for each type they wish to affect. These callbacks may update attributes of
@@ -19,9 +21,9 @@ class ViewModel::ActiveRecord::Cloner
     return nil if ignored?
 
     if node.class.name
-      class_name      = node.class.name.underscore.gsub('/', '__')
-      visit     = :"visit_#{class_name}"
-      end_visit = :"end_visit_#{class_name}"
+      class_name = node.class.name.underscore.gsub('/', '__')
+      visit      = :"visit_#{class_name}"
+      end_visit  = :"end_visit_#{class_name}"
     end
 
     if visit && respond_to?(visit, true)
@@ -44,7 +46,7 @@ class ViewModel::ActiveRecord::Cloner
 
         if associated.nil?
           new_associated = nil
-        elsif association_data.shared? && !association_data.through?
+        elsif !association_data.owned? && !association_data.through?
           # simply attach the associated target to the new model
           new_associated = associated
         else
@@ -82,11 +84,9 @@ class ViewModel::ActiveRecord::Cloner
     new_model
   end
 
-  def pre_visit(node, new_model)
-  end
+  def pre_visit(node, new_model); end
 
-  def post_visit(node, new_model)
-  end
+  def post_visit(node, new_model); end
 
   private
 

data/lib/view_model/active_record/controller.rb

@@ -46,8 +46,6 @@ module ViewModel::ActiveRecord::Controller
     pre_rendered = viewmodel_class.transaction do
       view = viewmodel_class.deserialize_from_view(update_hash, references: refs, deserialize_context: deserialize_context)
 
-      serialize_context.add_includes(deserialize_context.updated_associations)
-
       view = yield(view) if block_given?
 
       ViewModel.preload_for_serialization(view, serialize_context: serialize_context)

data/lib/view_model/active_record/update_context.rb

@@ -74,7 +74,7 @@ class ViewModel::ActiveRecord
 
     def initialize
       @root_update_operations       = [] # The subject(s) of this update
-      @referenced_update_operations = {} # Shared data updates, referred to by a ref hash
+      @referenced_update_operations = {} # data updates to other root models, referred to by a ref hash
 
       # Set of ViewModel::Reference used to assert only a single update is
       # present for each viewmodel
@@ -178,8 +178,20 @@ class ViewModel::ActiveRecord
           raise ViewModel::DeserializationError::ParentNotFound.new(@worklist.keys)
         end
 
-        deferred_update = @worklist.delete(key)
-        deferred_update.viewmodel = @release_pool.claim_from_pool(key)
+        deferred_update    = @worklist.delete(key)
+        released_viewmodel = @release_pool.claim_from_pool(key)
+
+        if deferred_update.viewmodel
+          # Deferred reference updates already have a viewmodel: ensure it
+          # matches the tree
+          unless deferred_update.viewmodel == released_viewmodel
+            raise ViewModel::DeserializationError::Internal.new(
+                    "Released viewmodel doesn't match reference update", blame_reference)
+          end
+        else
+          deferred_update.viewmodel = released_viewmodel
+        end
+
         deferred_update.build!(self)
       end
 
@@ -201,6 +213,12 @@ class ViewModel::ActiveRecord
       update_operation = ViewModel::ActiveRecord::UpdateOperation.new(
         nil, update_data, reparent_to: reparent_to, reposition_to: reposition_to)
       check_unique_update!(viewmodel_reference)
+      defer_update(viewmodel_reference, update_operation)
+    end
+
+    # Defer an existing update: used if we need to ensure that an owned
+    # reference has been freed before we use it.
+    def defer_update(viewmodel_reference, update_operation)
       @worklist[viewmodel_reference] = update_operation
     end
 

data/lib/view_model/active_record/update_data.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'renum'
 require 'view_model/schemas'
 
@@ -45,14 +47,13 @@ class ViewModel::ActiveRecord
     end
   end
 
-  # Parser for collection updates. Collection updates have a regular
-  # structure, but vary based on the contents. Parsing a {direct,
-  # owned} collection recurses deeply and creates a tree of
-  # UpdateDatas, while parsing a {through, shared} collection collects
-  # reference strings.
+  # Parser for collection updates. Collection updates have a regular structure,
+  # but vary based on the contents. Parsing a nested collection recurses deeply
+  # and creates a tree of UpdateDatas, while parsing a referenced collection
+  # collects reference strings.
   class AbstractCollectionUpdate
-    # Wraps a complete collection of new data: either UpdateDatas for owned
-    # collections or reference strings for shared.
+    # Wraps a complete collection of new data: either UpdateDatas for non-root
+    # associations or reference strings for root.
     class Replace
       attr_reader :contents
       def initialize(contents)
@@ -61,7 +62,8 @@ class ViewModel::ActiveRecord
     end
 
     # Wraps an ordered list of FunctionalUpdates, each of whose `contents` are
-    # either UpdateData for owned collections or references for shared.
+    # either UpdateData for nested associations or references for referenced
+    # associations.
     class Functional
       attr_reader :actions
       def initialize(actions)
@@ -81,8 +83,8 @@ class ViewModel::ActiveRecord
 
       # Resolve ViewModel::References used in the update's contents, whether by
       # reference or value.
-      def used_vm_refs(update_context)
-        raise "abstract"
+      def used_vm_refs(_update_context)
+        raise RuntimeError.new('abstract method')
       end
 
       def removed_vm_refs
@@ -153,7 +155,8 @@ class ViewModel::ActiveRecord
       # The shape of the actions are always the same
 
       # Parse an anchor for a functional_update, before/after
-      # May only contain type and id fields, is never a reference even for shared collections.
+      # May only contain type and id fields, is never a reference even for
+      # referenced associations.
       def parse_anchor(child_hash) # final
         child_metadata = ViewModel.extract_reference_only_metadata(child_hash)
 
@@ -271,9 +274,13 @@ class ViewModel::ActiveRecord
 
       def used_vm_refs(update_context)
         update_datas
-          .map { |upd| upd.viewmodel_reference if upd.id }
+          .map { |upd| resolve_vm_reference(upd, update_context) }
           .compact
       end
+
+      def resolve_vm_reference(update_data, _update_context)
+        update_data.viewmodel_reference if update_data.id
+      end
     end
 
     class Parser < AbstractCollectionUpdate::Parser
@@ -319,9 +326,13 @@ class ViewModel::ActiveRecord
 
       def used_vm_refs(update_context)
         references.map do |ref|
-          update_context.resolve_reference(ref, nil).viewmodel_reference
+          resolve_vm_reference(ref, update_context)
         end
       end
+
+      def resolve_vm_reference(ref, update_context)
+        update_context.resolve_reference(ref, nil).viewmodel_reference
+      end
     end
 
     class Parser < AbstractCollectionUpdate::Parser
@@ -356,6 +367,7 @@ class ViewModel::ActiveRecord
           unless valid_reference_keys.include?(ref)
             raise ViewModel::DeserializationError::InvalidSharedReference.new(ref, blame_reference)
           end
+
           ref
         end
       end
@@ -421,7 +433,7 @@ class ViewModel::ActiveRecord
       fupdate_owned =
         fupdate_base.(ViewModel::Schemas::VIEWMODEL_UPDATE_SCHEMA)
 
-      fupdate_shared           =
+      fupdate_shared =
         fupdate_base.({ 'oneOf' => [ViewModel::Schemas::VIEWMODEL_REFERENCE_SCHEMA,
                                     viewmodel_reference_only] })
 
@@ -571,30 +583,15 @@ class ViewModel::ActiveRecord
       case
       when value.nil?
         []
-      when association_data.shared?
+      when association_data.referenced?
         []
-      when association_data.collection? # not shared, because of shared? check above
+      when association_data.collection? # nested, because of referenced? check above
         value.update_datas
       else
         [value]
       end
     end
 
-    # Updates in terms of viewmodel associations
-    def updated_associations
-      deps = {}
-
-      (associations.merge(referenced_associations)).each do |assoc_name, assoc_update|
-        deps[assoc_name] =
-          to_sequence(assoc_name, assoc_update)
-            .each_with_object({}) do |update_data, updated_associations|
-              updated_associations.deep_merge!(update_data.updated_associations)
-            end
-      end
-
-      deps
-    end
-
     def build_preload_specs(association_data, updates)
       if association_data.polymorphic?
         updates.map do |update_data|
@@ -682,6 +679,7 @@ class ViewModel::ActiveRecord
 
         when AssociationData
           association_data = member_data
+
           case
           when value.nil?
             if association_data.collection?
@@ -689,28 +687,28 @@ class ViewModel::ActiveRecord
                       "Invalid collection update value 'nil' for association '#{name}'",
                       blame_reference)
             end
-            if association_data.shared?
+            if association_data.referenced?
               referenced_associations[name] = nil
             else
               associations[name] = nil
             end
 
-          when association_data.through?
-            referenced_associations[name] =
-              ReferencedCollectionUpdate::Parser
-                .new(association_data, blame_reference, valid_reference_keys)
-                .parse(value)
+          when association_data.referenced?
+            if association_data.collection?
+              referenced_associations[name] =
+                ReferencedCollectionUpdate::Parser
+                  .new(association_data, blame_reference, valid_reference_keys)
+                  .parse(value)
+            else
+              # Extract and check reference
+              ref = ViewModel.extract_reference_metadata(value)
 
-          when association_data.shared?
-            # Extract and check reference
-            ref = ViewModel.extract_reference_metadata(value)
+              unless valid_reference_keys.include?(ref)
+                raise ViewModel::DeserializationError::InvalidSharedReference.new(ref, blame_reference)
+              end
 
-            unless valid_reference_keys.include?(ref)
-              raise ViewModel::DeserializationError::InvalidSharedReference.new(ref, blame_reference)
+              referenced_associations[name] = ref
             end
-
-            referenced_associations[name] = ref
-
           else
             if association_data.collection?
               associations[name] =