iknow_view_models 2.10.1 → 3.0.0

data/lib/view_model/record.rb

@@ -36,22 +36,30 @@ class ViewModel::Record < ViewModel
     end
 
     # Specifies an attribute from the model to be serialized in this view
-    def attribute(attr, as: nil, read_only: false, write_once: false, using: nil, format: nil, array: false, optional: false)
+    def attribute(attr, as: nil, read_only: false, write_once: false, using: nil, format: nil, array: false)
       model_attribute_name = attr.to_s
       vm_attribute_name    = (as || attr).to_s
 
       if using && format
-        raise ArgumentError.new("Only one of :using and :format may be specified")
+        raise ArgumentError.new("Only one of ':using' and ':format' may be specified")
       end
       if using && !(using.is_a?(Class) && using < ViewModel)
         raise ArgumentError.new("Invalid 'using:' viewmodel: not a viewmodel class")
       end
+      if using && using.root?
+        raise ArgumentError.new("Invalid 'using:' viewmodel: is a root")
+      end
       if format && !format.respond_to?(:dump) && !format.respond_to?(:load)
         raise ArgumentError.new("Invalid 'format:' serializer: must respond to :dump and :load")
       end
 
-      attr_data = AttributeData.new(vm_attribute_name, model_attribute_name, using, format,
-                                    array, optional, read_only, write_once)
+      attr_data = AttributeData.new(name: vm_attribute_name,
+                                    model_attr_name: model_attribute_name,
+                                    attribute_viewmodel: using,
+                                    attribute_serializer: format,
+                                    array: array,
+                                    read_only: read_only,
+                                    write_once: write_once)
       _members[vm_attribute_name] = attr_data
 
       @generated_accessor_module.module_eval do
@@ -166,9 +174,10 @@ class ViewModel::Record < ViewModel
 
     self.model = model
 
-    @new_model          = false
-    @changed_attributes = []
-    @changed_children   = false
+    @new_model                     = false
+    @changed_attributes            = []
+    @changed_nested_children       = false
+    @changed_referenced_children   = false
   end
 
   # VM::Record identity matches the identity of its model. If the model has a
@@ -189,8 +198,12 @@ class ViewModel::Record < ViewModel
     @new_model
   end
 
-  def changed_children?
-    @changed_children
+  def changed_nested_children?
+    @changed_nested_children
+  end
+
+  def changed_referenced_children?
+    @changed_referenced_children
   end
 
   def serialize_view(json, serialize_context: self.class.new_serialize_context)
@@ -202,9 +215,7 @@ class ViewModel::Record < ViewModel
   end
 
   def serialize_members(json, serialize_context:)
-    self.class._members.each do |member_name, member_data|
-      next unless serialize_context.includes_member?(member_name, !member_data.optional?)
-
+    self.class._members.each do |member_name, _member_data|
       self.public_send("serialize_#{member_name}", json, serialize_context: serialize_context)
     end
   end
@@ -227,22 +238,29 @@ class ViewModel::Record < ViewModel
     @changed_attributes << attr_name.to_s
   end
 
-  def children_changed!
-    @changed_children = true
+  def nested_children_changed!
+    @changed_nested_children = true
+  end
+
+  def referenced_children_changed!
+    @changed_referenced_children = true
   end
 
   def changes
     ViewModel::Changes.new(
-      new:                new_model?,
-      changed_attributes: changed_attributes,
-      changed_children:   changed_children?)
+      new:                         new_model?,
+      changed_attributes:          changed_attributes,
+      changed_nested_children:     changed_nested_children?,
+      changed_referenced_children: changed_referenced_children?,
+    )
   end
 
   def clear_changes!
-    @previous_changes   = changes
-    @new_model          = false
-    @changed_attributes = []
-    @changed_children   = false
+    @previous_changes           = changes
+    @new_model                  = false
+    @changed_attributes         = []
+    @changed_nested_children    = false
+    @changed_referenced_children = false
     previous_changes
   end
 
@@ -348,9 +366,11 @@ class ViewModel::Record < ViewModel
       model.public_send("#{attr_data.model_attr_name}=", value)
     end
 
