iknow_view_models 3.2.13 → 3.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3991314cdb010347b417869ff3e2e22b0e7adb4ab590e25739cb6b12bf49a219
-  data.tar.gz: 0cd5994d07bdd9b9d311732be56b01a51d7b4f1eb71f7fa1d0217bf71911b97f
+  metadata.gz: 87a056bba1e37b5593a5ad90365c5b761976529f1c5ab4074b26dd666060d57e
+  data.tar.gz: 5a796e74204b2fb1b55d8f94bf95c347b3b80a65bf3d48036f7b6de06cba8cf2
 SHA512:
-  metadata.gz: a5cd70dd6f79db33a97dbdfb05eefec460c7e332784839ad461cf5a359307ce8abedb39c046d42d04a3b7355280d1ad54948cb6cc61fdc35effa0f684ea4c821
-  data.tar.gz: 6a673b6387892588434f981b57f8131e9c7a97991cc16d3901e72f043b9429efd0fef7a8e1f44cb0ea1ee364256d63d48f198a10e270b487d3da61311780eec7
+  metadata.gz: 1b7d484cb7ab2d0286bfc99460f029e8a9ccbb5edcc355cee42671e285f7ce2efe45946f2f7130d528b947fdb8e3bd41aa12dc007a049674b35d7a41b6f6b5be
+  data.tar.gz: 7ab16b3a6ec5569704da7a5bdfccde6374d43770c53e1e78ceca961e7043400842c8e84e3614528eee3b8f7c81ccf884f2d0ffc24793ef5cc8328d96cee12152

data/.circleci/config.yml

@@ -5,7 +5,7 @@ executors:
     parameters:
       ruby-version:
         type: string
-        default: "2.6"
+        default: "2.7"
       pg-version:
         type: string
         default: "11"
@@ -102,8 +102,8 @@ workflows:
   build:
     jobs:
       - test:
-          name: 'ruby 2.6 rails 5.2 pg 12'
-          ruby-version: "2.6"
+          name: 'ruby 2.7 rails 5.2 pg 12'
+          ruby-version: "2.7"
           pg-version: "12"
           gemfile: gemfiles/rails_5_2.gemfile
       - test:
@@ -111,6 +111,16 @@ workflows:
           ruby-version: "2.7"
           pg-version: "12"
           gemfile: gemfiles/rails_6_0.gemfile
+      - test:
+          name: 'ruby 2.7 rails 6.1 pg 12'
+          ruby-version: "2.7"
+          pg-version: "12"
+          gemfile: gemfiles/rails_6_1.gemfile
+      - test:
+          name: 'ruby 3.0 rails 6.1 pg 12'
+          ruby-version: "3.0"
+          pg-version: "12"
+          gemfile: gemfiles/rails_6_1.gemfile
       - publish:
           filters:
             branches:

data/Appraisals

@@ -7,3 +7,8 @@ appraise 'rails-6-0' do
   gem 'activerecord', '~> 6.0.0'
   gem 'activesupport', '~> 6.0.0'
 end
+
+appraise 'rails-6-1' do
+  gem 'activerecord', '~> 6.1.0'
+  gem 'activesupport', '~> 6.1.0'
+end

data/README.md

@@ -1,6 +1,6 @@
 # IknowViewModels
 
