iknow_view_models 3.2.2 → 3.2.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a86b2b9fdc89ee421bcb155ae29e3ac4f2c809be4d40e483a405337f8729a7f9
-  data.tar.gz: 8fd1c498264a0eefe30d9c3c6a35c4f005a94aaf71b03d37044a23212cb90eb4
+  metadata.gz: 4873d88f99bcdf0d63c3db8cbf36af0990bd9dd88bca0e170159b873b8aa7212
+  data.tar.gz: b190cb5ec7806dfe4f8decbf4acf8f54b7fcc0857f271d1417b4d680a87c0622
 SHA512:
-  metadata.gz: c2a2fd321cf605709eb398771cd6cc475869e80c59d5a4934a2cf5429cfa3e1a6a5e3e74f358227793ff2cc7ce10a1eff46fe3c4db20e859d49d54be306b4afb
-  data.tar.gz: cfb7009b02acbebce85d3ad41205549430370710633d51176ac8596acf6a83fb98f0e76132bf850baf37da36acfe402afc21d00c8996f66ca2a98f62a9380dc1
+  metadata.gz: 57c4fad3880aa1ce8f3434827df3dd6a789561a0f3bd8210b774c86258b8a0d4be777cbb827760f6c405b7caa61875efb8a780b3a2a9d7eff203315490d5f450
+  data.tar.gz: ffe26b3f24098c1ce7bd07453ce5a4f9a0bfd9611e57a53ccb7394b98fc2b8af724dc598bca85e0d2713c457d3fb5cc8575006ed947ade06aa7efd11f4436c16

data/lib/iknow_view_models/version.rb

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

data/lib/view_model.rb

@@ -245,7 +245,9 @@ class ViewModel
 
     def schema_hash(schema_versions)
       version_string = schema_versions.to_a.sort.join(',')
-      Base64.urlsafe_encode64(Digest::MD5.digest(version_string))
+      # We want a short hash value, as this will be used in cache keys
+      hash = Digest::SHA256.digest(version_string).byteslice(0, 16)
+      Base64.urlsafe_encode64(hash, padding: false)
     end
 
     def preload_for_serialization(viewmodels, serialize_context: new_serialize_context, include_referenced: true, lock: nil)

data/lib/view_model/active_record.rb

@@ -224,7 +224,7 @@ class ViewModel::ActiveRecord < ViewModel::Record
       DeepPreloader::Spec.new(association_specs)
     end
 
-    def dependent_viewmodels(seen = Set.new, include_referenced: true)
+    def dependent_viewmodels(seen = Set.new, include_referenced: true, include_external: true)
       return if seen.include?(self)
 
       seen << self
@@ -232,19 +232,20 @@ class ViewModel::ActiveRecord < ViewModel::Record
       _members.each_value do |data|
         next unless data.is_a?(AssociationData)
         next unless include_referenced || !data.referenced?
+        next unless include_external   || !data.external?
 
         data.viewmodel_classes.each do |vm|
-          vm.dependent_viewmodels(seen, include_referenced: include_referenced)
+          vm.dependent_viewmodels(seen, include_referenced: include_referenced, include_external: include_external)
         end
       end
 
       seen
     end
 
-    def deep_schema_version(include_referenced: true)
+    def deep_schema_version(include_referenced: true, include_external: true)
       (@deep_schema_version ||= {})[include_referenced] ||=
         begin
-          dependent_viewmodels(include_referenced: include_referenced).each_with_object({}) do |view, h|
+          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
         end

data/lib/view_model/registry.rb

@@ -6,7 +6,8 @@ class ViewModel::Registry
   DEFERRED_NAME = Object.new
 
   class << self
-    delegate :for_view_name, :register, :default_view_name, :infer_model_class_name, :clear_removed_classes!,
+    delegate :for_view_name, :register, :default_view_name, :infer_model_class_name,
+             :clear_removed_classes!, :all, :roots,
              to: :instance
   end
 
@@ -33,6 +34,17 @@ class ViewModel::Registry
     end
   end
 
+  def all
+    @lock.synchronize do
+      resolve_deferred_classes
+      @viewmodel_classes_by_name.values
+    end
+  end
+
+  def roots
+    all.select { |c| c.root? }
+  end
+
   def register(viewmodel, as: DEFERRED_NAME)
     @lock.synchronize do
       @deferred_viewmodel_classes << [viewmodel, as]

