iknow_view_models 3.1.6 → 3.2.2

data/lib/view_model/access_control/open.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class ViewModel::AccessControl::Open < ViewModel::AccessControl
   def visible_check(_traversal_env)
     ViewModel::AccessControl::Result::PERMIT

data/lib/view_model/access_control/read_only.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class ViewModel::AccessControl::ReadOnly < ViewModel::AccessControl
   def visible_check(_traversal_env)
     ViewModel::AccessControl::Result::PERMIT

data/lib/view_model/access_control/tree.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 ## Defines an access control discipline for a given action against a tree of
 ## viewmodels.
 ##
@@ -78,7 +80,7 @@ class ViewModel::AccessControl::Tree < ViewModel::AccessControl
   def initialize
     super()
     @always_policy_instance = self.class::AlwaysPolicy.new(self)
-    @view_policy_instances  = self.class.view_policies.each_with_object({}) { |(name, policy), h| h[name] = policy.new(self) }
+    @view_policy_instances  = self.class.view_policies.transform_values { |policy| policy.new(self) }
     @root_visibility_store  = {}
     @root_editability_store = {}
   end
@@ -98,27 +100,29 @@ class ViewModel::AccessControl::Tree < ViewModel::AccessControl
 
   def store_descendent_editability(view, descendent_editability)
     if @root_editability_store.has_key?(view.object_id)
-      raise RuntimeError.new("Root access control data already saved for root")
+      raise RuntimeError.new('Root access control data already saved for root')
     end
+
     @root_editability_store[view.object_id] = descendent_editability
   end
 
   def fetch_descendent_editability(view)
     @root_editability_store.fetch(view.object_id) do
-      raise RuntimeError.new("No root access control data recorded for root")
+      raise RuntimeError.new('No root access control data recorded for root')
     end
   end
 
   def store_descendent_visibility(view, descendent_visibility)
     if @root_visibility_store.has_key?(view.object_id)
-      raise RuntimeError.new("Root access control data already saved for root")
+      raise RuntimeError.new('Root access control data already saved for root')
     end
+
     @root_visibility_store[view.object_id] = descendent_visibility
   end
 
   def fetch_descendent_visibility(view)
     @root_visibility_store.fetch(view.object_id) do
-      raise RuntimeError.new("No root access control data recorded for root")
+      raise RuntimeError.new('No root access control data recorded for root')
     end
   end
 
@@ -152,6 +156,7 @@ class ViewModel::AccessControl::Tree < ViewModel::AccessControl
 
       def initialize_as_node
         @root = false
+
         @root_children_editable_ifs      = []
         @root_children_editable_unlesses = []
         @root_children_visible_ifs       = []
@@ -187,7 +192,7 @@ class ViewModel::AccessControl::Tree < ViewModel::AccessControl
       def inspect_checks
         checks = super
         if root?
-          checks << "no root checks"
+          checks << 'no root checks'
         else
           checks << "root_children_visible_if: #{root_children_visible_ifs.map(&:reason)}"            if root_children_visible_ifs.present?
           checks << "root_children_visible_unless: #{root_children_visible_unlesses.map(&:reason)}"   if root_children_visible_unlesses.present?

data/lib/view_model/access_control_error.rb

@@ -1,7 +1,10 @@
+# frozen_string_literal: true
+
 class ViewModel::AccessControlError < ViewModel::AbstractErrorWithBlame
   attr_reader :detail
+
   status 403
-  code "AccessControl.Forbidden"
+  code 'AccessControl.Forbidden'
 
   def initialize(detail, nodes = [])
     @detail = detail

data/lib/view_model/active_record.rb

@@ -1,23 +1,23 @@
 # frozen_string_literal: true
 
-require "active_support"
-require "active_record"
+require 'active_support'
+require 'active_record'
 
-require "view_model"
-require "view_model/record"
+require 'view_model'
+require 'view_model/record'
 
-require "lazily"
-require "concurrent"
+require 'lazily'
+require 'concurrent'
 
 class ViewModel::ActiveRecord < ViewModel::Record
   # Defined before requiring components so components can refer to them at parse time
 
   # for functional updates
-  FUNCTIONAL_UPDATE_TYPE = "_update"
-  ACTIONS_ATTRIBUTE      = "actions"
-  VALUES_ATTRIBUTE       = "values"
-  BEFORE_ATTRIBUTE       = "before"
-  AFTER_ATTRIBUTE        = "after"
+  FUNCTIONAL_UPDATE_TYPE = '_update'
+  ACTIONS_ATTRIBUTE      = 'actions'
+  VALUES_ATTRIBUTE       = 'values'
+  BEFORE_ATTRIBUTE       = 'before'
+  AFTER_ATTRIBUTE        = 'after'
 
   require 'view_model/utils/collections'
   require 'view_model/active_record/association_data'