-[![Build Status](https://travis-ci.org/iknow/iknow_view_models.svg?branch=master)](https://travis-ci.org/iknow/iknow_view_models)
+[![Build Status](https://circleci.com/gh/iknow/iknow_view_models.svg?style=svg)](https://circleci.com/gh/iknow/iknow_view_models/)
 
 ViewModels provide a means of encapsulating a collection of related data and specifying its JSON serialization.
 

data/gemfiles/rails_6_1.gemfile

@@ -0,0 +1,9 @@
+# This file was generated by Appraisal
+
+source 'https://rubygems.org'
+
+gem 'minitest-ci'
+gem 'activerecord', '~> 6.1.0'
+gem 'activesupport', '~> 6.1.0'
+
+gemspec path: '../'

data/iknow_view_models.gemspec

@@ -19,7 +19,7 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ['lib']
 
-  spec.required_ruby_version = 2.6
+  spec.required_ruby_version = '>= 2.7'
 
   spec.add_dependency 'activerecord', '>= 5.0'
   spec.add_dependency 'activesupport', '>= 5.0'

data/lib/iknow_view_models/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module IknowViewModels
-  VERSION = '3.2.13'
+  VERSION = '3.4.1'
 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
 
@@ -173,6 +173,17 @@ class ViewModel
       Jbuilder.new { |json| serialize(viewmodel, json, serialize_context: serialize_context) }.attributes!
     end
 
+    def serialize_from_cache(views, migration_versions: {}, locked: false, serialize_context:)
+      plural = views.is_a?(Array)
+      views = Array.wrap(views)
+
+      json_views, json_refs = ViewModel::ActiveRecord::Cache.render_viewmodels_from_cache(
+                    views, locked: locked, migration_versions: migration_versions, serialize_context: serialize_context)
+
+      json_views = json_views.first unless plural
+      return json_views, json_refs
+    end
+
     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
@@ -227,16 +238,16 @@ class ViewModel
       ViewModel::SerializeContext
     end
 
-    def new_serialize_context(*args)
-      serialize_context_class.new(*args)
+    def new_serialize_context(...)
+      serialize_context_class.new(...)
     end
 
     def deserialize_context_class
       ViewModel::DeserializeContext
     end
 
-    def new_deserialize_context(*args)
-      deserialize_context_class.new(*args)
+    def new_deserialize_context(...)
+      deserialize_context_class.new(...)
     end
 
     def accepts_schema_version?(schema_version)
@@ -256,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
@@ -343,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
@@ -348,7 +339,7 @@ class ViewModel::ActiveRecord < ViewModel::Record
       # associated here are join-table models; we need to get the far side out
       join_models = associated
 
-      if association_data.direct_viewmodel._list_member?
+      if association_data.ordered?
         attr = association_data.direct_viewmodel._list_attribute_name
         join_models = join_models.sort_by { |j| j[attr] }
       end
@@ -359,11 +350,16 @@ class ViewModel::ActiveRecord < ViewModel::Record
       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 = associated.map do |x|
+        associated_viewmodel_class = association_data.viewmodel_class_for_model!(x.class)
+        associated_viewmodel_class.new(x)
+      end
+
+      # If any associated type is a list member, they must all be
+      if association_data.ordered?
         associated_viewmodels.sort_by!(&:_list_attribute)
       end
+
       associated_viewmodels
 
     else

data/lib/view_model/active_record/association_data.rb

@@ -196,6 +196,21 @@ class ViewModel::ActiveRecord::AssociationData
     viewmodel_classes.first
   end
 
+  def ordered?
+    @ordered ||=
+      if through?
+        direct_viewmodel._list_member?
+      else
+        list_members = viewmodel_classes.map { |c| c._list_member? }.uniq
+
+        if list_members.size > 1
+          raise ArgumentError.new('Inconsistent associated views: mixed list membership')
+        end
+
+        list_members[0]
+      end
+  end
+
   def through?
     @indirect_association_name.present?
   end

data/lib/view_model/active_record/association_manipulation.rb

@@ -16,11 +16,13 @@ module ViewModel::ActiveRecord::AssociationManipulation
       associated_viewmodel = association_data.viewmodel_class
       direct_viewmodel     = association_data.direct_viewmodel
     else
+      raise ArgumentError.new('Polymorphic STI relationships not supported yet') if association_data.viewmodel_classes.size > 1
+
       associated_viewmodel = association.klass.try { |k| association_data.viewmodel_class_for_model!(k) }
       direct_viewmodel     = associated_viewmodel
     end
 
-    if direct_viewmodel._list_member?
+    if association_data.ordered?
       association_scope = association_scope.order(direct_viewmodel._list_attribute_name)
     end
 
@@ -34,10 +36,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
@@ -119,6 +118,8 @@ module ViewModel::ActiveRecord::AssociationManipulation
             direct_viewmodel_class = association_data.direct_viewmodel
             root_update_data, referenced_update_data = construct_indirect_append_updates(association_data, subtree_hashes, references)
           else
+            raise ArgumentError.new('Polymorphic STI relationships not supported yet') if association_data.viewmodel_classes.size > 1
+
             direct_viewmodel_class = association_data.viewmodel_class
             root_update_data, referenced_update_data = construct_direct_append_updates(association_data, subtree_hashes, references)
           end
@@ -130,7 +131,7 @@ module ViewModel::ActiveRecord::AssociationManipulation
           update_context.root_updates.each { |update| update.reparent_to = new_parent }
 
           # Set place in list.
-          if direct_viewmodel_class._list_member?
+          if association_data.ordered?
             new_positions = select_append_positions(association_data,
                                                     direct_viewmodel_class._list_attribute_name,
                                                     update_context.root_updates.count,
@@ -241,6 +242,8 @@ module ViewModel::ActiveRecord::AssociationManipulation
           direct_viewmodel = association_data.direct_viewmodel
           association_scope = association_scope.where(association_data.indirect_reflection.foreign_key => associated_id)
         else
+          raise ArgumentError.new('Polymorphic STI relationships not supported yet') if association_data.viewmodel_classes.size > 1
+
           # viewmodel type for current association: nil in case of empty polymorphic association
           direct_viewmodel = association.klass.try { |k| association_data.viewmodel_class_for_model!(k) }
 

data/lib/view_model/active_record/cache.rb

@@ -11,6 +11,30 @@ class ViewModel::ActiveRecord::Cache
 
   attr_reader :viewmodel_class
 
+  class << self
+    def render_viewmodels_from_cache(viewmodels, migration_versions: {}, locked: false, serialize_context: nil)
+      if viewmodels.empty?
+        return [], {}
+      end
+
+      ids = viewmodels.map(&:id)
+      # ideally the roots wouldn't have to all be the same type
+      viewmodel_class = viewmodels.first.class
+      serialize_context ||= viewmodel_class.new_serialize_context
+
+      render_from_cache(viewmodel_class, ids,
+                        initial_viewmodels: viewmodels,
+                        migration_versions: migration_versions,
+                        locked: locked,
+                        serialize_context: serialize_context)
+    end
+
+    def render_from_cache(viewmodel_class, ids, initial_viewmodels: nil, migration_versions: {}, locked: false, serialize_context: viewmodel_class.new_serialize_context)
+      worker = CacheWorker.new(migration_versions: migration_versions, serialize_context: serialize_context)
+      worker.render_from_cache(viewmodel_class, ids, initial_viewmodels: initial_viewmodels, locked: locked)
+    end
+  end
+
   # If cache_group: is specified, it must be a group of a single key: `:id`
   def initialize(viewmodel_class, cache_group: nil)
     @viewmodel_class = viewmodel_class
@@ -35,85 +59,98 @@ class ViewModel::ActiveRecord::Cache
     @cache_group.invalidate_cache_group
   end
 
+  # @deprecated Replaced by class methods
   def fetch_by_viewmodel(viewmodels, migration_versions: {}, locked: false, serialize_context: @viewmodel_class.new_serialize_context)
     ids = viewmodels.map(&:id)
     fetch(ids, initial_viewmodels: viewmodels, migration_versions: migration_versions, locked: locked, serialize_context: serialize_context)
   end
 
+  # @deprecated Replaced by class methods
   def fetch(ids, initial_viewmodels: nil, migration_versions: {}, locked: false, serialize_context: @viewmodel_class.new_serialize_context)
-    data_serializations = Array.new(ids.size)
-    worker = CacheWorker.new(migration_versions: migration_versions, serialize_context: serialize_context)
-
-    # If initial root viewmodels were provided, visit them to ensure that they
-    # are visible. Other than this, no traversal callbacks are performed, as a
-    # view may be resolved from the cache without ever loading its viewmodel.
-    # Note that if unlocked, these views will be reloaded as part of obtaining a
-    # share lock. If the visibility of this viewmodel can change due to edits,
-    # it is necessary to obtain a lock before calling `fetch`.
-    initial_viewmodels&.each do |v|
-      serialize_context.run_callback(ViewModel::Callbacks::Hook::BeforeVisit, v)
-      serialize_context.run_callback(ViewModel::Callbacks::Hook::AfterVisit, v)
-    end
+    self.class.render_from_cache(@viewmodel_class, ids,
+                                 initial_viewmodels: initial_viewmodels, locked: locked,
+                                 migration_versions: migration_versions, serialize_context: serialize_context)
+  end
 
-    # Collect input array positions for each id, allowing duplicates
-    positions = ids.each_with_index.with_object({}) do |(id, i), h|
-      (h[id] ||= []) << i
-    end
+  class CacheWorker
+    SENTINEL = Object.new
+    WorklistEntry = Struct.new(:ref_name, :viewmodel)
 
-    # Fetch duplicates only once
-    ids = positions.keys
+    attr_reader :migration_versions, :serialize_context, :resolved_references
 
-    # Load existing serializations from the cache
-    cached_serializations = worker.load_from_cache(self, ids)
-    cached_serializations.each do |id, data|
-      positions[id].each do |idx|
-        data_serializations[idx] = data
-      end
+    def initialize(migration_versions:, serialize_context:)
+      @worklist                = {} # Hash[type_name, Hash[id, WorklistEntry]]
+      @resolved_references     = {} # Hash[refname, json]
+      @migration_versions      = migration_versions
+      @migrated_cache_versions = {}
+      @serialize_context       = serialize_context
     end
 
-    # Resolve and serialize missing views
-    missing_ids = ids.to_set.subtract(cached_serializations.keys)
+    def render_from_cache(viewmodel_class, ids, initial_viewmodels: nil, locked: false)
+      viewmodel_class.transaction do
+        root_serializations = Array.new(ids.size)
 
-    # If initial viewmodels have been locked, we can serialize them for cache
-    #  misses.
-    available_viewmodels =
-      if locked
-        initial_viewmodels&.each_with_object({}) do |vm, h|
-          h[vm.id] = vm if missing_ids.include?(vm.id)
+        # Collect input array positions for each id, allowing duplicates
+        positions = ids.each_with_index.with_object({}) do |(id, i), h|
+          (h[id] ||= []) << i
         end
-      end
 
-    @viewmodel_class.transaction do
-      # Load remaining views and serialize
-      viewmodels = worker.find_and_preload_viewmodels(@viewmodel_class, missing_ids.to_a,
-                                                      available_viewmodels: available_viewmodels)
+        # If duplicates are specified, fetch each only once
+        ids = positions.keys
+
+        ids_to_render = ids.to_set
+
+        if viewmodel_class < CacheableView
+          # Load existing serializations from the cache
+          cached_serializations = load_from_cache(viewmodel_class.viewmodel_cache, ids)
+          cached_serializations.each do |id, data|
+            positions[id].each do |idx|
+              root_serializations[idx] = data
+            end
+          end
 
-      loaded_serializations = worker.serialize_and_cache(viewmodels)
-      loaded_serializations.each do |id, data|
-        positions[id].each do |idx|
-          data_serializations[idx] = data
+          ids_to_render.subtract(cached_serializations.keys)
+
+          # If initial root viewmodels were provided, call hooks on any
+          # viewmodels which were rendered from the cache to ensure that the
+          # root is visible (in isolation). Other than this, no traversal
+          # callbacks are performed for cache-rendered views. This particularly
+          # requires care for references: if a visible view may refer to
+          # non-visible cacheable views, those referenced views will not be
+          # access control checked.
+          initial_viewmodels&.each do |v|
+            next unless cached_serializations.has_key?(v.id)
+            serialize_context.run_callback(ViewModel::Callbacks::Hook::BeforeVisit, v)
+            serialize_context.run_callback(ViewModel::Callbacks::Hook::AfterVisit, v)
+          end
         end
-      end
 
-      # Resolve references
-      worker.resolve_references!
+        # Render remaining views. If initial viewmodels have been locked, we may
+        # use them to serialize from, otherwise we must reload with share lock
+        # in find_and_preload.
+        available_viewmodels =
+          if locked
+            initial_viewmodels&.each_with_object({}) do |vm, h|
+              h[vm.id] = vm if ids_to_render.include?(vm.id)
+            end
+          end
 
-      return data_serializations, worker.resolved_references
-    end
-  end
+        viewmodels = find_and_preload_viewmodels(viewmodel_class, ids_to_render.to_a,
+                                                 available_viewmodels: available_viewmodels)
 
-  class CacheWorker
-    SENTINEL = Object.new
-    WorklistEntry = Struct.new(:ref_name, :viewmodel)
+        loaded_serializations = serialize_and_cache(viewmodels)
 
-    attr_reader :migration_versions, :serialize_context, :resolved_references
+        loaded_serializations.each do |id, data|
+          positions[id].each do |idx|
+            root_serializations[idx] = data
+          end
+        end
 
-    def initialize(migration_versions:, serialize_context:)
-      @worklist                = {}
-      @resolved_references     = {}
-      @migration_versions      = migration_versions
-      @migrated_cache_versions = {}
-      @serialize_context       = serialize_context
+        # recursively resolve referenced views
+        self.resolve_references!
+
+        [root_serializations, self.resolved_references]
+      end
     end
 
     def resolve_references!
@@ -159,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])
@@ -218,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
@@ -242,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
@@ -298,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/cache/cacheable_view.rb

@@ -39,14 +39,6 @@ module ViewModel::ActiveRecord::Cache::CacheableView
     def viewmodel_cache
       @viewmodel_cache
     end
-
-    def serialize_from_cache(views, migration_versions: {}, locked: false, serialize_context:)
-      plural = views.is_a?(Array)
-      views = Array.wrap(views)
-      json_views, json_refs = viewmodel_cache.fetch_by_viewmodel(views, locked: locked, migration_versions: migration_versions, serialize_context: serialize_context)
-      json_views = json_views.first unless plural
-      return json_views, json_refs
-    end
   end
 
   # Clear the cache if the view or its nested children were changed during

data/lib/view_model/active_record/collection_nested_controller.rb

@@ -22,23 +22,23 @@ module ViewModel::ActiveRecord::CollectionNestedController
   extend ActiveSupport::Concern
   include ViewModel::ActiveRecord::NestedControllerBase
 
-  def index_associated(scope: nil, serialize_context: new_serialize_context, &block)
-    show_association(scope: scope, serialize_context: serialize_context, &block)
+  def index_associated(scope: nil, serialize_context: new_serialize_context, lock_owner: nil, &block)
+    show_association(scope: scope, serialize_context: serialize_context, lock_owner: lock_owner, &block)
   end
 
   # Deserialize items of the associated type and associate them with the owner,
   # replacing previously associated items.
-  def replace(serialize_context: new_serialize_context, deserialize_context: new_deserialize_context, &block)
-    write_association(serialize_context: serialize_context, deserialize_context: deserialize_context, &block)
+  def replace(serialize_context: new_serialize_context, deserialize_context: new_deserialize_context, lock_owner: nil, &block)
+    write_association(serialize_context: serialize_context, deserialize_context: deserialize_context, lock_owner: lock_owner, &block)
   end
 
-  def disassociate_all(serialize_context: new_serialize_context, deserialize_context: new_deserialize_context)
-    destroy_association(true, serialize_context: serialize_context, deserialize_context: deserialize_context)
+  def disassociate_all(serialize_context: new_serialize_context, deserialize_context: new_deserialize_context, lock_owner: nil)
+    destroy_association(true, serialize_context: serialize_context, deserialize_context: deserialize_context, lock_owner: lock_owner)
   end
 
   # Deserialize items of the associated type and append them to the owner's
   # collection.
-  def append(serialize_context: new_serialize_context, deserialize_context: new_deserialize_context)
+  def append(serialize_context: new_serialize_context, deserialize_context: new_deserialize_context, lock_owner: nil)
     assoc_view = nil
     pre_rendered = owner_viewmodel.transaction do
       update_hash, refs = parse_viewmodel_updates
@@ -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, 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
@@ -69,9 +69,9 @@ module ViewModel::ActiveRecord::CollectionNestedController
     assoc_view
   end
 
-  def disassociate(serialize_context: new_serialize_context, deserialize_context: new_deserialize_context)
+  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, 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)
@@ -76,7 +76,7 @@ module ViewModel::ActiveRecord::Controller
     end
   end
 
-  def prerender_viewmodel(*)
+  def prerender_viewmodel(...)
     super do |jbuilder|
       yield(jbuilder) if block_given?
 

data/lib/view_model/active_record/nested_controller_base.rb

@@ -9,13 +9,13 @@ module ViewModel::ActiveRecord::NestedControllerBase
 
   protected
 
-  def show_association(scope: nil, serialize_context: new_serialize_context)
+  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, 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?
 
@@ -27,12 +27,12 @@ module ViewModel::ActiveRecord::NestedControllerBase
     associated_views
   end
 
-  def write_association(serialize_context: new_serialize_context, deserialize_context: new_deserialize_context)
+  def write_association(serialize_context: new_serialize_context, deserialize_context: new_deserialize_context, lock_owner: nil)
     association_view = nil
     pre_rendered = owner_viewmodel.transaction do
       update_hash, refs = parse_viewmodel_updates
 
-      owner_view = owner_viewmodel.find(owner_viewmodel_id, eager_include: false, 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
@@ -49,7 +49,11 @@ module ViewModel::ActiveRecord::NestedControllerBase
     association_view
   end
 
-  def destroy_association(collection, serialize_context: new_serialize_context, deserialize_context: new_deserialize_context)
+  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)
+    end
+
     empty_update = collection ? [] : nil
     owner_viewmodel.deserialize_from_view(owner_update_hash(empty_update),
                                           deserialize_context: deserialize_context)

data/lib/view_model/active_record/singular_nested_controller.rb

@@ -20,15 +20,15 @@ module ViewModel::ActiveRecord::SingularNestedController
   extend ActiveSupport::Concern
   include ViewModel::ActiveRecord::NestedControllerBase
 
-  def show_associated(scope: nil, serialize_context: new_serialize_context, deserialize_context: new_deserialize_context, &block)
-    show_association(scope: scope, serialize_context: serialize_context, &block)
+  def show_associated(scope: nil, serialize_context: new_serialize_context, lock_owner: nil, &block)
+    show_association(scope: scope, serialize_context: serialize_context, lock_owner: lock_owner, &block)
   end
 
-  def create_associated(serialize_context: new_serialize_context, deserialize_context: new_deserialize_context, &block)
-    write_association(serialize_context: serialize_context, deserialize_context: deserialize_context, &block)
+  def create_associated(serialize_context: new_serialize_context, deserialize_context: new_deserialize_context, lock_owner: nil, &block)
+    write_association(serialize_context: serialize_context, deserialize_context: deserialize_context, lock_owner: lock_owner, &block)
   end
 
-  def destroy_associated(serialize_context: new_serialize_context, deserialize_context: new_deserialize_context)
-    destroy_association(false, serialize_context: serialize_context, deserialize_context: deserialize_context)
+  def destroy_associated(serialize_context: new_serialize_context, deserialize_context: new_deserialize_context, lock_owner: nil)
+    destroy_association(false, serialize_context: serialize_context, deserialize_context: deserialize_context, lock_owner: lock_owner)
   end
 end

data/lib/view_model/active_record/update_operation.rb

@@ -450,14 +450,13 @@ class ViewModel::ActiveRecord
       parent_data = ParentData.new(association_data.direct_reflection.inverse_of, viewmodel)
 
       # load children already attached to this model
-      child_viewmodel_class = association_data.viewmodel_class
-
       previous_child_viewmodels =
         model.public_send(association_data.direct_reflection.name).map do |child_model|
+          child_viewmodel_class = association_data.viewmodel_class_for_model!(child_model.class)
           child_viewmodel_class.new(child_model)
         end
 
-      if child_viewmodel_class._list_member?
+      if association_data.ordered?
         previous_child_viewmodels.sort_by!(&:_list_attribute)
       end
 
@@ -604,7 +603,7 @@ class ViewModel::ActiveRecord
       # need to be updated anyway since their parent pointer will change.
       new_positions = Array.new(resolved_children.length)
 
-      if association_data.viewmodel_class._list_member?
+      if association_data.ordered?
         set_position = ->(index, pos) { new_positions[index] = pos }
 
         get_previous_position = ->(index) do
@@ -802,7 +801,7 @@ class ViewModel::ActiveRecord
         ReferencedCollectionMember.new(indirect_viewmodel_ref, direct_vm)
       end
 
-      if direct_viewmodel_class._list_member?
+      if association_data.ordered?
         previous_members.sort_by!(&:position)
       end
 
@@ -868,7 +867,7 @@ class ViewModel::ActiveRecord
         viewmodel.association_changed!(association_data.association_name)
       end
 
-      if direct_viewmodel_class._list_member?
+      if association_data.ordered?
         ActsAsManualList.update_positions(target_collection.members)
       end
 

data/lib/view_model/migrator.rb

@@ -102,11 +102,18 @@ class ViewModel
   class DownMigrator < Migrator
     private
 
-    def migrate_viewmodel!(view_name, _, view_hash, references)
+    def migrate_viewmodel!(view_name, source_version, view_hash, references)
       path = @paths[view_name]
       return false unless path
 
-      required_version, _current_version = @versions[view_name]
+      # In a serialized output, the source version should always be the present
+      # and the current version, unless already modified by a parent migration
+      required_version, current_version = @versions[view_name]
+      return false if source_version == required_version
+
+      unless source_version == current_version
+        raise ViewModel::Migration::UnspecifiedVersionError.new(view_name, source_version)
+      end
 
       path.reverse_each do |migration|
         migration.down(view_hash, references)

data/lib/view_model/traversal_context.rb

@@ -24,8 +24,8 @@ class ViewModel::TraversalContext
 
   delegate :access_control, :callbacks, to: :shared_context
 
-  def self.new_child(*args)
-    self.allocate.tap { |c| c.initialize_as_child(*args) }
+  def self.new_child(...)
+    self.allocate.tap { |c| c.initialize_as_child(...) }
   end
 
   def initialize(shared_context: nil, **shared_context_params)

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

@@ -168,26 +168,61 @@ class ViewModel::ActiveRecord::BelongsToTest < ActiveSupport::TestCase
 
   class GCTests < ActiveSupport::TestCase
     include ARVMTestUtilities
-    include ViewModelSpecHelpers::ParentAndBelongsToChild
+    include ViewModelSpecHelpers::Base
 
     def model_attributes
       super.merge(
         schema: ->(t) do
+          t.integer :destroyed_child_id
           t.integer :deleted_child_id
           t.integer :ignored_child_id
+          t.foreign_key :children, column: :destroyed_child_id
+          t.foreign_key :children, column: :deleted_child_id
+          t.foreign_key :children, column: :ignored_child_id
         end,
         model: ->(_m) do
-          belongs_to :deleted_child, class_name: Child.name, dependent: :delete
-          belongs_to :ignored_child, class_name: Child.name
+          belongs_to :destroyed_child, class_name: Child.name, inverse_of: :destroyed_model, dependent: :destroy
+          belongs_to :deleted_child,   class_name: Child.name, inverse_of: :deleted_model,   dependent: :delete
+          belongs_to :ignored_child,   class_name: Child.name, inverse_of: :ignored_model
         end,
         viewmodel: ->(_v) do
-          associations :deleted_child, :ignored_child
+          associations :destroyed_child, :deleted_child, :ignored_child
         end)
     end
 
-    # test belongs_to garbage collection - dependent: delete_all
-    def test_gc_dependent_delete_all
+    def child_attributes
+      super.merge(
+        model: ->(_m) do
+          has_one :destroyed_model, class_name: 'Model', inverse_of: :destroyed_child, foreign_key: 'destroyed_child_id'
+          has_one :deleted_model, class_name: 'Model', inverse_of: :deleted_child, foreign_key: 'deleted_child_id'
+          has_one :ignored_model, class_name: 'Model', inverse_of: :ignored_child, foreign_key: 'ignored_child_id'
+        end)
+    end
+
+    def viewmodel_class
+      child_viewmodel_class
+      super
+    end
+
+    # test belongs_to garbage collection - dependent: destroy
+    def test_gc_dependent_destroy
+      model = model_class.create(destroyed_child: Child.new(name: 'one'))
+
+      old_child = model.destroyed_child
+
+      alter_by_view!(ModelView, model) do |ov, _refs|
+        ov['destroyed_child'] = { '_type' => 'Child', 'name' => 'two' }
+      end
+
+      assert_equal('two', model.destroyed_child.name)
+      refute_equal(old_child, model.destroyed_child)
+      assert(Child.where(id: old_child.id).blank?)
+    end
+
+    # test belongs_to garbage collection - dependent: delete
+    def test_gc_dependent_delete
       model = model_class.create(deleted_child: Child.new(name: 'one'))
+
       old_child = model.deleted_child
 
       alter_by_view!(ModelView, model) do |ov, _refs|

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

@@ -135,8 +135,8 @@ class ViewModel::ActiveRecord
       [data, refs]
     end
 
-    def fetch_with_cache
-      viewmodel_class.viewmodel_cache.fetch([root.id], migration_versions: migration_versions)
+    def fetch_with_cache(**rest)
+      ViewModel::ActiveRecord::Cache.render_from_cache(viewmodel_class, [root.id], migration_versions: migration_versions, **rest)
     end
 
     def serialize_with_cache
@@ -206,6 +206,19 @@ class ViewModel::ActiveRecord
 
       describe 'without migrations' do
         include BehavesLikeACache
+
+        it 'returns the right serialization with provided initial viewmodel' do
+          fetched_result = parse_result(fetch_with_cache(initial_viewmodels: [root_view]))
+
+          value(fetched_result).must_equal(serialize_from_database)
+        end
+
+        it 'returns the right serialization with provided locked initial viewmodel' do
+          locked_root_view = viewmodel_class.new(model_class.lock("FOR SHARE").find(root.id))
+          fetched_result = parse_result(fetch_with_cache(initial_viewmodels: [locked_root_view], locked: true))
+
+          value(fetched_result).must_equal(serialize_from_database)
+        end
       end
 
       describe 'with migrations' do
@@ -337,8 +350,8 @@ class ViewModel::ActiveRecord
             [data, refs]
           end
 
-          def fetch_with_cache
-            viewmodel_class.viewmodel_cache.fetch([root.id, root2.id])
+          def fetch_with_cache(**rest)
+            ViewModel::ActiveRecord::Cache.render_from_cache(viewmodel_class, [root.id, root2.id], **rest)
           end
 
           it 'merges matching shared references between cache hits and misses' do
@@ -376,8 +389,8 @@ class ViewModel::ActiveRecord
     end
 
     describe 'when fetched by viewmodel' do
-      def fetch_with_cache
-        viewmodel_class.viewmodel_cache.fetch_by_viewmodel([root_view])
+      def fetch_with_cache(**rest)
+        ViewModel::ActiveRecord::Cache.render_viewmodels_from_cache([root_view], **rest)
       end
 
       include CacheableParentAndChildren

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

@@ -808,6 +808,39 @@ class ViewModel::ActiveRecord::HasManyTest < ActiveSupport::TestCase
     assert_match(/Removed entities must have only _type and id fields/, ex.message)
   end
 
+  def test_functional_update_move
+    c1_id, c2_id, c3_id = @model1.children.pluck(:id)
+    c4_id, c5_id = @model2.children.pluck(:id)
+
+    remove_fupdate = build_fupdate do
+      remove([{ '_type' => 'Child', 'id' => c2_id }])
+    end
+
+    append_fupdate = build_fupdate do
+      append([{ '_type' => 'Child', 'id' => c2_id }])
+    end
+
+    move_view = [
+      {
+        '_type' => 'Model',
+        'id'       => @model1.id,
+        'children' => remove_fupdate
+      },
+      {
+        '_type' => 'Model',
+        'id'       => @model2.id,
+        'children' => append_fupdate
+      }
+    ]
+
+    viewmodel_class.deserialize_from_view(move_view)
+    @model1.reload
+    @model2.reload
+
+    assert_equal([c1_id, c3_id], @model1.children.pluck(:id))
+    assert_equal([c4_id, c5_id, c2_id], @model2.children.pluck(:id))
+  end
+
   def test_functional_update_update_success
     c1_id, c2_id, c3_id = @model1.children.pluck(:id)
 
@@ -865,6 +898,131 @@ class ViewModel::ActiveRecord::HasManyTest < ActiveSupport::TestCase
     assert_match(/Duplicate functional update targets\b.*\bChild\b/, ex.message)
   end
 
+  describe 'sti polymorphic children' do
+    def setup
+      child_viewmodel_class
+      dog_viewmodel_class
+      cat_viewmodel_class
+      enable_logging!
+    end
+
+    def child_attributes
+      super().merge(schema: ->(t) do
+                      t.string :type, null: false
+                      t.integer :dog_number
+                      t.integer :cat_number
+                    end)
+    end
+
+    def subject_association_features
+      { viewmodels: [:Dog, :Cat] }
+    end
+
+    def dog_viewmodel_class
+      @dog_viewmodel_class ||= define_viewmodel_class(:Dog, namespace: namespace, viewmodel_base: viewmodel_base, model_base: child_model_class) do
+        define_model {}
+        define_viewmodel do
+          attribute :dog_number
+          acts_as_list :position
+        end
+      end
+    end
+
+    def cat_viewmodel_class
+      @cat_viewmodel_class ||= define_viewmodel_class(:Cat, namespace: namespace, viewmodel_base: viewmodel_base, model_base: child_model_class) do
+        define_model {}
+        define_viewmodel do
+          attribute :cat_number
+          acts_as_list :position
+        end
+      end
+    end
+
+    def new_model
+      model_class.new(name: 'p', children: [Dog.new(position: 1, dog_number: 1), Cat.new(position: 2, cat_number: 2)])
+    end
+
+    it 'creates the model structure' do
+      m = create_model!
+      m.reload
+      assert(m.is_a?(Model))
+      children = m.children.order(:position)
+      assert_equal(2, children.size)
+      assert_kind_of(Dog, children[0])
+      assert_kind_of(Cat, children[1])
+    end
+
+    it 'serializes' do
+      model = create_model!
+      view = serialize(ModelView.new(model))
+      expected_view = {
+        'id' => 1, '_type' => 'Model', '_version' => 1, 'name' => 'p',
+        'children' => [
+          { 'id' => 1, '_type' => 'Dog', '_version' => 1, 'dog_number' => 1 },
+          { 'id' => 2, '_type' => 'Cat', '_version' => 1, 'cat_number' => 2 },
+        ]
+      }
+      assert_equal(expected_view, view)
+    end
+
+    it 'creates from view' do
+      view = {
+        '_type' => 'Model',
+        'name' => 'p',
+        'children' => [
+          { '_type' => 'Dog', 'dog_number' => 1 },
+          { '_type' => 'Cat', 'cat_number' => 2 },
+        ]
+      }
+
+      pv = ModelView.deserialize_from_view(view)
+      p = pv.model
+
+      assert(!p.changed?)
+      assert(!p.new_record?)
+
+      assert_equal('p', p.name)
+
+      children = p.children.order(:position)
+
+      assert_equal(2, children.size)
+      assert_kind_of(Dog, children[0])
+      assert_equal(1, children[0].dog_number)
+      assert_kind_of(Cat, children[1])
+      assert_equal(2, children[1].cat_number)
+    end
+
+    it 'updates with reordering' do
+      model = create_model!
+
+      alter_by_view!(ModelView, model) do |view, _refs|
+        view['children'].reverse!
+      end
+
+      children = model.children.order(:position)
+      assert_equal(2, children.size)
+      assert_kind_of(Cat, children[0])
+      assert_equal(2, children[0].cat_number)
+      assert_kind_of(Dog, children[1])
+      assert_equal(1, children[1].dog_number)
+    end
+
+    it 'functional updates' do
+      model = create_model!
+
+      alter_by_view!(ModelView, model) do |view, refs|
+        view['children'] = build_fupdate do
+          append([{ '_type' => 'Cat', 'cat_number' => 100 }])
+        end
+      end
+
+      assert_equal(3, model.children.size)
+      new_child = model.children.order(:position).last
+      assert_kind_of(Cat, new_child)
+      assert_equal(100, new_child.cat_number)
+    end
+  end
+
   describe 'owned reference children' do
     def child_attributes
       super.merge(viewmodel: ->(_v) { root! })

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
 

data/test/unit/view_model/callbacks_test.rb

@@ -494,7 +494,7 @@ class ViewModel::CallbacksTest < ActiveSupport::TestCase
       let(:callback) { CallbackCrasher.new }
 
       it 'raises the callback error' do
-        proc { serialize(vm) }.must_raise(Crash)
+        _(-> { serialize(vm) }).must_raise(Crash)
       end
 
       describe 'with an access control that rejects' do
@@ -503,7 +503,7 @@ class ViewModel::CallbacksTest < ActiveSupport::TestCase
         end
 
         it 'fails access control first' do
-          proc { serialize(vm) }.must_raise(ViewModel::AccessControlError)
+          _(-> { serialize(vm) }).must_raise(ViewModel::AccessControlError)
         end
 
         describe 'and a view-mutating callback that crashes' do
@@ -514,7 +514,7 @@ class ViewModel::CallbacksTest < ActiveSupport::TestCase
           let(:callback) { MutatingCrasher.new }
 
           it 'raises the callback error first' do
-            proc { serialize(vm) }.must_raise(Crash)
+            _(-> { serialize(vm) }).must_raise(Crash)
           end
         end
       end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: iknow_view_models
 version: !ruby/object:Gem::Version
-  version: 3.2.13
+  version: 3.4.1
 platform: ruby
 authors:
 - iKnow Team
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-02-19 00:00:00.000000000 Z
+date: 2021-06-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -379,6 +379,7 @@ files:
 - Rakefile
 - gemfiles/rails_5_2.gemfile
 - gemfiles/rails_6_0.gemfile
+- gemfiles/rails_6_1.gemfile
 - iknow_view_models.gemspec
 - lib/iknow_view_models.rb
 - lib/iknow_view_models/railtie.rb
@@ -485,14 +486,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.7'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.1.6
 signing_key: 
 specification_version: 4
 summary: ViewModels provide a means of encapsulating a collection of related data