iknow_view_models 3.1.8 → 3.2.4

data/lib/view_model/migration/unspecified_version_error.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+class ViewModel::Migration::UnspecifiedVersionError < ViewModel::AbstractError
+  attr_reader :vm_name, :version
+
+  status 400
+
+  def initialize(vm_name, version)
+    @vm_name = vm_name
+    @version = version
+    super()
+  end
+
+  def detail
+    "Provided view for #{vm_name} at version #{version} does not match request"
+  end
+
+  def meta
+    {
+      viewmodel: vm_name,
+      version: version,
+    }
+  end
+end

data/lib/view_model/migrator.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+class ViewModel
+  class Migrator
+    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)
+
+        if required_versions.present?
+          deep_schema_version = deep_schema_version.dup
+
+          required_versions.each do |required_vm_class, required_version|
+            name = required_vm_class.view_name
+            if deep_schema_version.has_key?(name)
+              deep_schema_version[name] = required_version
+            end
+          end
+        end
+
+        deep_schema_version
+      end
+    end
+
+    def initialize(required_versions)
+      @paths = required_versions.each_with_object({}) do |(viewmodel_class, required_version), h|
+        if required_version != viewmodel_class.schema_version
+          path = viewmodel_class.migration_path(from: required_version, to: viewmodel_class.schema_version)
+          h[viewmodel_class.view_name] = path
+        end
+      end
+
+      @versions = required_versions.each_with_object({}) do |(viewmodel_class, required_version), h|
+        h[viewmodel_class.view_name] = [required_version, viewmodel_class.schema_version]
+      end
+    end
+
+    def migrate!(node, references:)
+      case node
+      when Hash
+        if (type = node[ViewModel::TYPE_ATTRIBUTE])
+          version = node[ViewModel::VERSION_ATTRIBUTE]
+
+          if migrate_viewmodel!(type, version, node, references)
+            node[ViewModel::MIGRATED_ATTRIBUTE] = true
+          end
+        end
+
+        node.each_value do |child|
+          migrate!(child, references: references)
+        end
+      when Array
+        node.each { |child| migrate!(child, references: references) }
+      end
+    end
+
+    private
+
+    def migrate_viewmodel!(_view_name, _version, _view_hash, _references)
+      raise RuntimeError.new('abstract method')
+    end
+  end
+
+  class UpMigrator < Migrator
+    private
+
+    def migrate_viewmodel!(view_name, source_version, view_hash, references)
+      path = @paths[view_name]
+      return false unless path
+
+      # We assume that an unspecified source version is the same as the required
+      # version.
+      required_version, current_version = @versions[view_name]
+
+      unless source_version.nil? || source_version == required_version
+        raise ViewModel::Migration::UnspecifiedVersionError.new(view_name, source_version)
+      end
+
+      path.each do |migration|
+        migration.up(view_hash, references)
+      end
+
+      view_hash[ViewModel::VERSION_ATTRIBUTE] = current_version
+
+      true
+    end
+  end
+
+  # down migrations find a reverse path from the current schema version to the
+  # specific version requested by the client.
+  class DownMigrator < Migrator
+    private
+
+    def migrate_viewmodel!(view_name, _, view_hash, references)
+      path = @paths[view_name]
+      return false unless path
+
+      required_version, _current_version = @versions[view_name]
+
+      path.reverse_each do |migration|
+        migration.down(view_hash, references)
+      end
+
+      view_hash[ViewModel::VERSION_ATTRIBUTE] = required_version
+
+      true
+    end
+  end
+end

data/lib/view_model/record.rb

@@ -10,6 +10,9 @@ class ViewModel::Record < ViewModel
   attr_accessor :model
 
   require 'view_model/record/attribute_data'
+  require 'view_model/migratable_view'
+
+  include ViewModel::MigratableView
 
   class << self
     attr_reader :_members
@@ -113,7 +116,7 @@ class ViewModel::Record < ViewModel
       end
     end
 
