iknow_view_models 3.2.10 → 3.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 280c8d764916ec30bb500e2f0e982131416d27ea51a3a25d1cd7e3908bb4ad5b
-  data.tar.gz: 50d202b87cde141ac58ad82a5de6b73332f9b60a71c23fbbd378ba6c1def8184
+  metadata.gz: 680a05c75dacc9f5380b920439650249c11d04ab3f1b685e88081414fc4a72d3
+  data.tar.gz: 7328f45000837430c6627ecb1f916f529172b53fe0266aba8a0d02c48d131935
 SHA512:
-  metadata.gz: 51333e3292118de4b71e8869ea4843be804ad2d24ce0c7296918c3f09b0df93740561afeb466b4a8874a1b5b667922b664745e994151b8fe47ce458bb087d14d
-  data.tar.gz: 999d1feb717d4ef5ce11b400abf67772c5b70fd7c91cf3e328f14e5ff66a373b7c98aa5f701cb436cf4bf7df448bc553fca96131de570cead59734e8131c4788
+  metadata.gz: 5ae7508982f9e95354f137e84e8bb844b5373f5236526c7640276cc93f3bdb78846864a0cc35209ded4cd24963bbab248010849bfe6cbabcf8c01046288c97bd
+  data.tar.gz: 459318dca0636a4381b96e83ce6d260380b74106834b6d60b88af886363c846233c9dc2547e082e009b799d8e674d2cf48811bd49765d3bd2e2a4f2f8e307882

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.10'
+  VERSION = '3.3.0'
 end

data/lib/view_model.rb

@@ -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)
@@ -377,3 +388,4 @@ require 'view_model/deserialize_context'
 require 'view_model/changes'
 require 'view_model/schemas'
 require 'view_model/error_view'
+require 'view_model/garbage_collection'

data/lib/view_model/active_record.rb

@@ -182,9 +182,14 @@ class ViewModel::ActiveRecord < ViewModel::Record
     end
 
     # Constructs a preload specification of the required models for
-    # serializing/deserializing this view.
-    def eager_includes(serialize_context: new_serialize_context, include_referenced: true)
+    # 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: [])
       association_specs = {}
+
+      return nil if vm_path.count(self) > 2
+
+      child_path = vm_path + [self]
       _members.each do |assoc_name, association_data|
         next unless association_data.is_a?(AssociationData)
         next if association_data.external?
@@ -201,7 +206,7 @@ class ViewModel::ActiveRecord < ViewModel::Record
         case
         when association_data.through?
           viewmodel = association_data.direct_viewmodel
-          children = viewmodel.eager_includes(serialize_context: child_context, include_referenced: include_referenced)
+          children = viewmodel.eager_includes(serialize_context: child_context, include_referenced: include_referenced, vm_path: child_path)
 
         when !include_referenced && association_data.referenced?
           children = nil # Load up to the root viewmodel, but no further
@@ -210,13 +215,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)
+            children_by_klass[klass] = vm_class.eager_includes(serialize_context: child_context, include_referenced: include_referenced, vm_path: child_path)
           end
           children = DeepPreloader::PolymorphicSpec.new(children_by_klass)
 
         else
           viewmodel = association_data.viewmodel_class
-          children = viewmodel.eager_includes(serialize_context: child_context, include_referenced: include_referenced)
+          children = viewmodel.eager_includes(serialize_context: child_context, include_referenced: include_referenced, vm_path: child_path)
         end
 
         association_specs[association_data.direct_reflection.name.to_s] = children
@@ -340,12 +345,15 @@ class ViewModel::ActiveRecord < ViewModel::Record
 
     case
     when association_data.through?
-      # associated here are join_table models; we need to get the far side out
+      # associated here are join-table models; we need to get the far side out
+      join_models = associated
+
       if association_data.direct_viewmodel._list_member?
-        associated.order(association_data.direct_viewmodel._list_attribute_name)
+        attr = association_data.direct_viewmodel._list_attribute_name
+        join_models = join_models.sort_by { |j| j[attr] }
       end
 