data/test/unit/view_model/record_test.rb

@@ -365,122 +365,140 @@ class ViewModel::RecordTest < ActiveSupport::TestCase
       end
     end
 
-    Nested = Struct.new(:member)
+    describe 'nesting' do
+      let(:nested_model_class) do
+        klass = Struct.new(:member)
+        Object.const_set(:Nested, klass)
+        klass
+      end
 
-    class NestedView < TestViewModel
-      self.view_name = 'Nested'
-      self.model_class = Nested
-      attribute :member
-    end
+      let(:nested_viewmodel_class) do
+        mc = nested_model_class
+        klass = Class.new(TestViewModel) do
+          self.view_name = 'Nested'
+          self.model_class = mc
+          attribute :member
+        end
+        Object.const_set(:NestedView, klass)
+        klass
+      end
 
-    describe 'with nested viewmodel' do
-      let(:default_nested_model) { Nested.new('member') }
-      let(:default_nested_view)  { view_base.merge('_type' => 'Nested', 'member' => 'member') }
+      def teardown
+        Object.send(:remove_const, :Nested)
+        Object.send(:remove_const, :NestedView)
+        ActiveSupport::Dependencies::Reference.clear!
+        super
+      end
 
-      let(:attributes) { { simple: {}, nested: { using: NestedView } } }
+      describe 'with nested viewmodel' do
+        let(:default_nested_model) { nested_model_class.new('member') }
+        let(:default_nested_view)  { view_base.merge('_type' => 'Nested', 'member' => 'member') }
 
-      let(:default_view_values)  { { nested: default_nested_view } }
-      let(:default_model_values) { { nested: default_nested_model } }
+        let(:attributes) { { simple: {}, nested: { using: nested_viewmodel_class } } }
 
-      let(:update_context) do
-        TestDeserializeContext.new(targets: [default_model, default_nested_model],
-                                   access_control: access_control)
-      end
+        let(:default_view_values)  { { nested: default_nested_view } }
+        let(:default_model_values) { { nested: default_nested_model } }
 
-      include CanSerialize
-      include CanDeserializeToNew
-      include CanDeserializeToExisting
+        let(:update_context) do
+          TestDeserializeContext.new(targets: [default_model, default_nested_model],
+                                     access_control: access_control)
+        end
 
-      it 'can update the nested value' do
-        new_view = default_view.merge('nested' => default_nested_view.merge('member' => 'changed'))
+        include CanSerialize
+        include CanDeserializeToNew
+        include CanDeserializeToExisting
 
-        vm = viewmodel_class.deserialize_from_view(new_view, deserialize_context: update_context)
+        it 'can update the nested value' do
+          new_view = default_view.merge('nested' => default_nested_view.merge('member' => 'changed'))
 
-        assert(default_model.equal?(vm.model), 'returned model was not the same')
-        assert(default_nested_model.equal?(vm.model.nested), 'returned nested model was not the same')
+          vm = viewmodel_class.deserialize_from_view(new_view, deserialize_context: update_context)
 
-        assert_equal('changed', default_model.nested.member)
+          assert(default_model.equal?(vm.model), 'returned model was not the same')
+          assert(default_nested_model.equal?(vm.model.nested), 'returned nested model was not the same')
 
-        assert_unchanged(vm)
-        assert_edited(vm.nested, changed_attributes: [:member])
-      end
+          assert_equal('changed', default_model.nested.member)
 
-      it 'can replace the nested value' do
-        # The value will be unified if it is different after deserialization
-        new_view = default_view.merge('nested' => default_nested_view.merge('member' => 'changed'))
+          assert_unchanged(vm)
+          assert_edited(vm.nested, changed_attributes: [:member])
+        end
 
-        partial_update_context = TestDeserializeContext.new(targets: [default_model],
-                                                            access_control: access_control)
+        it 'can replace the nested value' do
+          # The value will be unified if it is different after deserialization
+          new_view = default_view.merge('nested' => default_nested_view.merge('member' => 'changed'))
 
-        vm = viewmodel_class.deserialize_from_view(new_view, deserialize_context: partial_update_context)
+          partial_update_context = TestDeserializeContext.new(targets: [default_model],
+                                                              access_control: access_control)
 