-    def resolve_viewmodel(metadata, view_hash, deserialize_context:)
+    def resolve_viewmodel(_metadata, _view_hash, deserialize_context:)
       self.for_new_model
     end
 
@@ -178,6 +181,8 @@ class ViewModel::Record < ViewModel
     @changed_attributes            = []
     @changed_nested_children       = false
     @changed_referenced_children   = false
+
+    super()
   end
 
   # VM::Record identity matches the identity of its model. If the model has a
@@ -207,7 +212,7 @@ class ViewModel::Record < ViewModel
   end
 
   def serialize_view(json, serialize_context: self.class.new_serialize_context)
-    json.set!(ViewModel::ID_ATTRIBUTE, model.id) if model.respond_to?(:id)
+    json.set!(ViewModel::ID_ATTRIBUTE, self.id) if stable_id?
     json.set!(ViewModel::TYPE_ATTRIBUTE, self.view_name)
     json.set!(ViewModel::VERSION_ATTRIBUTE, self.class.schema_version)
 
@@ -306,12 +311,10 @@ class ViewModel::Record < ViewModel
       # viewmodel), it's only desired for converting the value to and from wire
       # format, so conversion is deferred to serialization time.
       value = attr_data.map_value(value) do |v|
-        begin
-          attr_data.attribute_serializer.dump(v, json: true)
-        rescue IknowParams::Serializer::DumpError => ex
-          raise ViewModel::SerializationError.new(
-                  "Could not serialize invalid value '#{vm_attr_name}': #{ex.message}")
-        end
+        attr_data.attribute_serializer.dump(v, json: true)
+      rescue IknowParams::Serializer::DumpError => ex
+        raise ViewModel::SerializationError.new(
+                "Could not serialize invalid value '#{vm_attr_name}': #{ex.message}")
       end
     end
 
@@ -339,12 +342,10 @@ class ViewModel::Record < ViewModel
         end
       when attr_data.using_serializer?
         attr_data.map_value(serialized_value) do |sv|
-          begin
-            attr_data.attribute_serializer.load(sv)
-          rescue IknowParams::Serializer::LoadError => ex
-            reason = "could not be deserialized because #{ex.message}"
-            raise ViewModel::DeserializationError::Validation.new(vm_attr_name, reason, {}, blame_reference)
-          end
+          attr_data.attribute_serializer.load(sv)
+        rescue IknowParams::Serializer::LoadError => ex
+          reason = "could not be deserialized because #{ex.message}"
+          raise ViewModel::DeserializationError::Validation.new(vm_attr_name, reason, {}, blame_reference)
         end
       else
         serialized_value

data/lib/view_model/reference.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class ViewModel
   # Key to identify a viewmodel with some kind of inherent ID (e.g. an ViewModel::ActiveRecord)
   class Reference
@@ -22,7 +24,7 @@ class ViewModel
         other.model_id        == model_id
     end
 
-    alias :eql? :==
+    alias eql? ==
 
     def hash
       [viewmodel_class, model_id].hash

data/lib/view_model/references.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class ViewModel
   # A bucket for configuration, used for serializing and deserializing.
   class References
@@ -17,14 +19,15 @@ class ViewModel
     # under which the data is stored. If the data is not present, will compute
     # it by calling the given block.
     def add_reference(value)
-      if (ref = @ref_by_value[value]).present?
-        ref
-      else
+      ref = @ref_by_value[value]
+
+      unless ref.present?
         ref = new_ref!(value)
         @ref_by_value[value] = ref
         @value_by_ref[ref] = value
-        ref
       end
+
+      ref
     end
 
     def clear!
@@ -41,7 +44,7 @@ class ViewModel
         hash = Digest::SHA256.base64digest("#{vm_ref.viewmodel_class.name}.#{vm_ref.model_id}")
         "ref:h:#{hash}"
       else
-        'ref:i:%06d' % (@last_ref += 1)
+        format('ref:i:%06<count>d', count: (@last_ref += 1))
       end
     end
   end

data/lib/view_model/registry.rb

