iknow_view_models 3.2.7 → 3.2.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4873d88f99bcdf0d63c3db8cbf36af0990bd9dd88bca0e170159b873b8aa7212
-  data.tar.gz: b190cb5ec7806dfe4f8decbf4acf8f54b7fcc0857f271d1417b4d680a87c0622
+  metadata.gz: 284af292a0f1a70b761afd2e3ef084ad9f8f5853f00c8af8ac2d3b1227eb9cb5
+  data.tar.gz: 61fdea22a0b13db50e7b237e472900eef376e95d04fed5f21a8c1ef7422aaa56
 SHA512:
-  metadata.gz: 57c4fad3880aa1ce8f3434827df3dd6a789561a0f3bd8210b774c86258b8a0d4be777cbb827760f6c405b7caa61875efb8a780b3a2a9d7eff203315490d5f450
-  data.tar.gz: ffe26b3f24098c1ce7bd07453ce5a4f9a0bfd9611e57a53ccb7394b98fc2b8af724dc598bca85e0d2713c457d3fb5cc8575006ed947ade06aa7efd11f4436c16
+  metadata.gz: 64ffd808756c298236f4e00b11cdf7f1410019bc506f306c6cfbaa97b953212a5c58e7b56263deac0aac5e80398fa2d551922d6b90d7a3c60732a50b66467384
+  data.tar.gz: ccd3301209a94c8e9cd9a44166b153ae3edafab81cfe49498849e6c22dc413956d33e3cdba0ab001456122f47400df47dfbe327d9a9005f1947c512da3d9e523

data/lib/iknow_view_models/version.rb

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

data/lib/view_model.rb

@@ -243,6 +243,12 @@ class ViewModel
       schema_version == self.schema_version
     end
 
+    def schema_versions(viewmodels)
+      viewmodels.each_with_object({}) do |view, h|
+        h[view.view_name] = view.schema_version
+      end
+    end
+
     def schema_hash(schema_versions)
       version_string = schema_versions.to_a.sort.join(',')
       # We want a short hash value, as this will be used in cache keys
@@ -371,3 +377,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

@@ -243,11 +243,10 @@ class ViewModel::ActiveRecord < ViewModel::Record
     end
 
     def deep_schema_version(include_referenced: true, include_external: true)
-      (@deep_schema_version ||= {})[include_referenced] ||=
+      (@deep_schema_version ||= {})[[include_referenced, include_external]] ||=
         begin
-          dependent_viewmodels(include_referenced: include_referenced, include_external: include_external).each_with_object({}) do |view, h|
-            h[view.view_name] = view.schema_version
-          end.freeze
+          vms = dependent_viewmodels(include_referenced: include_referenced, include_external: include_external)
+          ViewModel.schema_versions(vms).freeze
         end
     end
 
@@ -341,12 +340,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

@@ -177,28 +177,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/controller.rb

@@ -71,7 +71,7 @@ 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
@@ -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/migratable_view.rb

@@ -52,6 +52,9 @@ module ViewModel::MigratableView
 
       graph = RGL::DirectedAdjacencyGraph.new
 
+      # Add a vertex for the current version, in case no edges reach it
+      graph.add_vertex(self.schema_version)
+
       # Add edges backwards, as we care about paths from the latest version
       @migration_classes.each_key do |from, to|
         graph.add_edge(to, from)
@@ -60,7 +63,7 @@ module ViewModel::MigratableView
       paths = graph.dijkstra_shortest_paths(Hash.new { 1 }, self.schema_version)
 
       paths.each do |target_version, path|
-        next if path.length == 1
+        next if path.nil? || path.length == 1
 
         # Store the path forwards rather than backwards
         path_migration_classes = path.reverse.each_cons(2).map do |from, to|

data/lib/view_model/migration/no_path_error.rb

@@ -4,6 +4,7 @@ class ViewModel::Migration::NoPathError < ViewModel::AbstractError
   attr_reader :vm_name, :from, :to
 
   status 400
+  code 'Migration.NoPathError'
 
   def initialize(viewmodel, from, to)
     @vm_name = viewmodel.view_name

data/lib/view_model/migration/one_way_error.rb

@@ -4,6 +4,7 @@ class ViewModel::Migration::OneWayError < ViewModel::AbstractError
   attr_reader :vm_name, :direction
 
   status 400
+  code 'Migration.OneWayError'
 
   def initialize(vm_name, direction)
     @vm_name = vm_name