-        assert(default_model.equal?(vm.model), 'returned model was not the same')
-        refute(default_nested_model.equal?(vm.model.nested), 'returned nested model was the same')
+          vm = viewmodel_class.deserialize_from_view(new_view, deserialize_context: partial_update_context)
 
-        assert_edited(vm, new: false, changed_attributes: [:nested])
-        assert_edited(vm.nested, new: true, changed_attributes: [:member])
+          assert(default_model.equal?(vm.model), 'returned model was not the same')
+          refute(default_nested_model.equal?(vm.model.nested), 'returned nested model was the same')
+
+          assert_edited(vm, new: false, changed_attributes: [:nested])
+          assert_edited(vm.nested, new: true, changed_attributes: [:member])
+        end
       end
-    end
 
-    describe 'with array of nested viewmodel' do
-      let(:default_nested_model_1) { Nested.new('member1') }
-      let(:default_nested_view_1)  { view_base.merge('_type' => 'Nested', 'member' => 'member1') }
+      describe 'with array of nested viewmodel' do
+        let(:default_nested_model_1) { nested_model_class.new('member1') }
+        let(:default_nested_view_1)  { view_base.merge('_type' => 'Nested', 'member' => 'member1') }
 
-      let(:default_nested_model_2) { Nested.new('member2') }
-      let(:default_nested_view_2)  { view_base.merge('_type' => 'Nested', 'member' => 'member2') }
+        let(:default_nested_model_2) { nested_model_class.new('member2') }
+        let(:default_nested_view_2)  { view_base.merge('_type' => 'Nested', 'member' => 'member2') }
 
-      let(:attributes) { { simple: {}, nested: { using: NestedView, array: true } } }
+        let(:attributes) { { simple: {}, nested: { using: nested_viewmodel_class, array: true } } }
 
-      let(:default_view_values)  { { nested: [default_nested_view_1, default_nested_view_2] } }
-      let(:default_model_values) { { nested: [default_nested_model_1, default_nested_model_2] } }
+        let(:default_view_values)  { { nested: [default_nested_view_1, default_nested_view_2] } }
+        let(:default_model_values) { { nested: [default_nested_model_1, default_nested_model_2] } }
 
-      let(:update_context) {
-        TestDeserializeContext.new(targets: [default_model, default_nested_model_1, default_nested_model_2],
-                                   access_control: access_control)
-      }
+        let(:update_context) {
+          TestDeserializeContext.new(targets: [default_model, default_nested_model_1, default_nested_model_2],
+                                     access_control: access_control)
+        }
 
-      include CanSerialize
-      include CanDeserializeToNew
-      include CanDeserializeToExisting
+        include CanSerialize
+        include CanDeserializeToNew
+        include CanDeserializeToExisting
 
-      it 'rejects change to attribute' do
-        new_view = default_view.merge('nested' => 'terrible')
-        ex = assert_raises(ViewModel::DeserializationError::InvalidAttributeType) do
-          viewmodel_class.deserialize_from_view(new_view, deserialize_context: update_context)
+        it 'rejects change to attribute' do
+          new_view = default_view.merge('nested' => 'terrible')
+          ex = assert_raises(ViewModel::DeserializationError::InvalidAttributeType) do
+            viewmodel_class.deserialize_from_view(new_view, deserialize_context: update_context)
+          end
+          assert_equal('nested', ex.attribute)
+          assert_equal('Array',  ex.expected_type)
+          assert_equal('String', ex.provided_type)
         end
-        assert_equal('nested', ex.attribute)
-        assert_equal('Array',  ex.expected_type)
-        assert_equal('String', ex.provided_type)
-      end
 
-      it 'can edit a nested value' do
-        default_view['nested'][0]['member'] = 'changed'
-        vm = viewmodel_class.deserialize_from_view(default_view, deserialize_context: update_context)
-        assert(default_model.equal?(vm.model), 'returned model was not the same')
-        assert_equal(2, vm.model.nested.size)
-        assert(default_nested_model_1.equal?(vm.model.nested[0]))
-        assert(default_nested_model_2.equal?(vm.model.nested[1]))
+        it 'can edit a nested value' do
+          default_view['nested'][0]['member'] = 'changed'
+          vm = viewmodel_class.deserialize_from_view(default_view, deserialize_context: update_context)
+          assert(default_model.equal?(vm.model), 'returned model was not the same')
+          assert_equal(2, vm.model.nested.size)
+          assert(default_nested_model_1.equal?(vm.model.nested[0]))
+          assert(default_nested_model_2.equal?(vm.model.nested[1]))
 
