iknow_view_models 2.9.0 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 53525088a6e3b8f394861ea5326ee235d94eb69a7b49b346ca09f26894e62f38
-  data.tar.gz: e394ad428ee6131d5dcdf7107ca5fea22d23eb41ab6bc6c5ba96626343180f89
+  metadata.gz: a86c98f9ceda1cb4bf6980a84eb2051b5bc3904c08ab85b8546c4b16c78d26ff
+  data.tar.gz: 3b988a29d63e06d929c3fa0ca31b7b11f585e03263653c8f5bea64f2583c2fa3
 SHA512:
-  metadata.gz: 342baae02e08f68f1f4b624c153bb9fd00144f21aef38c5623144899a4554730fd98651411e26528e05f40b16fa51136235ae1831ebc25bb4860904de465aef8
-  data.tar.gz: af565e5b9374ce950178437a16def8cda1b50639d2e98e5c367be5af0cacaff85ddcb7f0fc57a1a4309466e3f682760ae8a213f0ac9ed740eeed4bd9b975736e
+  metadata.gz: f281b79eda3e83689d5f2aec0239f89d73a4c1ad0778ee017c20af65088c50dc7356d2149bce7b487766a68947c85645cddd0f6e92f0312a7c2cad1489ccb6f0
+  data.tar.gz: a3f4960911039bc0679c068cc67c86bee0cdad278ab7acfbea66e36cdf8e064e45eed8ea709ecd3b75ddc42a7934645f93ad9699be5c40a0595a3d2b5db10dc6

data/iknow_view_models.gemspec

@@ -24,7 +24,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency "activesupport", ">= 5.0"
 
   spec.add_dependency "acts_as_manual_list"
-  spec.add_dependency "deep_preloader"
+  spec.add_dependency "deep_preloader", ">= 1.0.1"
   spec.add_dependency "iknow_cache"
   spec.add_dependency "iknow_params", "~> 2.2.0"
   spec.add_dependency "safe_values"

data/lib/iknow_view_models/version.rb

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

data/lib/view_model/active_record/association_data.rb

@@ -1,95 +1,137 @@
 # frozen_string_literal: true
 
-# TODO consider rephrase scope for consistency
 class ViewModel::ActiveRecord::AssociationData
-  attr_reader :direct_reflection, :association_name
-
-  def initialize(association_name, direct_reflection, viewmodel_classes, shared, optional, through_to, through_order_attr)
-    @association_name   = association_name
-    @direct_reflection  = direct_reflection
-    @shared             = shared
-    @optional           = optional
-    @through_to         = through_to
-    @through_order_attr = through_order_attr
-
-    if viewmodel_classes
-      @viewmodel_classes = Array.wrap(viewmodel_classes).map! do |v|
-        case v
-        when String, Symbol
-          ViewModel::Registry.for_view_name(v.to_s)
-        when Class
-          v
+  class InvalidAssociation < RuntimeError; end
+
+  attr_reader :association_name, :direct_reflection
+
+  def initialize(owner:,
+                 association_name:,
+                 direct_association_name:,
+                 indirect_association_name:,
+                 target_viewmodels:,
+                 external:,
+                 through_order_attr:,
+                 read_only:)
+    @association_name = association_name
+
+    @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}'")
+    end
+
+    @indirect_association_name = indirect_association_name
+
+    @read_only           = read_only
+    @external            = external
+    @through_order_attr  = through_order_attr
+    @target_viewmodels   = target_viewmodels
+
+    # Target models/reflections/viewmodels are lazily evaluated so that we can
+    # safely express cycles.
+    @initialized         = false
+    @mutex               = Mutex.new
+  end
+
+  def lazy_initialize!
+    @mutex.synchronize do
+      return if @initialized
+
+      if through?
+        intermediate_model   = @direct_reflection.klass
+        @indirect_reflection = load_indirect_reflection(intermediate_model, @indirect_association_name)
+        target_reflection    = @indirect_reflection
+      else
+        target_reflection    = @direct_reflection
+      end
+
+      @viewmodel_classes =
+        if @target_viewmodels.present?
+          # Explicitly named
+          @target_viewmodels.map { |v| resolve_viewmodel_class(v) }
         else