@@ -232,6 +232,7 @@ class ViewModel::ActiveRecord < ViewModel::Record
       _members.each_value do |data|
         next unless data.is_a?(AssociationData)
         next unless include_referenced || !data.referenced?
+
         data.viewmodel_classes.each do |vm|
           vm.dependent_viewmodels(seen, include_referenced: include_referenced)
         end
@@ -245,7 +246,7 @@ class ViewModel::ActiveRecord < ViewModel::Record
         begin
           dependent_viewmodels(include_referenced: include_referenced).each_with_object({}) do |view, h|
             h[view.view_name] = view.schema_version
-          end
+          end.freeze
         end
     end
 

data/lib/view_model/active_record/association_data.rb

@@ -17,7 +17,7 @@ class ViewModel::ActiveRecord::AssociationData
 
     @direct_reflection = owner.model_class.reflect_on_association(direct_association_name)
     if @direct_reflection.nil?
-      raise InvalidAssociation.new("Association '#{direct_association_name}' not found in model '#{model_class.name}'")
+      raise InvalidAssociation.new("Association '#{direct_association_name}' not found in model '#{owner.model_class.name}'")
     end
 
     @indirect_association_name = indirect_association_name
@@ -42,7 +42,7 @@ class ViewModel::ActiveRecord::AssociationData
         @indirect_reflection = load_indirect_reflection(intermediate_model, @indirect_association_name)
         target_reflection    = @indirect_reflection
       else
-        target_reflection    = @direct_reflection
+        target_reflection = @direct_reflection
       end
 
       @viewmodel_classes =
@@ -202,6 +202,7 @@ class ViewModel::ActiveRecord::AssociationData
 
   def direct_viewmodel
     raise ArgumentError.new('not a through association') unless through?
+
     lazy_initialize! unless @initialized
     @direct_viewmodel
   end

data/lib/view_model/active_record/association_manipulation.rb

@@ -11,7 +11,8 @@ module ViewModel::ActiveRecord::AssociationManipulation
     association_scope = association.scope
 
     if association_data.through?
-      raise ArgumentError.new("Polymorphic through relationships not supported yet") if association_data.polymorphic?
+      raise ArgumentError.new('Polymorphic through relationships not supported yet') if association_data.polymorphic?
+
       associated_viewmodel = association_data.viewmodel_class
       direct_viewmodel     = association_data.direct_viewmodel
     else
@@ -44,6 +45,7 @@ module ViewModel::ActiveRecord::AssociationManipulation
       if vms.size > 1
         raise ViewModel::DeserializationError::Internal.new("Internal error: encountered multiple records for single association #{association_name}", self.blame_reference)
       end
+
       vms.first
     end
   end
@@ -112,7 +114,7 @@ module ViewModel::ActiveRecord::AssociationManipulation
           deserialize_context.run_callback(ViewModel::Callbacks::Hook::BeforeValidate, self)
 
           if association_data.through?
-            raise ArgumentError.new("Polymorphic through relationships not supported yet") if association_data.polymorphic?
+            raise ArgumentError.new('Polymorphic through relationships not supported yet') if association_data.polymorphic?
 
             direct_viewmodel_class = association_data.direct_viewmodel
             root_update_data, referenced_update_data = construct_indirect_append_updates(association_data, subtree_hashes, references)
@@ -317,7 +319,7 @@ module ViewModel::ActiveRecord::AssociationManipulation
     # TODO: this won't handle polymorphic associations! In the case of polymorphism,
     #       need to join on (type, id) pairs instead.
     if association_data.polymorphic?
-      raise ArgumentError.new("Internal error: append_association is not yet supported for polymorphic indirect associations")
+      raise ArgumentError.new('Internal error: append_association is not yet supported for polymorphic indirect associations')
     end
 
     existing_indirect_associates = indirect_update_data.map { |upd| upd.id unless upd.new? }.compact
@@ -340,7 +342,7 @@ module ViewModel::ActiveRecord::AssociationManipulation
       ViewModel::ActiveRecord::UpdateData.new(
         direct_viewmodel_class,
         metadata,
-        { indirect_reflection.name.to_s => { ViewModel::REFERENCE_ATTRIBUTE => ref_name }},
+        { indirect_reflection.name.to_s => { ViewModel::REFERENCE_ATTRIBUTE => ref_name } },
         [ref_name])
     end
 

data/lib/view_model/active_record/cache.rb