-        assert_unchanged(vm)
-        assert_edited(vm.nested[0], changed_attributes: [:member])
-      end
+          assert_unchanged(vm)
+          assert_edited(vm.nested[0], changed_attributes: [:member])
+        end
 
-      it 'can append a nested value' do
-        default_view['nested'] << view_base.merge('_type' => 'Nested', 'member' => 'member3')
+        it 'can append a nested value' do
+          default_view['nested'] << view_base.merge('_type' => 'Nested', 'member' => 'member3')
 
-        vm = viewmodel_class.deserialize_from_view(default_view, deserialize_context: update_context)
+          vm = viewmodel_class.deserialize_from_view(default_view, deserialize_context: update_context)
 
-        assert(default_model.equal?(vm.model), 'returned model was not the same')
-        assert_equal(3, vm.model.nested.size)
-        assert(default_nested_model_1.equal?(vm.model.nested[0]))
-        assert(default_nested_model_2.equal?(vm.model.nested[1]))
+          assert(default_model.equal?(vm.model), 'returned model was not the same')
+          assert_equal(3, vm.model.nested.size)
+          assert(default_nested_model_1.equal?(vm.model.nested[0]))
+          assert(default_nested_model_2.equal?(vm.model.nested[1]))
 
-        vm.model.nested.each_with_index do |nvm, i|
-          assert_equal("member#{i + 1}", nvm.member)
-        end
+          vm.model.nested.each_with_index do |nvm, i|
+            assert_equal("member#{i + 1}", nvm.member)
+          end
 
-        assert_edited(vm, changed_attributes: [:nested])
-        assert_edited(vm.nested[2], new: true, changed_attributes: [:member])
+          assert_edited(vm, changed_attributes: [:nested])
+          assert_edited(vm.nested[2], new: true, changed_attributes: [:member])
+        end
       end
     end
   end

data/test/unit/view_model/registry_test.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'minitest/autorun'
+require 'minitest/unit'
+require 'minitest/hooks'
+
+require_relative '../../helpers/arvm_test_utilities'
+require_relative '../../helpers/arvm_test_models'
+require_relative '../../helpers/viewmodel_spec_helpers'
+
+require 'view_model'
+require 'view_model/active_record'
+
+class ViewModel
+  class RegistryTest < ActiveSupport::TestCase
+    using ViewModel::Utils::Collections
+    include ARVMTestUtilities
+    extend Minitest::Spec::DSL
+    include ViewModelSpecHelpers::ParentAndBelongsToChild
+
+    before(:each) do
+      ViewModel::Registry.clear_removed_classes!
+    end
+
+    it 'registers the views' do
+      assert_equal(ViewModel::Registry.for_view_name(view_name), viewmodel_class)
+      assert_equal(ViewModel::Registry.for_view_name(child_view_name), child_viewmodel_class)
+    end
+
+    it 'enumerates the views' do
+      assert_contains_exactly([ViewModel::ErrorView, viewmodel_class, child_viewmodel_class], ViewModel::Registry.all)
+    end
+
+    it 'enumerates the root views' do
+      assert_contains_exactly([viewmodel_class], ViewModel::Registry.roots)
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: iknow_view_models
 version: !ruby/object:Gem::Version
-  version: 3.2.2
+  version: 3.2.7
 platform: ruby
 authors:
 - iKnow Team
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-10-15 00:00:00.000000000 Z
+date: 2020-10-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -468,6 +468,7 @@ files:
 - test/unit/view_model/controller_test.rb
 - test/unit/view_model/deserialization_error/unique_violation_test.rb
 - test/unit/view_model/record_test.rb
+- test/unit/view_model/registry_test.rb
 - test/unit/view_model/traversal_context_test.rb
 - test/unit/view_model_test.rb
 homepage: https://github.com/iknow/cerego_view_models
@@ -527,5 +528,6 @@ test_files:
 - test/unit/view_model/controller_test.rb
 - test/unit/view_model/deserialization_error/unique_violation_test.rb
 - test/unit/view_model/record_test.rb
+- test/unit/view_model/registry_test.rb
 - test/unit/view_model/traversal_context_test.rb
 - test/unit/view_model_test.rb