-      associated.map do |through_model|
+      join_models.map do |through_model|
         model = through_model.public_send(association_data.indirect_reflection.name)
         association_data.viewmodel_class_for_model!(model.class).new(model)
       end

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!
@@ -177,28 +214,27 @@ class ViewModel::ActiveRecord::Cache
           ViewModel.serialize(viewmodel, json, serialize_context: serialize_context)
         end
 
+        # viewmodels referenced from roots
         referenced_viewmodels = serialize_context.extract_referenced_views!
 
         if migration_versions.present?
           migrator = ViewModel::DownMigrator.new(migration_versions)
 
-          # This migration isn't given the chance to inspect/alter the contents
-          # of referenced views, only their presence: it's strictly less
-          # powerful than migrations on a fully serialized tree, as the only
-          # possible action on a referenced child is to delete it. The effect of
-          # this is that for sufficiently complex migrations where a parent view
-          # must introduce children or alter the contents of its referenced
-          # children, we may have to avoid caching while the migration is in
-          # use.
+          # This migration isn't able to affect the contents of referenced
+          # views, only their presence. The references will be themselves
+          # rendered (and migrated) independently later. We mark the dummy
+          # references provided to exclude their partial contents from being
+          # themselves migrated.
           dummy_references = referenced_viewmodels.transform_values do |ref_vm|
             {
               ViewModel::TYPE_ATTRIBUTE    => ref_vm.class.view_name,
               ViewModel::VERSION_ATTRIBUTE => ref_vm.class.schema_version,
               ViewModel::ID_ATTRIBUTE      => ref_vm.id,
+              ViewModel::Migrator::EXCLUDE_FROM_MIGRATION => true,
             }.freeze
           end
 
-          migrator.migrate!(builder.attributes!, references: dummy_references)
+          migrator.migrate!({ 'data' => builder.attributes!, 'references' => dummy_references })
 
           # Removed dummy references can be removed from referenced_viewmodels.
           referenced_viewmodels.keep_if { |k, _| dummy_references.has_key?(k) }

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/controller.rb

@@ -71,12 +71,12 @@ module ViewModel::ActiveRecord::Controller
     super.tap do |update_hash, refs|
       if migration_versions.present?
         migrator = ViewModel::UpMigrator.new(migration_versions)
-        migrator.migrate!([update_hash, refs], references: refs)
+        migrator.migrate!({ 'data' => update_hash, 'references' => refs })
       end
     end
   end
 
-  def prerender_viewmodel(*)
+  def prerender_viewmodel(...)
     super do |jbuilder|
       yield(jbuilder) if block_given?
 
@@ -84,7 +84,7 @@ module ViewModel::ActiveRecord::Controller
       if migration_versions.present?
         tree = jbuilder.attributes!
         migrator = ViewModel::DownMigrator.new(migration_versions)
-        migrator.migrate!(tree, references: tree['references'])
+        migrator.migrate!(tree)
       end
     end
   end

data/lib/view_model/garbage_collection.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+class ViewModel::GarbageCollection
+  class << self
+    def garbage_collect_references!(serialization)
+      return unless serialization.has_key?('references')
+
+      roots      = serialization.except('references')
+      references = serialization['references']
+
+      worklist = Set.new(collect_references(roots))
+      visited  = Set.new
+
+      while (live = worklist.first)
+        worklist.delete(live)
+        visited << live
+        collect_references(references[live]) do |ref|
+          worklist << ref unless visited.include?(ref)
+        end
+      end
+
+      references.keep_if { |ref, _val| visited.include?(ref) }
+    end
+
+    private
+
+    ## yield each reference encountered in tree
+    def collect_references(tree, &block)
+      return enum_for(__method__, tree) unless block_given?
+
+      case tree
+      when Hash
+        if tree.size == 1 && (ref = tree[ViewModel::REFERENCE_ATTRIBUTE])
+          block.(ref)
+        else
+          tree.each_value { |t| collect_references(t, &block) }
+        end
+      when Array
+        tree.each { |t| collect_references(t, &block) }
+      end
+    end
+  end
+end

data/lib/view_model/migrator.rb

@@ -2,6 +2,8 @@
 
 class ViewModel
   class Migrator