@@ -5,6 +5,7 @@ require 'iknow_cache'
 # Cache for ViewModels that wrap ActiveRecord models.
 class ViewModel::ActiveRecord::Cache
   require 'view_model/active_record/cache/cacheable_view'
+  require 'view_model/migrator'
 
   class UncacheableViewModelError < RuntimeError; end
 
@@ -13,13 +14,20 @@ class ViewModel::ActiveRecord::Cache
   # 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
-    @cache_group = cache_group || create_default_cache_group # requires @viewmodel_class
+
+    @cache_group = cache_group || create_default_cache_group
+    @migrated_cache_group = @cache_group.register_child_group(:migrated, :version)
+
+    # /viewname/:id/viewname-currentversion
     @cache = @cache_group.register_cache(cache_name)
+
+    # /viewname/:id/migrated/:oldversion/viewname-currentversion
+    @migrated_cache = @migrated_cache_group.register_cache(cache_name)
   end
 
   def delete(*ids)
     ids.each do |id|
-      @cache_group.delete_all(key_for(id))
+      @cache_group.delete_all(@cache.key.new(id))
     end
   end
 
@@ -27,14 +35,14 @@ class ViewModel::ActiveRecord::Cache
     @cache_group.invalidate_cache_group
   end
 
-  def fetch_by_viewmodel(viewmodels, locked: false, serialize_context: @viewmodel_class.new_serialize_context)
+  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, locked: false, serialize_context: serialize_context)
+    fetch(ids, initial_viewmodels: viewmodels, migration_versions: migration_versions, locked: locked, serialize_context: serialize_context)
   end
 
-  def fetch(ids, initial_viewmodels: nil, locked: false, serialize_context: @viewmodel_class.new_serialize_context)
+  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(serialize_context: serialize_context)
+    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
@@ -98,12 +106,14 @@ class ViewModel::ActiveRecord::Cache
     SENTINEL = Object.new
     WorklistEntry = Struct.new(:ref_name, :viewmodel)
 
-    attr_reader :serialize_context, :resolved_references
+    attr_reader :migration_versions, :serialize_context, :resolved_references
 
-    def initialize(serialize_context:)
-      @worklist            = {}
-      @resolved_references = {}
-      @serialize_context   = serialize_context
+    def initialize(migration_versions:, serialize_context:)
+      @worklist                = {}
+      @resolved_references     = {}
+      @migration_versions      = migration_versions
+      @migrated_cache_versions = {}
+      @serialize_context       = serialize_context
     end
 
     def resolve_references!
@@ -141,11 +151,15 @@ class ViewModel::ActiveRecord::Cache
       end
     end
 
+    def migrated_cache_version(viewmodel_cache)
+      @migrated_cache_versions[viewmodel_cache] ||= viewmodel_cache.migrated_cache_version(migration_versions)
+    end
+
     # Loads the specified entities from the cache and returns a hash of
     # {id=>serialized_view}. Any references encountered are added to the
     # worklist.
     def load_from_cache(viewmodel_cache, ids)
-      cached_serializations = viewmodel_cache.load(ids, serialize_context: serialize_context)
+      cached_serializations = viewmodel_cache.load(ids, migrated_cache_version(viewmodel_cache), serialize_context: serialize_context)
 
       cached_serializations.each_with_object({}) do |(id, cached_serialization), result|
         add_refs_to_worklist(cached_serialization[:ref_cache])
@@ -159,17 +173,54 @@ class ViewModel::ActiveRecord::Cache
     # added to the worklist.
     def serialize_and_cache(viewmodels)
       viewmodels.each_with_object({}) do |viewmodel, result|
-        data_serialization = Jbuilder.encode do |json|
+        builder = Jbuilder.new do |json|
           ViewModel.serialize(viewmodel, json, serialize_context: serialize_context)
         end
 
         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.
+          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,
+            }.freeze
+          end
+
+          migrator.migrate!(builder.attributes!, references: dummy_references)
+
+          # Removed dummy references can be removed from referenced_viewmodels.
+          referenced_viewmodels.keep_if { |k, _| dummy_references.has_key?(k) }
+
+          # Introduced dummy references cannot be handled.
+          if dummy_references.keys != referenced_viewmodels.keys
+            version = migration_versions[viewmodel.class]
+            raise ViewModel::Error.new(
+                    status: 500,
+                    detail: "Down-migration for cacheable view #{viewmodel.class} to v#{version} must not introduce new shared references")
+          end
+        end
+
+        data_serialization = builder.target!
+
         add_viewmodels_to_worklist(referenced_viewmodels)
 
         if viewmodel.class < CacheableView
           cacheable_references = referenced_viewmodels.transform_values { |vm| cacheable_reference(vm) }