-          raise ArgumentError.new("Invalid viewmodel class: #{v.inspect}")
+          # Infer name from name of model
+          if target_reflection.polymorphic?
+            raise InvalidAssociation.new(
+                    'Cannot automatically infer target viewmodels from polymorphic association')
+          end
+          infer_viewmodel_class(target_reflection.klass)
         end
+
+      @referenced = @viewmodel_classes.first.root?
+
+      # Non-referenced viewmodels must be owned. For referenced viewmodels, we
+      # own it if it points to us. Through associations aren't considered
+      # `owned?`: while we do own the implicit direct viewmodel, we don't own
+      # the target of the association.
+      @owned = !@referenced || (target_reflection.macro != :belongs_to)
+
+      unless @viewmodel_classes.all? { |v| v.root? == @referenced }
+        raise InvalidAssociation.new('Invalid association target: mixed root and non-root viewmodels')
       end
-    end
 
-    if through?
-      # Through associations must always be an owned direct association to a
-      # shared indirect target. We expect the user to set shared: true to
-      # express the ownership of the indirect target, but this direct
-      # association to the intermediate is in fact owned. This ownership
-      # property isn't directly used anywhere: the synthetic intermediate
-      # viewmodel is only used in the deserialization update operations, which
-      # directly understands the semantics of through associations.
-      raise ArgumentError.new("Through associations must be to a shared target") unless @shared
-      raise ArgumentError.new("Through associations must be `has_many`") unless direct_reflection.macro == :has_many
-    end
-  end
+      if external? && !@referenced
+        raise InvalidAssociation.new('External associations must be to root viewmodels')
+      end
 
-  # reflection for the target of this association: indirect if through, direct otherwise
-  def target_reflection
-    if through?
-      indirect_reflection
-    else
-      direct_reflection
+      if through?
+        unless @referenced
+          raise InvalidAssociation.new('Through associations must be to root viewmodels')
+        end
+
+        @direct_viewmodel = build_direct_viewmodel(@direct_reflection, @indirect_reflection,
+                                                   @viewmodel_classes, @through_order_attr)
+      end
+
+      @initialized = true
     end
   end
 
-  def polymorphic?
-    target_reflection.polymorphic?
+  def association?
+    true
   end
 
-  def viewmodel_classes
-    # If we weren't given explicit viewmodel classes, try to work out from the
-    # names. This should work unless the association is polymorphic.
-    @viewmodel_classes ||=
-      begin
-        model_class = target_reflection.klass
-        if model_class.nil?
-          raise "Couldn't derive target class for association '#{target_reflection.name}"
-        end
-        inferred_view_name = ViewModel::Registry.default_view_name(model_class.name)
-        viewmodel_class = ViewModel::Registry.for_view_name(inferred_view_name) # TODO: improve error message to show it's looking for default name
-        [viewmodel_class]
-      end
+  def referenced?
+    lazy_initialize! unless @initialized
+    @referenced
   end
 
-  private def model_to_viewmodel
-    @model_to_viewmodel ||= viewmodel_classes.each_with_object({}) do |vm, h|
-      h[vm.model_class] = vm
-    end
+  def nested?
+    !referenced?
   end
 
-  private def name_to_viewmodel
-    @name_to_viewmodel ||= viewmodel_classes.each_with_object({}) do |vm, h|
-      h[vm.view_name] = vm
-      vm.view_aliases.each do |view_alias|
-        h[view_alias] = vm
-      end
-    end
+  def owned?
+    lazy_initialize! unless @initialized
+    @owned
   end
 
   def shared?
-    @shared
+    !owned?
+  end
+
+  def external?
+    @external
+  end
+
+  def read_only?
+    @read_only
+  end
+
+  # reflection for the target of this association: indirect if through, direct otherwise
+  def target_reflection
+    if through?
+      indirect_reflection
+    else
+      direct_reflection
+    end
   end
 
-  def optional?
-    @optional
+  def polymorphic?
+    target_reflection.polymorphic?
   end
 
-  def pointer_location # TODO name
+  # The side of the immediate association that holds the pointer.
+  def pointer_location
     case direct_reflection.macro
     when :belongs_to
       :local
@@ -98,6 +140,24 @@ class ViewModel::ActiveRecord::AssociationData
     end
   end
 