+    EXCLUDE_FROM_MIGRATION = '_exclude_from_migration'
+
     class << self
       def migrated_deep_schema_version(viewmodel_class, required_versions, include_referenced: true)
         deep_schema_version = viewmodel_class.deep_schema_version(include_referenced: include_referenced)
@@ -34,27 +36,37 @@ class ViewModel
       end
     end
 
-    def migrate!(node, references:)
+    def migrate!(serialization)
+      migrate_tree!(serialization, references: serialization['references'] || {})
+      GarbageCollection.garbage_collect_references!(serialization)
+    end
+
+    private
+
+    def migrate_tree!(node, references:)
       case node
       when Hash
         if (type = node[ViewModel::TYPE_ATTRIBUTE])
           version = node[ViewModel::VERSION_ATTRIBUTE]
 
+          # We allow subtrees to be excluded from migration. This is used
+          # internally to permit stub references that are not a full
+          # serialization of the referenced type: see ViewModel::Cache.
+          return if node[EXCLUDE_FROM_MIGRATION]
+
           if migrate_viewmodel!(type, version, node, references)
             node[ViewModel::MIGRATED_ATTRIBUTE] = true
           end
         end
 
         node.each_value do |child|
-          migrate!(child, references: references)
+          migrate_tree!(child, references: references)
         end
       when Array
-        node.each { |child| migrate!(child, references: references) }
+        node.each { |child| migrate_tree!(child, references: references) }
       end
     end
 
-    private
-
     def migrate_viewmodel!(_view_name, _version, _view_hash, _references)
       raise RuntimeError.new('abstract method')
     end

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/helpers/viewmodel_spec_helpers.rb

@@ -141,10 +141,10 @@ module ViewModelSpecHelpers
     end
   end
 
-  module ParentAndBelongsToChildWithMigration
+  module ParentAndChildMigrations
     extend ActiveSupport::Concern
