iknow_view_models 2.8.4

data/lib/view_model/record/attribute_data.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+class ViewModel::Record::AttributeData
+  attr_reader :name, :model_attr_name, :attribute_viewmodel, :attribute_serializer
+
+  def initialize(name, model_attr_name, attribute_viewmodel, attribute_serializer, array, optional, read_only, write_once)
+    @name                 = name
+    @model_attr_name      = model_attr_name
+    @attribute_viewmodel  = attribute_viewmodel
+    @attribute_serializer = attribute_serializer
+    @array                = array
+    @optional             = optional
+    @read_only            = read_only
+    @write_once           = write_once
+  end
+
+  def array?
+    @array
+  end
+
+  def optional?
+    @optional
+  end
+
+  def read_only?
+    @read_only
+  end
+
+  def write_once?
+    @write_once
+  end
+
+  def using_serializer?
+    !@attribute_serializer.nil?
+  end
+
+  def using_viewmodel?
+    !@attribute_viewmodel.nil?
+  end
+
+  def map_value(value)
+    if array?
+      value.map { |v| yield(v) }
+    else
+      yield(value)
+    end
+  end
+end

data/lib/view_model/reference.rb

@@ -0,0 +1,31 @@
+class ViewModel
+  # Key to identify a viewmodel with some kind of inherent ID (e.g. an ViewModel::ActiveRecord)
+  class Reference
+    attr_accessor :viewmodel_class, :model_id
+
+    def initialize(viewmodel_class, model_id)
+      @viewmodel_class = viewmodel_class
+      @model_id        = model_id
+    end
+
+    def to_s
+      "'#{viewmodel_class.view_name}(id=#{model_id})'"
+    end
+
+    def inspect
+      "<Ref:#{self}>"
+    end
+
+    def ==(other)
+      other.class             == self.class &&
+        other.viewmodel_class == viewmodel_class &&
+        other.model_id        == model_id
+    end
+
+    alias :eql? :==
+
+    def hash
+      [viewmodel_class, model_id].hash
+    end
+  end
+end

data/lib/view_model/references.rb

@@ -0,0 +1,48 @@
+class ViewModel
+  # A bucket for configuration, used for serializing and deserializing.
+  class References
+    delegate :each, :size, :present?, to: :@value_by_ref
+
+    def initialize
+      @last_ref = 0
+      @ref_by_value = {}
+      @value_by_ref = {}
+    end
+
+    def has_references?
+      @ref_by_value.present?
+    end
+
+    # Takes a reference to a thing that is to be shared, and returns the id
+    # 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 = new_ref!(value)
+        @ref_by_value[value] = ref
+        @value_by_ref[ref] = value
+        ref
+      end
+    end
+
+    def clear!
+      @ref_by_value.clear
+      @value_by_ref.clear
+    end
+
+    private
+
+    # Ensure stable reference ids for the same (persisted) viewmodels.
+    def new_ref!(viewmodel)
+      vm_ref = viewmodel.to_reference
+      if vm_ref.model_id
+        hash = Digest::SHA256.base64digest("#{vm_ref.viewmodel_class.name}.#{vm_ref.model_id}")
+        "ref:h:#{hash}"
+      else
+        'ref:i:%06d' % (@last_ref += 1)
+      end
+    end
+  end
+end