-          viewmodel.class.viewmodel_cache.store(viewmodel.id, data_serialization, cacheable_references,
-                                                serialize_context: serialize_context)
+          target_cache = viewmodel.class.viewmodel_cache
+          target_cache.store(viewmodel.id, migrated_cache_version(target_cache), data_serialization, cacheable_references,
+                             serialize_context: serialize_context)
         end
 
         result[viewmodel.id] = data_serialization
@@ -192,14 +243,14 @@ class ViewModel::ActiveRecord::Cache
       if ids.present?
         found = viewmodel_class.find(ids,
                                      eager_include: false,
-                                     lock: "FOR SHARE",
+                                     lock: 'FOR SHARE',
                                      serialize_context: serialize_context)
         viewmodels.concat(found)
       end
 
       ViewModel.preload_for_serialization(viewmodels,
                                           include_referenced: false,
-                                          lock: "FOR SHARE",
+                                          lock: 'FOR SHARE',
                                           serialize_context: serialize_context)
 
       viewmodels
@@ -213,6 +264,7 @@ class ViewModel::ActiveRecord::Cache
     def add_refs_to_worklist(cacheable_references)
       cacheable_references.each do |ref_name, (type, id)|
         next if resolved_references.has_key?(ref_name)
+
         (@worklist[type] ||= {})[id] = WorklistEntry.new(ref_name, nil)
       end
     end
@@ -220,13 +272,26 @@ class ViewModel::ActiveRecord::Cache
     def add_viewmodels_to_worklist(referenced_viewmodels)
       referenced_viewmodels.each do |ref_name, viewmodel|
         next if resolved_references.has_key?(ref_name)
+
         (@worklist[viewmodel.class.view_name] ||= {})[viewmodel.id] = WorklistEntry.new(ref_name, viewmodel)
       end
     end
   end
 
-  def key_for(id)
-    cache.key.new(id)
+  def cache_for(migration_version)
+    if migration_version
+      @migrated_cache
+    else
+      @cache
+    end
+  end
+
+  def key_for(id, migration_version)
+    if migration_version
+      @migrated_cache.key.new(id, migration_version)
+    else
+      @cache.key.new(id)
+    end
   end
 
   def id_for(key)
@@ -234,32 +299,47 @@ class ViewModel::ActiveRecord::Cache
   end
 
   # Save the provided serialization and reference data in the cache
-  def store(id, data_serialization, ref_cache, serialize_context:)
-    cache.write(key_for(id), { data: data_serialization, ref_cache: ref_cache })
+  def store(id, migration_version, data_serialization, ref_cache, serialize_context:)
+    key = key_for(id, migration_version)
+    cache_for(migration_version).write(key, { data: data_serialization, ref_cache: ref_cache })
   end
 
-  def load(ids, serialize_context:)
-    keys = ids.map { |id| key_for(id) }
-    results = cache.read_multi(keys)
+  def load(ids, migration_version, serialize_context:)
+    keys = ids.map { |id| key_for(id, migration_version) }
+    results = cache_for(migration_version).read_multi(keys)
     results.transform_keys! { |key| id_for(key) }
   end
 
-  private
+  def cache_version
+    @cache_version ||=
+      begin
+        versions = @viewmodel_class.deep_schema_version(include_referenced: false)
+        ViewModel.schema_hash(versions)
+      end
+  end
 
-  attr_reader :cache
+  def migrated_cache_version(migration_versions)
+    versions = ViewModel::Migrator.migrated_deep_schema_version(viewmodel_class, migration_versions, include_referenced: false)
+    version_hash = ViewModel.schema_hash(versions)
+
+    if version_hash == cache_version
+      # no migrations affect this view
+      nil
+    else
+      version_hash
+    end
+  end
+
+  private
 
   def create_default_cache_group
     IknowCache.register_group(@viewmodel_class.name, :id)
   end
 
-  # Statically version the terminal cache based on the deep schema versions of
-  # the constituent viewmodels, so that viewmodel changes force invalidation.
+  # Statically version the cache name based on the (current) deep schema
+  # versions of the constituent viewmodels, so that viewmodel changes force
+  # invalidation.
   def cache_name
-    "#{@viewmodel_class.name}_#{cache_version}"
-  end
-
-  def cache_version
-    version_string = @viewmodel_class.deep_schema_version(include_referenced: false).to_a.sort.join(',')
-    Base64.urlsafe_encode64(Digest::MD5.digest(version_string))
+    "vmcache_#{cache_version}"
   end
 end