+  def indirect_reflection
+    lazy_initialize! unless @initialized
+    @indirect_reflection
+  end
+
+  def direct_reflection_inverse(foreign_class = nil)
+    if direct_reflection.polymorphic?
+      direct_reflection.polymorphic_inverse_of(foreign_class)
+    else
+      direct_reflection.inverse_of
+    end
+  end
+
+  def viewmodel_classes
+    lazy_initialize! unless @initialized
+    @viewmodel_classes
+  end
+
   def viewmodel_class_for_model(model_class)
     model_to_viewmodel[model_class]
   end
@@ -132,47 +192,101 @@ class ViewModel::ActiveRecord::AssociationData
     unless viewmodel_classes.size == 1
       raise ArgumentError.new("More than one possible class for association '#{target_reflection.name}'")
     end
+
     viewmodel_classes.first
   end
 
   def through?
-    @through_to.present?
+    @indirect_association_name.present?
   end
 
   def direct_viewmodel
-    @direct_viewmodel ||= begin
-      raise 'not a through association' unless through?
+    raise ArgumentError.new('not a through association') unless through?
+    lazy_initialize! unless @initialized
+    @direct_viewmodel
+  end
+
+  def collection?
+    through? || direct_reflection.collection?
+  end
 
-      # Join table viewmodel class
+  def indirect_association_data
+    direct_viewmodel._association_data(indirect_reflection.name)
+  end
 
-      # For A has_many B through T; where this association is defined on A
+  private
 
-      # Copy into scope for new class block
-      direct_reflection   = self.direct_reflection    # A -> T
-      indirect_reflection = self.indirect_reflection  # T -> B
-      through_order_attr  = @through_order_attr
-      viewmodel_classes   = self.viewmodel_classes
+  # Through associations must always be to a root viewmodel, via an owned
+  # has_many association to an intermediate model. A synthetic viewmodel is
+  # created to represent this intermediate, but is used only internally by the
+  # deserialization update operations, which directly understands the semantics
+  # of through associations.
+  def load_indirect_reflection(intermediate_model, indirect_association_name)
+    indirect_reflection =
+      intermediate_model.reflect_on_association(ActiveSupport::Inflector.singularize(indirect_association_name))
 
-      Class.new(ViewModel::ActiveRecord) do
-        self.synthetic = true
-        self.model_class = direct_reflection.klass
-        self.view_name = direct_reflection.klass.name
-        association indirect_reflection.name, shared: true, optional: false, viewmodels: viewmodel_classes
-        acts_as_list through_order_attr if through_order_attr
-      end
+    if indirect_reflection.nil?
+      raise InvalidAssociation.new(
+              "Indirect association '#{@indirect_association_name}' not found in "\
+              "intermediate model '#{intermediate_model.name}'")
+    end
+
+    unless direct_reflection.macro == :has_many
+      raise InvalidAssociation.new('Through associations must be `has_many`')
     end
+
+    indirect_reflection
   end
 
-  def indirect_reflection
-    @indirect_reflection ||=
-      direct_reflection.klass.reflect_on_association(ActiveSupport::Inflector.singularize(@through_to))
+  def build_direct_viewmodel(direct_reflection, indirect_reflection, viewmodel_classes, through_order_attr)
+    # Join table viewmodel class. For A has_many B through T; where this association is defined on A
+    # direct_reflection   = A -> T
+    # indirect_reflection = T -> B
+
+    Class.new(ViewModel::ActiveRecord) do
+      self.synthetic = true
+      self.model_class = direct_reflection.klass
+      self.view_name = direct_reflection.klass.name
+      association indirect_reflection.name, viewmodels: viewmodel_classes
+      acts_as_list through_order_attr if through_order_attr
+    end
   end
 
-  def collection?
-    through? || direct_reflection.collection?
+  def resolve_viewmodel_class(v)
+    case v
+    when String, Symbol
+      ViewModel::Registry.for_view_name(v.to_s)
+    when Class
+      v
+    else
+      raise InvalidAssociation.new("Invalid viewmodel class: #{v.inspect}")
+    end
   end
 