@@ -6,13 +6,14 @@ 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
 
   def initialize
     @lock = Monitor.new
-    @viewmodel_classes_by_name  = {}
+    @viewmodel_classes_by_name = {}
     @deferred_viewmodel_classes = []
   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/lib/view_model/schemas.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'json'
 require 'json_schema'
 
@@ -9,7 +11,8 @@ class ViewModel::Schemas
 
   ID_SCHEMA =
     { 'oneOf' => [{ 'type' => 'integer' },
-                  { 'type' => 'string', 'format' => 'uuid' }] }
+                  { 'type' => 'string', 'format' => 'uuid' },] }.freeze
+
   ID = JsonSchema.parse!(ID_SCHEMA)
 
   VIEWMODEL_UPDATE_SCHEMA =
@@ -20,8 +23,9 @@ class ViewModel::Schemas
                          ViewModel::ID_ATTRIBUTE      => ID_SCHEMA,
                          ViewModel::NEW_ATTRIBUTE     => { 'type' => 'boolean' },
                          ViewModel::VERSION_ATTRIBUTE => { 'type' => 'integer' } },
-      'required'    => [ViewModel::TYPE_ATTRIBUTE]
-    }
+      'required'    => [ViewModel::TYPE_ATTRIBUTE],
+    }.freeze
+
   VIEWMODEL_UPDATE = JsonSchema.parse!(VIEWMODEL_UPDATE_SCHEMA)
 
   VIEWMODEL_REFERENCE_SCHEMA =
@@ -31,7 +35,8 @@ class ViewModel::Schemas
       'properties'           => { ViewModel::REFERENCE_ATTRIBUTE => { 'type' => 'string' } },
       'additionalProperties' => false,
       'required'             => [ViewModel::REFERENCE_ATTRIBUTE],
-    }
+    }.freeze
+
   VIEWMODEL_REFERENCE = JsonSchema.parse!(VIEWMODEL_REFERENCE_SCHEMA)
 
   def self.verify_schema!(schema, value)

data/lib/view_model/serialization_error.rb

@@ -1,7 +1,10 @@
+# frozen_string_literal: true
+
 class ViewModel::SerializationError < ViewModel::AbstractError
   attr_reader :detail
+
   status 400
-  code "SerializationError"
+  code 'SerializationError'
 
   def initialize(detail)
     @detail = detail

data/lib/view_model/serialize_context.rb

@@ -38,10 +38,10 @@ class ViewModel::SerializeContext < ViewModel::TraversalContext
 
     while references.present?
       extract_referenced_views!.each do |ref, value|
-        unless serialized_refs.has_key?(ref)
-          serialized_refs[ref] = Jbuilder.new do |j|
-            ViewModel.serialize(value, j, serialize_context: reference_context)
-          end
+        next if serialized_refs.has_key?(ref)
+
+        serialized_refs[ref] = Jbuilder.new do |j|
+          ViewModel.serialize(value, j, serialize_context: reference_context)
         end
       end
     end

data/lib/view_model/test_helpers.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 ##
 # Helpers useful for writing tests for viewmodel implementations
 module ViewModel::TestHelpers
@@ -51,11 +53,13 @@ module ViewModel::TestHelpers
 
   def assert_consistent_record(viewmodel, been_there: Set.new)
     return if been_there.include?(viewmodel.model)
+
     been_there << viewmodel.model
 
-    if viewmodel.is_a?(ViewModel::ActiveRecord)
+    case viewmodel
+    when ViewModel::ActiveRecord
       assert_model_represents_database(viewmodel.model, been_there: been_there)
-    elsif viewmodel.is_a?(ViewModel::Record)
+    when ViewModel::Record
       viewmodel.class._members.each do |name, attribute_data|
         if attribute_data.attribute_viewmodel
           assert_consistent_record(viewmodel.send(name), been_there: been_there)
@@ -66,6 +70,7 @@ module ViewModel::TestHelpers
 
   def assert_model_represents_database(model, been_there: Set.new)
     return if been_there.include?(model)