-    include ViewModelSpecHelpers::ParentAndBelongsToChild
-    def model_attributes
+  
+  def model_attributes
       super.merge(
         schema: ->(t) { t.integer :new_field, default: 1, null: false },
         viewmodel: ->(_v) {
@@ -206,6 +206,12 @@ module ViewModelSpecHelpers
     end
   end
 
+  module ParentAndBelongsToChildWithMigration
+    extend ActiveSupport::Concern
+    include ViewModelSpecHelpers::ParentAndBelongsToChild
+    include ViewModelSpecHelpers::ParentAndChildMigrations
+  end
+
   module ParentAndSharedBelongsToChild
     extend ActiveSupport::Concern
     include ViewModelSpecHelpers::ParentAndBelongsToChild

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

@@ -122,7 +122,7 @@ class ViewModel::ActiveRecord
 
       if migration_versions.present?
         migrator = ViewModel::DownMigrator.new(migration_versions)
-        migrator.migrate!([data, refs], references: refs)
+        migrator.migrate!({ 'data' => data, 'references' => refs })
       end
 
       [data, refs]
@@ -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_through_test.rb

@@ -101,8 +101,10 @@ class ViewModel::ActiveRecord::HasManyThroughTest < ActiveSupport::TestCase
     @tag1, @tag2, @tag3 = (1..3).map { |x| Tag.create!(name: "tag#{x}") }
 
     @parent1 = Parent.create(name: 'p1',
-                             parents_tags: [ParentsTag.new(tag: @tag1, position: 1.0),
-                                            ParentsTag.new(tag: @tag2, position: 2.0),])
+                             parents_tags: [
+                               ParentsTag.new(tag: @tag2, position: 2.0),
+                               ParentsTag.new(tag: @tag1, position: 1.0),
+                             ])
 
     enable_logging!
   end

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

@@ -24,25 +24,39 @@ class ViewModel::ActiveRecord::Migration < ActiveSupport::TestCase
   let(:up_migrator) { ViewModel::UpMigrator.new(migration_versions) }
 
   def migrate!
-    migrator.migrate!(subject, references: {})
+    migrator.migrate!(subject)
   end
 
-  let(:current_serialization) { ViewModel.serialize_to_hash(viewmodel) }
+  let(:current_serialization) do
+    ctx = viewmodel_class.new_serialize_context
+    view = ViewModel.serialize_to_hash(viewmodel, serialize_context: ctx)
+    refs = ctx.serialize_references_to_hash
+    { 'data' => view, 'references' => refs }
+  end
 
-  let(:v2_serialization) do
+  let(:v2_serialization_data) do
     {
-      ViewModel::TYPE_ATTRIBUTE => viewmodel_class.view_name,
-      ViewModel::VERSION_ATTRIBUTE => 2,
-      ViewModel::ID_ATTRIBUTE => viewmodel.id,
-      'name' => viewmodel.name,
-      'old_field' => 1,
-      'child' => {
-        ViewModel::TYPE_ATTRIBUTE => child_viewmodel_class.view_name,
+        ViewModel::TYPE_ATTRIBUTE => viewmodel_class.view_name,
         ViewModel::VERSION_ATTRIBUTE => 2,
-        ViewModel::ID_ATTRIBUTE => viewmodel.child.id,
-        'name' => viewmodel.child.name,
-        'former_field' => 'former_value',
-      },
+        ViewModel::ID_ATTRIBUTE => viewmodel.id,
+        'name' => viewmodel.name,
+        'old_field' => 1,
+        'child' => {
+          ViewModel::TYPE_ATTRIBUTE => child_viewmodel_class.view_name,
+          ViewModel::VERSION_ATTRIBUTE => 2,
+          ViewModel::ID_ATTRIBUTE => viewmodel.child.id,
+          'name' => viewmodel.child.name,
+          'former_field' => 'former_value',
+        },
+    }
+  end
+
+  let(:v2_serialization_references) { {} }
+
+  let(:v2_serialization) do
+    {
+      'data' => v2_serialization_data,
+      'references' => v2_serialization_references,
     }
   end
 
@@ -56,14 +70,15 @@ class ViewModel::ActiveRecord::Migration < ActiveSupport::TestCase
       let(:expected_result) do
         v2_serialization.deep_merge(
           {
-            ViewModel::MIGRATED_ATTRIBUTE => true,
-            'old_field' => -1,
-            'child' => {
+            'data' => {
               ViewModel::MIGRATED_ATTRIBUTE => true,
-              'former_field' => 'reconstructed',
+              'old_field' => -1,
+              'child' => {
+                ViewModel::MIGRATED_ATTRIBUTE => true,
+                'former_field' => 'reconstructed',
+              },
             },
-          },
-        )
+          })
       end
 
       it 'migrates' do
@@ -85,15 +100,21 @@ class ViewModel::ActiveRecord::Migration < ActiveSupport::TestCase
 
     describe 'upwards' do
       let(:migrator) { up_migrator }
-      let(:subject) { v2_serialization.deep_dup }
+      let(:subject_data) { v2_serialization_data.deep_dup }
+      let(:subject_references) { v2_serialization_references.deep_dup }
+      let(:subject) { { 'data' => subject_data, 'references' => subject_references } }
 
       let(:expected_result) do
         current_serialization.deep_merge(
-          ViewModel::MIGRATED_ATTRIBUTE => true,
-          'new_field' => 3,
-          'child' => {
-            ViewModel::MIGRATED_ATTRIBUTE => true,
-          },
+          {
+            'data' => {
+              ViewModel::MIGRATED_ATTRIBUTE => true,
+              'new_field' => 3,
+              'child' => {
+                ViewModel::MIGRATED_ATTRIBUTE => true,
+              },
+            },
+          }
         )
       end
 
@@ -104,9 +125,8 @@ class ViewModel::ActiveRecord::Migration < ActiveSupport::TestCase
       end
 
       describe 'with version unspecified' do
-        let(:subject) do
-          v2_serialization
-            .except(ViewModel::VERSION_ATTRIBUTE)
+        let(:subject_data) do
+          v2_serialization_data.except(ViewModel::VERSION_ATTRIBUTE)
         end
 
         it 'treats it as the requested version' do