-    if attr_data.using_viewmodel? &&
-       Array.wrap(value).any? { |v| v.respond_to?(:previous_changes) && v.previous_changes.changed_tree? }
-      self.children_changed!
+    if attr_data.using_viewmodel?
+      previous_changes = Array.wrap(value).select { |v| v.respond_to?(:previous_changes) }.map!(&:previous_changes)
+
+      self.nested_children_changed!     if previous_changes.any? { |pc| pc.changed_nested_tree? }
+      self.referenced_children_changed! if previous_changes.any? { |pc| pc.changed_referenced_children? }
     end
   end
 

data/lib/view_model/serialize_context.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'active_support/core_ext'
 require 'view_model/traversal_context'
 
@@ -17,52 +19,6 @@ class ViewModel::SerializeContext < ViewModel::TraversalContext
   end
 
   delegate :references, :flatten_references, to: :shared_context
-
-  attr_reader :include, :prune
-
-  def initialize(include: nil, prune: nil, **rest)
-    super(**rest)
-    @include = self.class.normalize_includes(include)
-    @prune   = self.class.normalize_includes(prune)
-  end
-
-  def initialize_as_child(include:, prune:, **rest)
-    super(**rest)
-    @include = include
-    @prune   = prune
-  end
-
-  def for_child(parent_viewmodel, association_name:, **rest)
-    super(parent_viewmodel,
-          association_name: association_name,
-          include: @include.try { |i| i[association_name] },
-          prune:   @prune.try   { |p| p[association_name] },
-          **rest)
-  end
-
-  def includes_member?(member_name, default)
-    member_name = member_name.to_s
-
-    # Every node in the include tree is to be included
-    included = @include.try { |is| is.has_key?(member_name) }
-    # whereas only the leaves of the prune tree are to be removed
-    pruned   = @prune.try { |ps| ps.fetch(member_name, :sentinel).nil? }
-
-    (default || included) && !pruned
-  end
-
-  def add_includes(includes)
-    return if includes.blank?
-    @include ||= {}
-    @include.deep_merge!(self.class.normalize_includes(includes))
-  end
-
-  def add_prunes(prunes)
-    return if prunes.blank?
-    @prune ||= {}
-    @prune.deep_merge!(self.class.normalize_includes(prunes))
-  end
-
   delegate :add_reference, :has_references?, to: :references
 
   # Return viewmodels referenced during serialization and clear @references.
@@ -98,21 +54,4 @@ class ViewModel::SerializeContext < ViewModel::TraversalContext
   def serialize_references_to_hash
     Jbuilder.new { |json| serialize_references(json) }.attributes!
   end
-
-  def self.normalize_includes(includes)
-    case includes
-    when Array
-      includes.each_with_object({}) do |v, new_includes|
-        new_includes.merge!(normalize_includes(v))
-      end
-    when Hash
-      includes.each_with_object({}) do |(k,v), new_includes|
-        new_includes[k.to_s] = normalize_includes(v)
-      end
-    when nil
-      nil
-    else
-      { includes.to_s => nil }
-    end
-  end
 end

data/lib/view_model/test_helpers/arvm_builder.rb

@@ -62,10 +62,8 @@ class ViewModel::TestHelpers::ARVMBuilder
     ActiveRecord::Base.connection.execute("DROP TABLE IF EXISTS #{name.underscore.pluralize} CASCADE")
     namespace.send(:remove_const, name)
     namespace.send(:remove_const, viewmodel_name) if viewmodel
-    if ActiveSupport::VERSION::MAJOR < 7
-      # prevent cached old class from being used to resolve associations
-      ActiveSupport::Dependencies::Reference.clear!
-    end
+    # prevent cached old class from being used to resolve associations
+    ActiveSupport::Dependencies::Reference.clear!
   end
 
   private

data/lib/view_model/traversal_context.rb

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

data/lib/view_model.rb

@@ -3,7 +3,6 @@
 # A ViewModel encapsulates a particular aggregation of data calculated via the
 # underlying models and provides a means of serializing it into views.
 require 'jbuilder'
-require 'base64'
 require 'deep_preloader'
 
 class ViewModel
@@ -21,6 +20,7 @@ class ViewModel
     attr_accessor :_attributes
     attr_accessor :schema_version
     attr_reader   :view_aliases
+    attr_writer   :view_name
 
     def inherited(subclass)
       subclass.initialize_as_viewmodel
@@ -42,15 +42,23 @@ class ViewModel
         end
     end
 