-  def indirect_association_data
-    direct_viewmodel._association_data(indirect_reflection.name)
+  def infer_viewmodel_class(model_class)
+    # If we weren't given explicit viewmodel classes, try to work out from the
+    # names. This should work unless the association is polymorphic.
+    if model_class.nil?
+      raise InvalidAssociation.new("Couldn't derive target class for model association '#{target_reflection.name}'")
+    end
+
+    inferred_view_name = ViewModel::Registry.default_view_name(model_class.name)
+    viewmodel_class = ViewModel::Registry.for_view_name(inferred_view_name) # TODO: improve error message to show it's looking for default name
+    [viewmodel_class]
+  end
+
+  def model_to_viewmodel
+    @model_to_viewmodel ||= viewmodel_classes.each_with_object({}) do |vm, h|
+      h[vm.model_class] = vm
+    end
+  end
+
+  def name_to_viewmodel
+    @name_to_viewmodel ||= viewmodel_classes.each_with_object({}) do |vm, h|
+      h[vm.view_name] = vm
+      vm.view_aliases.each do |view_alias|
+        h[view_alias] = vm
+      end
+    end
   end
 end

data/lib/view_model/active_record/association_manipulation.rb

@@ -52,9 +52,7 @@ module ViewModel::ActiveRecord::AssociationManipulation
   def replace_associated(association_name, update_hash, references: {}, deserialize_context: self.class.new_deserialize_context)
     association_data = self.class._association_data(association_name)
 
-    # TODO: structure checking
-
-    if association_data.through? || association_data.shared?
+    if association_data.referenced?
       is_fupdate =
         association_data.collection? &&
         update_hash.is_a?(Hash) &&
@@ -125,10 +123,6 @@ module ViewModel::ActiveRecord::AssociationManipulation
 
           update_context = ViewModel::ActiveRecord::UpdateContext.build!(root_update_data, referenced_update_data, root_type: direct_viewmodel_class)
 
-          # Provide information about what was updated
-          deserialize_context.updated_associations = root_update_data.map(&:updated_associations)
-                                                       .inject({}) { |acc, assocs| acc.deep_merge(assocs) }
-
           # Set new parent
           new_parent = ViewModel::ActiveRecord::UpdateOperation::ParentData.new(direct_reflection.inverse_of, self)
           update_context.root_updates.each { |update| update.reparent_to = new_parent }
@@ -177,15 +171,26 @@ module ViewModel::ActiveRecord::AssociationManipulation
           child_context = self.context_for_child(association_name, context: deserialize_context)
           updated_viewmodels = update_context.run!(deserialize_context: child_context)
 
+          # Propagate changes and finalize the parent
+          updated_viewmodels.each do |child|
+            child_changes = child.previous_changes
+
+            if association_data.nested?
+              nested_children_changed!     if child_changes.changed_nested_tree?
+              referenced_children_changed! if child_changes.changed_referenced_children?
+            elsif association_data.owned?
+              referenced_children_changed! if child_changes.changed_owned_tree?
+            end
+          end
+
+          final_changes = self.clear_changes!
+
           if association_data.through?
             updated_viewmodels.map! do |direct_vm|
               direct_vm._read_association(association_data.indirect_reflection.name)
             end
           end
 
-          # Finalize the parent
-          final_changes = self.clear_changes!
-
           # Could happen if hooks attempted to change the parent, which aren't
           # valid since we're only editing children here.
           unless final_changes.contained_to?(associations: [association_name.to_s])
@@ -269,7 +274,12 @@ module ViewModel::ActiveRecord::AssociationManipulation
           association.delete(child_vm.model)
         end
 
-        self.children_changed!
+        if association_data.nested?
+          nested_children_changed!
+        elsif association_data.owned?
+          referenced_children_changed!
+        end
+
         final_changes = self.clear_changes!
 
         unless final_changes.contained_to?(associations: [association_name.to_s])
@@ -286,7 +296,7 @@ module ViewModel::ActiveRecord::AssociationManipulation
 
   private
 
-  def construct_direct_append_updates(association_data, subtree_hashes, references)
+  def construct_direct_append_updates(_association_data, subtree_hashes, references)
     ViewModel::ActiveRecord::UpdateData.parse_hashes(subtree_hashes, references)
   end
 

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

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

data/lib/view_model/active_record/cache.rb

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

data/lib/view_model/active_record/cloner.rb

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

data/lib/view_model/active_record/controller.rb

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

data/lib/view_model/active_record/update_context.rb

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