data/lib/view_model/migration/unspecified_version_error.rb

@@ -4,6 +4,7 @@ class ViewModel::Migration::UnspecifiedVersionError < ViewModel::AbstractError
   attr_reader :vm_name, :version
 
   status 400
+  code 'Migration.UnspecifiedVersionError'
 
   def initialize(vm_name, version)
     @vm_name = vm_name

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/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]

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

@@ -12,147 +12,267 @@ class ViewModel::ActiveRecord::Migration < ActiveSupport::TestCase
   include ARVMTestUtilities
   extend Minitest::Spec::DSL
 
-  include ViewModelSpecHelpers::ParentAndBelongsToChildWithMigration
-
   def new_model
     model_class.new(name: 'm1', child: child_model_class.new(name: 'c1'))
   end
 
   let(:viewmodel) { create_viewmodel! }
 
-  let(:current_serialization) { ViewModel.serialize_to_hash(viewmodel) }
-
-  let(:v2_serialization) 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::VERSION_ATTRIBUTE => 2,
-        ViewModel::ID_ATTRIBUTE => viewmodel.child.id,
-        'name' => viewmodel.child.name,
-        'former_field' => 'former_value',
-      },
-    }
-  end
-
   let(:migration_versions) { { viewmodel_class => 2, child_viewmodel_class => 2 } }
 
   let(:down_migrator) { ViewModel::DownMigrator.new(migration_versions) }
   let(:up_migrator) { ViewModel::UpMigrator.new(migration_versions) }
 
   def migrate!
-    migrator.migrate!(subject, references: {})
+    migrator.migrate!(subject)
   end
 
-  describe 'downwards' do
-    let(:migrator) { down_migrator }
-    let(:subject) { current_serialization.deep_dup }
+  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(:expected_result) do
-      v2_serialization.deep_merge(
-        {
-          ViewModel::MIGRATED_ATTRIBUTE => true,
-          'old_field' => -1,
-          'child' => {
-            ViewModel::MIGRATED_ATTRIBUTE => true,
-            'former_field' => 'reconstructed',
-          },
+  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::VERSION_ATTRIBUTE => 2,
+          ViewModel::ID_ATTRIBUTE => viewmodel.child.id,
+          'name' => viewmodel.child.name,
+          'former_field' => 'former_value',
         },
-      )
-    end
+    }
+  end
 
-    it 'migrates' do
-      migrate!
+  let(:v2_serialization_references) { {} }
 
-      assert_equal(expected_result, subject)
-    end
+  let(:v2_serialization) do
+    {
+      'data' => v2_serialization_data,
+      'references' => v2_serialization_references,
+    }
+  end
 
-    describe 'to an unreachable version' do
-      let(:migration_versions) { { viewmodel_class => 2, child_viewmodel_class => 1 } }
+  describe 'with defined migrations' do
+    include ViewModelSpecHelpers::ParentAndBelongsToChildWithMigration
 
-      it 'raises' do
-        assert_raises(ViewModel::Migration::NoPathError) do
-          migrate!
-        end
+    describe 'downwards' do
+      let(:migrator) { down_migrator }
+      let(:subject) { current_serialization.deep_dup }
+
+      let(:expected_result) do
+        v2_serialization.deep_merge(
+          {
+            'data' => {
+              ViewModel::MIGRATED_ATTRIBUTE => true,
+              'old_field' => -1,
+              'child' => {
+                ViewModel::MIGRATED_ATTRIBUTE => true,
+                'former_field' => 'reconstructed',
+              },
+            },
+          })
       end
-    end
-  end
 
-  describe 'upwards' do
-    let(:migrator) { up_migrator }
-    let(:subject) { v2_serialization.deep_dup }
+      it 'migrates' do
+        migrate!
 
-    let(:expected_result) do
-      current_serialization.deep_merge(
-        ViewModel::MIGRATED_ATTRIBUTE => true,
-        'new_field' => 3,
-        'child' => {
-          ViewModel::MIGRATED_ATTRIBUTE => true,
-        },
-      )
-    end
+        assert_equal(expected_result, subject)
+      end
 
-    it 'migrates' do
-      migrate!
+      describe 'to an unreachable version' do
+        let(:migration_versions) { { viewmodel_class => 2, child_viewmodel_class => 1 } }
 
-      assert_equal(expected_result, subject)
+        it 'raises' do
+          assert_raises(ViewModel::Migration::NoPathError) do
+            migrate!
+          end
+        end
+      end
     end
 