data/lib/view_model/registry.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+class ViewModel::Registry
+  include Singleton
+
+  DEFERRED_NAME = Object.new
+
+  class << self
+    delegate :for_view_name, :register, :default_view_name, :infer_model_class_name, :clear_removed_classes!,
+             to: :instance
+  end
+
+  def initialize
+    @lock = Monitor.new
+    @viewmodel_classes_by_name  = {}
+    @deferred_viewmodel_classes = []
+  end
+
+  def for_view_name(name)
+    raise ViewModel::DeserializationError::InvalidSyntax.new('ViewModel name cannot be nil') if name.nil?
+
+    @lock.synchronize do
+      # Resolve names for any deferred viewmodel classes
+      resolve_deferred_classes
+
+      viewmodel_class = @viewmodel_classes_by_name[name]
+
+      if viewmodel_class.nil? || !(viewmodel_class < ViewModel)
+        raise ViewModel::DeserializationError::UnknownView.new(name)
+      end
+
+      viewmodel_class
+    end
+  end
+
+  def register(viewmodel, as: DEFERRED_NAME)
+    @lock.synchronize do
+      @deferred_viewmodel_classes << [viewmodel, as]
+    end
+  end
+
+  def default_view_name(model_class_name)
+    model_class_name.gsub('::', '.')
+  end
+
+  def infer_model_class_name(view_name)
+    view_name.gsub('.', '::')
+  end
+
+  # For Rails hot code loading: ditch any classes that are not longer present at
+  # their constant
+  def clear_removed_classes!
+    @lock.synchronize do
+      resolve_deferred_classes
+      @viewmodel_classes_by_name.delete_if do |_name, klass|
+        !Kernel.const_defined?(klass.name)
+      end
+    end
+  end
+
+  private
+
+  def resolve_deferred_classes
+    until @deferred_viewmodel_classes.empty?
+      vm, view_name = @deferred_viewmodel_classes.pop
+
+      if vm.should_register?
+        view_name = vm.view_name if view_name == DEFERRED_NAME
+        @viewmodel_classes_by_name[view_name] = vm
+      end
+    end
+  end
+end

data/lib/view_model/schemas.rb

@@ -0,0 +1,45 @@
+require 'json'
+require 'json_schema'
+
+class ViewModel::Schemas
+  JsonSchema.configure do |c|
+    uuid_format = /\A[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}\Z/
+    c.register_format('uuid', ->(value) { uuid_format.match(value) })
+  end
+
+  ID_SCHEMA =
+    { 'oneOf' => [{ 'type' => 'integer' },
+                  { 'type' => 'string', 'format' => 'uuid' }] }
+  ID = JsonSchema.parse!(ID_SCHEMA)
+
+  VIEWMODEL_UPDATE_SCHEMA =
+    {
+      'type'        => 'object',
+      'description' => 'viewmodel update',
+      'properties'  => { ViewModel::TYPE_ATTRIBUTE    => { 'type' => 'string' },
+                         ViewModel::ID_ATTRIBUTE      => ID_SCHEMA,
+                         ViewModel::NEW_ATTRIBUTE     => { 'type' => 'boolean' },
+                         ViewModel::VERSION_ATTRIBUTE => { 'type' => 'integer' } },
+      'required'    => [ViewModel::TYPE_ATTRIBUTE]
+    }
+  VIEWMODEL_UPDATE = JsonSchema.parse!(VIEWMODEL_UPDATE_SCHEMA)
+
+  VIEWMODEL_REFERENCE_SCHEMA =
+    {
+      'type'                 => 'object',
+      'description'          => 'viewmodel shared reference',
+      'properties'           => { ViewModel::REFERENCE_ATTRIBUTE => { 'type' => 'string' } },
+      'additionalProperties' => false,
+      'required'             => [ViewModel::REFERENCE_ATTRIBUTE],
+    }
+  VIEWMODEL_REFERENCE = JsonSchema.parse!(VIEWMODEL_REFERENCE_SCHEMA)
+
+  def self.verify_schema!(schema, value)
+    valid, errors = schema.validate(value)
+    unless valid
+      error_list = errors.map { |e| "#{e.pointer}: #{e.message}" }.join("\n")
+      errors     = 'Error'.pluralize(errors.length)
+      raise ViewModel::DeserializationError::InvalidSyntax.new("#{errors} parsing #{schema.description}:\n#{error_list}")
+    end
+  end
+end

data/lib/view_model/serialization_error.rb

@@ -0,0 +1,10 @@
+class ViewModel::SerializationError < ViewModel::AbstractError
+  attr_reader :detail
+  status 400
+  code "SerializationError"
+
+  def initialize(detail)
+    @detail = detail
+    super()
+  end
+end