-    def view_name=(name)
-      @view_name = name
-    end
-
     def add_view_alias(as)
       view_aliases << as
       ViewModel::Registry.register(self, as: as)
     end
 
+    # ViewModels are either roots or children. Root viewmodels may be
+    # (de)serialized directly, whereas child viewmodels are always nested within
+    # their parent. Associations to root viewmodel types always use indirect
+    # references.
+    def root?
+      false
+    end
+
+    def root!
+      define_singleton_method(:root?) { true }
+    end
+
     # ViewModels are typically going to be pretty simple structures. Make it a
     # bit easier to define them: attributes specified this way are given
     # accessors and assigned in order by the default constructor.
@@ -60,7 +68,7 @@ class ViewModel
 
     def attribute(attr, **_args)
       unless attr.is_a?(Symbol)
-        raise ArgumentError.new("ViewModel attributes must be symbols")
+        raise ArgumentError.new('ViewModel attributes must be symbols')
       end
 
       attr_accessor attr
@@ -117,7 +125,7 @@ class ViewModel
     # If this viewmodel represents an AR model, what associations does it make
     # use of? Returns a includes spec appropriate for DeepPreloader, either as
     # AR-style nested hashes or DeepPreloader::Spec.
-    def eager_includes(serialize_context: new_serialize_context, include_shared: true)
+    def eager_includes(serialize_context: new_serialize_context, include_referenced: true)
       {}
     end
 
@@ -210,26 +218,26 @@ class ViewModel
       ViewModel::SerializeContext
     end
 
-    def new_serialize_context(...)
-      serialize_context_class.new(...)
+    def new_serialize_context(*args)
+      serialize_context_class.new(*args)
     end
 
     def deserialize_context_class
       ViewModel::DeserializeContext
     end
 
-    def new_deserialize_context(...)
-      deserialize_context_class.new(...)
+    def new_deserialize_context(*args)
+      deserialize_context_class.new(*args)
     end
 
     def accepts_schema_version?(schema_version)
       schema_version == self.schema_version
     end
 
-    def preload_for_serialization(viewmodels, serialize_context: new_serialize_context, include_shared: true, lock: nil)
+    def preload_for_serialization(viewmodels, serialize_context: new_serialize_context, include_referenced: true, lock: nil)
       Array.wrap(viewmodels).group_by(&:class).each do |type, views|
         DeepPreloader.preload(views.map(&:model),
-                              type.eager_includes(serialize_context: serialize_context, include_shared: include_shared),
+                              type.eager_includes(serialize_context: serialize_context, include_referenced: include_referenced),
                               lock: lock)
       end
     end

data/shell.nix