-    describe 'with version unspecified' do
-      let(:subject) do
-        v2_serialization
-          .except(ViewModel::VERSION_ATTRIBUTE)
+    describe 'upwards' do
+      let(:migrator) { up_migrator }
+      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(
+          {
+            'data' => {
+              ViewModel::MIGRATED_ATTRIBUTE => true,
+              'new_field' => 3,
+              'child' => {
+                ViewModel::MIGRATED_ATTRIBUTE => true,
+              },
+            },
+          }
+        )
       end
 
-      it 'treats it as the requested version' do
+      it 'migrates' do
         migrate!
+
         assert_equal(expected_result, subject)
       end
-    end
 
-    describe 'with a version not in the specification' do
-      let(:subject) do
-        v2_serialization
-          .except('old_field')
-          .deep_merge(ViewModel::VERSION_ATTRIBUTE => 3, 'mid_field' => 1)
-      end
+      describe 'with version unspecified' do
+        let(:subject_data) do
+          v2_serialization_data.except(ViewModel::VERSION_ATTRIBUTE)
+        end
 
-      it 'rejects it' do
-        assert_raises(ViewModel::Migration::UnspecifiedVersionError) do
+        it 'treats it as the requested version' do
           migrate!
+          assert_equal(expected_result, subject)
         end
       end
-    end
 
-    describe 'from an unreachable version' do
-      let(:migration_versions) { { viewmodel_class => 2, child_viewmodel_class => 1 } }
+      describe 'with a version not in the specification' do
+        let(:subject_data) do
+          v2_serialization_data
+            .except('old_field')
+            .deep_merge(ViewModel::VERSION_ATTRIBUTE => 3, 'mid_field' => 1)
+        end
 
-      let(:subject) do
-        v2_serialization.deep_merge(
-          'child' => { ViewModel::VERSION_ATTRIBUTE => 1 },
-        )
+        it 'rejects it' do
+          assert_raises(ViewModel::Migration::UnspecifiedVersionError) do
+            migrate!
+          end
+        end
       end
 
-      it 'raises' do
-        assert_raises(ViewModel::Migration::NoPathError) do
-          migrate!
+      describe 'from an unreachable version' do
+        let(:migration_versions) { { viewmodel_class => 2, child_viewmodel_class => 1 } }
+
+        let(:subject_data) do
+          v2_serialization_data.deep_merge(
+            'child' => { ViewModel::VERSION_ATTRIBUTE => 1 },
+          )
+        end
+
+        it 'raises' do
+          assert_raises(ViewModel::Migration::NoPathError) do
+            migrate!
+          end
+        end
+      end
+
+      describe 'in an undefined direction' do
+        let(:migration_versions) { { viewmodel_class => 1, child_viewmodel_class => 2 } }
+
+        let(:subject_data) do
+          v2_serialization_data.except('old_field').merge(ViewModel::VERSION_ATTRIBUTE => 1)
+        end
+
+        it 'raises' do
+          assert_raises(ViewModel::Migration::OneWayError) do
+            migrate!
+          end
         end
       end
     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
 
-    describe 'in an undefined direction' do
-      let(:migration_versions) { { viewmodel_class => 1, child_viewmodel_class => 2 } }
+    # 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
 
-      let(:subject) do
-        v2_serialization.except('old_field').merge(ViewModel::VERSION_ATTRIBUTE => 1)
+    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
+
+      def model_attributes
+        super.merge(viewmodel: ->(_v) {
+                      self.schema_version = 4
+                      # Define an unreachable migration to ensure that the view
+                      # attempts to realize paths.
+                      migrates from: 1, to: 2 do
+                      end
+                    })
+      end
+
+      def child_attributes
+        super.merge(viewmodel: ->(_v) { self.schema_version = 3 })
       end
 
-      it 'raises' do
-        assert_raises(ViewModel::Migration::OneWayError) do
+      let(:migrator) { down_migrator }
+      let(:subject) { current_serialization.deep_dup }
+
+      it 'raises no path error' do
+        assert_raises(ViewModel::Migration::NoPathError) do
           migrate!
         end
       end

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.7
+  version: 3.2.12
 platform: ruby
 authors:
 - iKnow Team
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-10-21 00:00:00.000000000 Z
+date: 2021-02-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -414,6 +414,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 +468,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
@@ -527,6 +529,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