+
     been_there << model
 
     refute(model.new_record?, 'model represents database entity')
@@ -83,7 +88,7 @@ module ViewModel::TestHelpers
       next unless association.loaded?
 
       case
-      when association.target == nil
+      when association.target.nil?
         assert_nil(database_model.association(reflection.name).target,
                    'in memory nil association matches database')
       when reflection.collection?

data/lib/view_model/test_helpers/arvm_builder.rb

@@ -1,10 +1,13 @@
+# frozen_string_literal: true
+
 class ViewModel::TestHelpers::ARVMBuilder
   attr_reader :name, :model, :viewmodel, :namespace
 
   # Building an ARVM requires three blocks, to define schema, model and
   # viewmodel. Support providing these either in an spec argument or as a
   # dsl-style builder.
-  Spec = Struct.new(:schema, :model, :viewmodel) do
+  Spec = Struct.new(:schema, :model, :viewmodel)
+  class Spec
     def initialize(schema:, model:, viewmodel:)
       super(schema, model, viewmodel)
     end
@@ -45,16 +48,16 @@ class ViewModel::TestHelpers::ARVMBuilder
       instance_eval(&block)
     end
 
-    raise "Model not created in ARVMBuilder"     unless model
-    raise "Schema not created in ARVMBuilder"    unless model.table_exists?
-    raise "ViewModel not created in ARVMBuilder" unless (viewmodel || @no_viewmodel)
+    raise 'Model not created in ARVMBuilder'     unless model
+    raise 'Schema not created in ARVMBuilder'    unless model.table_exists?
+    raise 'ViewModel not created in ARVMBuilder' unless viewmodel || @no_viewmodel
 
     # Force the realization of the view model into the library's lookup
     # table. If this doesn't happen the library may have conflicting entries in
     # the deferred table, and will allow viewmodels to leak between tests.
     unless @no_viewmodel || !(@viewmodel < ViewModel::Record)
       resolved = ViewModel::Registry.for_view_name(viewmodel.view_name)
-      raise "Failed to register expected new class!" unless resolved == @viewmodel
+      raise 'Failed to register expected new class!' unless resolved == @viewmodel
     end
   end
 
@@ -69,7 +72,7 @@ class ViewModel::TestHelpers::ARVMBuilder
   private
 
   def viewmodel_name
-    self.name + "View"
+    self.name + 'View'
   end
 
   def define_schema(&block)
@@ -83,10 +86,11 @@ class ViewModel::TestHelpers::ARVMBuilder
 
   def define_model(&block)
     model_name = name
-    _namespace = namespace
-    @model = Class.new(@model_base) do |c|
-      raise "Model already defined: #{model_name}" if _namespace.const_defined?(model_name, false)
-      _namespace.const_set(model_name, self)
+    model_namespace = namespace
+    @model = Class.new(@model_base) do |_c|
+      raise "Model already defined: #{model_name}" if model_namespace.const_defined?(model_name, false)
+
+      model_namespace.const_set(model_name, self)
       class_eval(&block)
       reset_column_information
     end
@@ -95,13 +99,15 @@ class ViewModel::TestHelpers::ARVMBuilder
 
   def define_viewmodel(&block)
     vm_name = viewmodel_name
-    _namespace = namespace
-    @viewmodel = Class.new(@viewmodel_base) do |c|
-      raise "Viewmodel alreay defined: #{vm_name}" if _namespace.const_defined?(vm_name, false)
-      _namespace.const_set(vm_name, self)
+    vm_namespace = namespace
+    @viewmodel = Class.new(@viewmodel_base) do |_c|
+      raise "Viewmodel alreay defined: #{vm_name}" if vm_namespace.const_defined?(vm_name, false)
+
+      vm_namespace.const_set(vm_name, self)
       class_eval(&block)
     end
-    raise "help help" if @viewmodel.name.nil?
+    raise 'help help' if @viewmodel.name.nil?
+
     @viewmodel
   end