@@ -1,7 +1,7 @@
 with import <nixpkgs> {};
 
 (bundlerEnv {
-  name = "dev";
+  name = "iknow-view-models-shell";
   gemdir = ./nix/gem;
 
   gemConfig = (defaultGemConfig.override { postgresql = postgresql_11; });

data/test/helpers/arvm_test_models.rb

@@ -6,18 +6,10 @@ require "view_model/active_record/controller"
 
 require "acts_as_manual_list"
 
-db_config =
-  if (url = ENV['DATABASE_URL'])
-    url
-  else
-    db_config_path = File.join(File.dirname(__FILE__), '../config/database.yml')
-    yaml = YAML.safe_load(File.open(db_config_path))
-    raise 'Test database configuration missing' unless yaml['test']
-
-    yaml['test']
-  end
-
-ActiveRecord::Base.establish_connection(db_config)
+db_config_path = File.join(File.dirname(__FILE__), '../config/database.yml')
+db_config = YAML.load(File.open(db_config_path))
+raise "Test database configuration missing" unless db_config["test"]
+ActiveRecord::Base.establish_connection(db_config["test"])
 
 # Remove test tables if any exist
 %w[labels parents children targets poly_ones poly_twos owners

data/test/helpers/arvm_test_utilities.rb

@@ -4,6 +4,12 @@ require 'minitest/hooks'
 require 'view_model'
 require 'view_model/test_helpers'
 
+unless ViewModel::Config.configured?
+  ViewModel::Config.configure! do
+    debug_deserialization true
+  end
+end
+
 require_relative 'query_logging.rb'
 
 ActiveSupport::TestCase.include(Minitest::Hooks)

data/test/helpers/controller_test_helpers.rb

@@ -33,6 +33,7 @@ module ControllerTestModels
         has_many :parents
       end
       define_viewmodel do
+        root!
         attributes :name
       end
     end
@@ -77,11 +78,12 @@ module ControllerTestModels
         belongs_to :category
       end
       define_viewmodel do
+        root!
         attributes   :name
         associations :label, :target
-        association  :children, optional: true
+        association  :children
         association  :poly, viewmodels: [:PolyOne, :PolyTwo]
-        association  :category, shared: true
+        association  :category, external: true
       end
     end
 
@@ -99,7 +101,7 @@ module ControllerTestModels
       define_model do
         belongs_to :parent, inverse_of: :children
         acts_as_manual_list scope: :parent
-        validates :age, numericality: {less_than: 42}, allow_nil: true
+        validates :age, numericality: { less_than: 42 }, allow_nil: true
       end
       define_viewmodel do
         attributes :name, :age
@@ -267,9 +269,7 @@ module ControllerTestControllers
     [:ParentController, :ChildController, :LabelController, :TargetController].each do |name|
       Object.send(:remove_const, name)
     end
-    if ActiveSupport::VERSION::MAJOR < 7
-      ActiveSupport::Dependencies::Reference.clear!
-    end
+    ActiveSupport::Dependencies::Reference.clear!
     super
   end
 end

data/test/helpers/viewmodel_spec_helpers.rb

@@ -77,7 +77,7 @@ module ViewModelSpecHelpers
       ViewModel::TestHelpers::ARVMBuilder::Spec.new(
         schema:    ->(t) { t.string :name },
         model:     ->(m) {},
-        viewmodel: ->(v) { attribute :name }
+        viewmodel: ->(v) { root!; attribute :name }
       )
     end
 
@@ -99,6 +99,10 @@ module ViewModelSpecHelpers
       raise RuntimeError.new('Test model does not have a child association')
     end
 
+    def subject_association_features
+      {}
+    end
+
     def subject_association_name
       subject_association.association_name
     end
@@ -114,9 +118,10 @@ module ViewModelSpecHelpers
     include ViewModelSpecHelpers::Base
 
     def model_attributes
+      f = subject_association_features
       super.merge(schema:    ->(t) { t.references :child, foreign_key: true },
                   model:     ->(m) { belongs_to :child, inverse_of: :model, dependent: :destroy },
-                  viewmodel: ->(v) { association :child })
+                  viewmodel: ->(v) { association :child, **f })
     end
 
     def child_attributes
@@ -134,17 +139,33 @@ module ViewModelSpecHelpers
     end
   end
 
+  module ParentAndSharedBelongsToChild
+    extend ActiveSupport::Concern
+    include ViewModelSpecHelpers::ParentAndBelongsToChild
+    def child_attributes
+      super.merge(viewmodel: ->(v) { root! })
+    end
+  end
+
   module List
     extend ActiveSupport::Concern
     include ViewModelSpecHelpers::Base
 
     def model_attributes
-      super.merge(schema:    ->(t) { t.integer :next_id },
-                  model:     ->(m) {
-                    belongs_to :next, class_name: self.name, inverse_of: :previous, dependent: :destroy
-                    has_one :previous, class_name: self.name, foreign_key: :next_id, inverse_of: :next
-                  },
-                  viewmodel: ->(v) { association :next })
+      ViewModel::TestHelpers::ARVMBuilder::Spec.new(
+        schema:    ->(t) {
+          t.string :name
+          t.integer :next_id
+        },
+        model:     ->(m) {
+          belongs_to :next, class_name: self.name, inverse_of: :previous, dependent: :destroy
+          has_one :previous, class_name: self.name, foreign_key: :next_id, inverse_of: :next
+        },
+        viewmodel: ->(v) {
+          # Not a root
+          association :next
+          attribute :name
+        })
     end
 
     def subject_association
@@ -157,9 +178,10 @@ module ViewModelSpecHelpers
     include ViewModelSpecHelpers::Base
 
     def model_attributes
+      f = subject_association_features
       super.merge(
         model:     ->(m) { has_one :child, inverse_of: :model, dependent: :destroy },
-        viewmodel: ->(v) { association :child }
+        viewmodel: ->(v) { association :child, **f }
       )
     end
 
@@ -181,14 +203,23 @@ module ViewModelSpecHelpers
     end
   end
 
+  module ParentAndReferencedHasOneChild
+    extend ActiveSupport::Concern
+    include ViewModelSpecHelpers::ParentAndHasOneChild
+    def child_attributes
+      super.merge(viewmodel: ->(v) { root! })
+    end
+  end
+
   module ParentAndHasManyChildren
     extend ActiveSupport::Concern
     include ViewModelSpecHelpers::Base
 
     def model_attributes
+      f = subject_association_features
       super.merge(
         model:     ->(m) { has_many :children, inverse_of: :model, dependent: :destroy },
-        viewmodel: ->(v) { association :children }
+        viewmodel: ->(v) { association :children, **f }
       )
     end
 
@@ -210,22 +241,23 @@ module ViewModelSpecHelpers
     end
   end
 
-  module ParentAndOrderedChildren
+  module ParentAndSharedHasManyChildren
     extend ActiveSupport::Concern
-    include ViewModelSpecHelpers::Base
-
-    def model_attributes
-      super.merge(
-        model:     ->(m) { has_many :children, inverse_of: :model, dependent: :destroy },
-        viewmodel: ->(v) { association :children },
-      )
+    include ViewModelSpecHelpers::ParentAndHasManyChildren
+    def child_attributes
+      super.merge(viewmodel: ->(v) { root! })
     end
+  end
+
+  module ParentAndOrderedChildren
+    extend ActiveSupport::Concern
+    include ViewModelSpecHelpers::ParentAndHasManyChildren
 
     def child_attributes
       super.merge(
-        schema:    ->(t) { t.references :model, foreign_key: true; t.float :position, null: false },
-        model:     ->(m) { belongs_to :model, inverse_of: :children },
-        viewmodel: ->(v) { acts_as_list :position },
+        schema:    ->(t) { t.float :position, null: false },
+        model:     ->(_m) { acts_as_manual_list scope: :model },
+        viewmodel: ->(_v) { acts_as_list :position },
       )
     end
 
@@ -233,7 +265,7 @@ module ViewModelSpecHelpers
       # child depends on parent, ensure it's touched first
       viewmodel_class
 
-      # Add a deferrable unique position constraiont
+      # Add a deferrable unique position constraint
       super do |klass|
         model = klass.model_class
         table = model.table_name
@@ -242,38 +274,15 @@ module ViewModelSpecHelpers
           SQL
       end
     end
-
-    def subject_association
-      viewmodel_class._association_data('children')
-    end
   end
 
-  module ParentAndSharedChild
-    extend ActiveSupport::Concern
-    include ViewModelSpecHelpers::Base
 
-    def model_attributes
-      super.merge(
-        schema:    ->(t) { t.references :child, foreign_key: true },
-        model:     ->(m) { belongs_to :child, inverse_of: :model, dependent: :destroy },
-        viewmodel: ->(v) { association :child, shared: true }
-      )
-    end
-
-    def child_attributes
-      super.merge(
-        model: ->(m) { has_one :model, inverse_of: :child }
-      )
-    end
-
-    # parent depends on child, ensure it's touched first
-    def viewmodel_class
-      child_viewmodel_class
-      super
-    end
+  module ParentAndExternalSharedChild
+    extend ActiveSupport::Concern
+    include ViewModelSpecHelpers::ParentAndSharedBelongsToChild
 
-    def subject_association
-      viewmodel_class._association_data('child')
+    def subject_association_features
+      { external: true }
     end
   end
 
@@ -282,15 +291,17 @@ module ViewModelSpecHelpers
     include ViewModelSpecHelpers::Base
 
     def model_attributes
+      f = subject_association_features
       super.merge(
         model:     ->(m) { has_many :model_children, inverse_of: :model, dependent: :destroy },
-        viewmodel: ->(v) { association :children, shared: true, through: :model_children, through_order_attr: :position }
+        viewmodel: ->(v) { association :children, through: :model_children, through_order_attr: :position, **f }
       )
     end
 
     def child_attributes
       super.merge(
-        model: ->(m) { has_many :model_children, inverse_of: :child, dependent: :destroy }
+        model: ->(m) { has_many :model_children, inverse_of: :child, dependent: :destroy },
+        viewmodel: ->(v) { root! }
       )
     end