data/lib/view_model/serialize_context.rb

@@ -0,0 +1,118 @@
+require 'active_support/core_ext'
+require 'view_model/traversal_context'
+
+class ViewModel::SerializeContext < ViewModel::TraversalContext
+  class SharedContext < ViewModel::TraversalContext::SharedContext
+    attr_reader :references, :flatten_references
+
+    def initialize(flatten_references: false, **rest)
+      super(**rest)
+      @references         = ViewModel::References.new
+      @flatten_references = flatten_references
+    end
+  end
+
+  def self.shared_context_class
+    SharedContext
+  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.
+  def extract_referenced_views!
+    refs = references.each.to_h
+    references.clear!
+    refs
+  end
+
+  def serialize_references(json)
+    reference_context = self.for_references
+
+    # References should be serialized in a stable order to improve caching via
+    # naive response hash.
+
+    serialized_refs = {}
+
+    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
+        end
+      end
+    end
+
+    serialized_refs.sort.each do |ref, value|
+      json.set!(ref, value)
+    end
+  end
+
+  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.rb

@@ -0,0 +1,103 @@
+##
+# Helpers useful for writing tests for viewmodel implementations
+module ViewModel::TestHelpers
+  require 'view_model/test_helpers/arvm_builder'
+  extend ActiveSupport::Concern
+  using ViewModel::Utils::Collections
+
+  def serialize_with_references(serializable, serialize_context: ViewModel.new_serialize_context)
+    data = ViewModel.serialize_to_hash(serializable, serialize_context: serialize_context)
+    references = serialize_context.serialize_references_to_hash
+    return data, references
+  end
+
+  def serialize(serializable, serialize_context: ViewModel.new_serialize_context)
+    data, _ = serialize_with_references(serializable, serialize_context: serialize_context)
+    data
+  end
+
+  # Test helper: update a model by manipulating the full view hash
+  def alter_by_view!(viewmodel_class, model,
+                     serialize_context:   viewmodel_class.new_serialize_context,
+                     deserialize_context: viewmodel_class.new_deserialize_context)
+
+    models = Array.wrap(model)
+
+    data, refs = serialize_with_references(models.map { |m| viewmodel_class.new(m) }, serialize_context: serialize_context)
+
+    if model.is_a?(Array)
+      yield(data, refs)
+    else
+      yield(data.first, refs)
+    end
+
+    begin
+      result = viewmodel_class.deserialize_from_view(
+        data, references: refs, deserialize_context: deserialize_context)
+
+      result.each do |vm|
+        assert_consistent_record(vm)
+      end
+
+      result = result.first unless model.is_a?(Array)
+
+      models.each { |m| m.reload }
+
+      return result, deserialize_context
+    end
+  end
+
+  private
+
+  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)
+      assert_model_represents_database(viewmodel.model, been_there: been_there)
+    elsif viewmodel.is_a?(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)
+        end
+      end
+    end
+  end
+
+  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')
+    refute(model.changed?, 'model is fully persisted')
+
+    database_model = model.class.find(model.id)
+
+    assert_equal(database_model.attributes,
+                 model.attributes,
+                 'in memory attributes match database attributes')
+
+    model.class.reflections.each do |_, reflection|
+      association = model.association(reflection.name)
+
+      next unless association.loaded?
+
+      case
+      when association.target == nil
+        assert_nil(database_model.association(reflection.name).target,
+                   'in memory nil association matches database')
+      when reflection.collection?
+        association.target.each do |associated_model|
+          assert_model_represents_database(associated_model, been_there: been_there)
+        end
+      else
+        assert_model_represents_database(association.target, been_there: been_there)
+      end
+    end
+  end
+
+  def assert_contains_exactly(expected, actual, msg = nil)
+    msg ||= diff(expected, actual)
+    assert(expected.contains_exactly?(actual), msg)
+  end
+end