@@ -116,8 +136,8 @@ class ViewModel::ActiveRecord::Migration < ActiveSupport::TestCase
       end
 
       describe 'with a version not in the specification' do
-        let(:subject) do
-          v2_serialization
+        let(:subject_data) do
+          v2_serialization_data
             .except('old_field')
             .deep_merge(ViewModel::VERSION_ATTRIBUTE => 3, 'mid_field' => 1)
         end
@@ -132,8 +152,8 @@ class ViewModel::ActiveRecord::Migration < ActiveSupport::TestCase
       describe 'from an unreachable version' do
         let(:migration_versions) { { viewmodel_class => 2, child_viewmodel_class => 1 } }
 
-        let(:subject) do
-          v2_serialization.deep_merge(
+        let(:subject_data) do
+          v2_serialization_data.deep_merge(
             'child' => { ViewModel::VERSION_ATTRIBUTE => 1 },
           )
         end
@@ -148,8 +168,8 @@ class ViewModel::ActiveRecord::Migration < ActiveSupport::TestCase
       describe 'in an undefined direction' do
         let(:migration_versions) { { viewmodel_class => 1, child_viewmodel_class => 2 } }
 
-        let(:subject) do
-          v2_serialization.except('old_field').merge(ViewModel::VERSION_ATTRIBUTE => 1)
+        let(:subject_data) do
+          v2_serialization_data.except('old_field').merge(ViewModel::VERSION_ATTRIBUTE => 1)
         end
 
         it 'raises' do
@@ -161,6 +181,75 @@ class ViewModel::ActiveRecord::Migration < ActiveSupport::TestCase
     end
   end
 
+  describe 'garbage collection' do
+    include ViewModelSpecHelpers::ParentAndSharedBelongsToChild
+
+    # current (v2) features the shared child, v1 did not
+    def model_attributes
+      super.merge(
+        viewmodel: ->(_v) {
+          self.schema_version = 2
+          migrates from: 1, to: 2 do
+            down do |view, refs|
+              view.delete('child')
+            end
+          end
+        })
+    end
+
+    # current (v2) refers to another child, v1 did not
+    def child_attributes
+      super.merge(
+        schema: ->(t) { t.references :child, foreign_key: true },
+        model: ->(m) {
+          belongs_to :child, inverse_of: :parent, dependent: :destroy
+          has_one :parent, inverse_of: :child, class_name: self.name
+        },
+        viewmodel: ->(_v) {
+          self.schema_version = 2
+          association :child
+          migrates from: 1, to: 2 do
+            down do |view, refs|
+              view.delete('child')
+            end
+          end
+        })
+    end
+
+    def new_model
+      model_class.new(name: 'm1',
+                      child: child_model_class.new(
+                        name: 'c1',
+                        child: child_model_class.new(
+                          name: 'c2')))
+    end
+
+
+    let(:migrator) { down_migrator }
+    let(:migration_versions) { { viewmodel_class => 1, child_viewmodel_class => 1 } }
+
+    let(:subject) { current_serialization.deep_dup }
+
+    let(:expected_result) do
+      {
+        'data' => {
+          ViewModel::TYPE_ATTRIBUTE => viewmodel_class.view_name,
+          ViewModel::VERSION_ATTRIBUTE => 1,
+          ViewModel::ID_ATTRIBUTE => viewmodel.id,
+          ViewModel::MIGRATED_ATTRIBUTE => true,
+          'name' => viewmodel.name,
+        },
+        'references' => {},
+      }
+    end
+
+    it 'migrates' do
+      migrate!
+
+      assert_equal(expected_result, subject)
+    end
+  end
+
   describe 'without migrations' do
     describe 'to an unreachable version' do
       include ViewModelSpecHelpers::ParentAndBelongsToChild

data/test/unit/view_model/active_record_test.rb

@@ -416,6 +416,11 @@ class ViewModel::ActiveRecordTest < ActiveSupport::TestCase
       @list = List.new(child: List.new(child: nil))
     end
 
+    def test_list_eager_includes
+      expected_includes = 3.times.inject(nil) { |x| DeepPreloader::Spec.new({ 'child' => x }) }
+      assert_equal(expected_includes, ListView.eager_includes)
+    end
+
     def test_deserialize_context
       view = {
         '_type' => 'List',

data/test/unit/view_model/garbage_collection_test.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require 'minitest/autorun'
+require 'minitest/unit'
+
+require 'view_model'
+require 'view_model/garbage_collection'
+
+class ViewModel::GarbageCollectionTest < ActiveSupport::TestCase
+  extend Minitest::Spec::DSL
+
+  # Generate a viewmodel-serialization alike from a minimal structure
+  # @param [Hash<Symbol, Array<Symbol>] structure mapping from id to referenced ids
+  # @param [Hash<Symbol, Array<Symbol>] data_ids list of ids of data elements
+  def mock_serialization(data_skeleton, refs_skeleton)
+    data       = []
+    references = {}
+
+    generate(data_skeleton) do |id, body|
+      data << body
+    end
+
+    generate(refs_skeleton) do |id, body|
+      references[id] = body
+    end
+
+    {
+      "data"       => data,
+      "references" => references,
+    }
+  end
+
+  def generate(skeleton)
+    skeleton.each do |id, referred|
+      yield id, ({
+        ViewModel::ID_ATTRIBUTE => id,
+        :children               => referred.map do |referred_id|
+          { ViewModel::REFERENCE_ATTRIBUTE => referred_id }
+        end
+      })
+    end
+  end
+
+  def retained_ids(data_skeleton, refs_skeleton)
+    serialization = mock_serialization(data_skeleton, refs_skeleton)
+    ViewModel::GarbageCollection.garbage_collect_references!(serialization)
+    Set.new(
+      (serialization['data'].map { |x| x[ViewModel::ID_ATTRIBUTE] }) +
+        (serialization['references'].keys),
+    )
+  end
+
+  it 'keeps all roots' do
+    assert_equal(
+      Set.new([:a, :b, :c]),
+      retained_ids({ a: [], b: [], c: [] }, {})
+    )
+  end
+
+  it 'keeps a list' do
+    assert_equal(
+      Set.new([:a, :b, :c, :d]),
+      retained_ids({ a: [:b], }, { b: [:c], c: [:d], d: [] }),
+    )
+  end
+
+  it 'keeps a child with a removed reference' do
+    assert_equal(
+      Set.new([:a, :z]),
+      retained_ids({ a: [:z], }, { b: [:z], z: [] }),
+    )
+  end
+
+  it 'prunes a list at the head' do
+    assert_equal(
+      Set.new([:a]),
+      retained_ids({ a: [], }, { b: [:c], c: [:d], d: [] }),
+    )
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: iknow_view_models
 version: !ruby/object:Gem::Version
-  version: 3.2.10
+  version: 3.3.0
 platform: ruby
 authors:
 - iKnow Team
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-01-12 00:00:00.000000000 Z
+date: 2021-04-13 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
@@ -414,6 +415,7 @@ files:
 - lib/view_model/deserialize_context.rb
 - lib/view_model/error.rb
 - lib/view_model/error_view.rb
+- lib/view_model/garbage_collection.rb
 - lib/view_model/migratable_view.rb
 - lib/view_model/migration.rb
 - lib/view_model/migration/no_path_error.rb
@@ -467,6 +469,7 @@ files:
 - test/unit/view_model/callbacks_test.rb
 - test/unit/view_model/controller_test.rb
 - test/unit/view_model/deserialization_error/unique_violation_test.rb
+- test/unit/view_model/garbage_collection_test.rb
 - test/unit/view_model/record_test.rb
 - test/unit/view_model/registry_test.rb
 - test/unit/view_model/traversal_context_test.rb
@@ -483,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
@@ -527,6 +530,7 @@ test_files:
 - test/unit/view_model/callbacks_test.rb
 - test/unit/view_model/controller_test.rb
 - test/unit/view_model/deserialization_error/unique_violation_test.rb
+- test/unit/view_model/garbage_collection_test.rb
 - test/unit/view_model/record_test.rb
 - test/unit/view_model/registry_test.rb
 - test/unit/view_model/traversal_context_test.rb