iknow_view_models 2.8.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: aae4e7d0b4370199361f2f7a44f12f4f8c30156e5b53990323f4bff8a1fc0daf
+  data.tar.gz: 0fb1fd1096212ffdd8b12693d1f411e910509d6e2b21e4d5b1b7208549db90f3
+SHA512:
+  metadata.gz: 1ea33fb802b495ccc0040a1d6ea9652366ee3cd06d88c3e89bba9dec3fa8b960c30aaa7ef183b3b6224b905d4f56c43ae103ff86395f00711c742d38012fdcbd
+  data.tar.gz: 03d0e0aa61d6dca2bd270c803ce817817a80f8a26497ca6efaf6fe2e0a58c471b5d720f3f28081beba09b6798a3def23d13c1e1fff357e7cffb82a0a54ab0c06

data/.circleci/config.yml

@@ -0,0 +1,115 @@
+version: 2.1
+
+executors:
+  ruby-pg:
+    parameters:
+      ruby-version:
+        type: string
+        default: "2.6"
+      pg-version:
+        type: string
+        default: "11"
+      gemfile:
+        type: string
+        default: "Gemfile"
+    environment:
+      PGHOST: 127.0.0.1
+      PGUSER: eikaiwa
+    docker:
+      - image: circleci/ruby:<< parameters.ruby-version >>
+        environment:
+          BUNDLE_JOBS: 3
+          BUNDLE_RETRY: 3
+          BUNDLE_PATH: vendor/bundle
+          RAILS_ENV: test
+          BUNDLE_GEMFILE: << parameters.gemfile >>
+      - image: circleci/postgres:<< parameters.pg-version >>-alpine
+        environment:
+          POSTGRES_USER: eikaiwa
+          POSTGRES_DB: iknow_view_models
+          POSTGRES_PASSWORD: ""
+
+jobs:
+  test:
+    parameters:
+      ex:
+        type: executor
+    executor: << parameters.ex >>
+    parallelism: 1
+    steps:
+      - checkout
+
+      - run:
+          # Remove the non-appraisal gemfile for safety: we never want to use it.
+          name: Prepare bundler
+          command: bundle -v && rm Gemfile
+
+      - run:
+          name: Compute a gemfile lock
+          command: bundle lock && cp "${BUNDLE_GEMFILE}.lock" /tmp/gem-lock
+
+      - restore_cache:
+          keys:
+            - iknow_viewmodels-{{ checksum "/tmp/gem-lock" }}
+            - iknow_viewmodels-
+
+      - run:
+          name: Bundle Install
+          command: bundle check || bundle install
+
+      - save_cache:
+          key: iknow_viewmodels-{{ checksum "/tmp/gem-lock" }}
+          paths:
+            - vendor/bundle
+
+      - run:
+          name: Wait for DB
+          command: dockerize -wait tcp://localhost:5432 -timeout 1m
+
+      - run:
+          name: Run minitest
+          command: bundle exec rake test
+
+      - store_test_results:
+          path: test/reports
+
+  publish:
+    executor: ruby-pg
+    steps:
+       - checkout
+       - run:
+           name: Setup Rubygems
+           command: |
+             mkdir ~/.gem &&
+             echo -e "---\r\n:rubygems_api_key: $RUBYGEMS_API_KEY" > ~/.gem/credentials &&
+             chmod 0600 ~/.gem/credentials
+       - run:
+           name: Publish to Rubygems
+           command: |
+             gem build iknow_view_models.gemspec
+             gem push iknow_view_models-*.gem
+
+workflows:
+  version: 2.1
+  build:
+    jobs:
+      - test:
+          name: 'ruby 2.6 rails 5.2 pg 11'
+          ex:
+            name: ruby-pg
+            ruby-version: "2.6"
+            pg-version: "11"
+            gemfile: gemfiles/rails_5_2.gemfile
+      - test:
+          name: 'ruby 2.6 rails 6.0 pg 11'
+          ex:
+            name: ruby-pg
+            ruby-version: "2.6"
+            pg-version: "11"
+            gemfile: gemfiles/rails_6_0_beta.gemfile
+      - publish:
+          filters:
+            branches:
+              only: master
+            tags:
+              ignore: /.*/

data/.gitignore

@@ -0,0 +1,36 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+.byebug_history
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+*~
+test/config/database.yml
+
+# RubyMine
+.idea/
+
+# Appraisal
+gemfiles/*.lock
+
+# RVM
+.ruby-version
+.ruby-gemset

data/.travis.yml

@@ -0,0 +1,31 @@
+dist: trusty
+sudo: false
+language: ruby
+cache: bundler
+
+rvm:
+  - 2.5
+
+gemfile:
+  - gemfiles/rails_5_2.gemfile
+
+addons:
+  postgresql: "10"
+  apt:
+    packages:
+      - postgresql-10
+      - postgresql-client-10
+      - postgresql-server-dev-10
+env:
+  global:
+    - PGPORT=5433
+
+before_install:
+  - gem update --system
+  - gem install bundler
+
+before_script:
+  - psql -c 'CREATE DATABASE iknow_view_models;'
+
+notifications:
+  email: false

data/Appraisals

@@ -0,0 +1,9 @@
+appraise "rails-5-2" do
+  gem "activerecord", "~> 5.2.0"
+  gem "activesupport", "~> 5.2.0"
+end
+
+appraise "rails-6-0-beta" do
+  gem "activerecord", "~> 6.0.0.beta"
+  gem "activesupport", "~> 6.0.0.beta"
+end

data/Gemfile

@@ -0,0 +1,19 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in cerego_view_models.gemspec
+gemspec
+
+# Test metadata collection for circleci
+gem 'minitest-ci'
+
+# Override gemspec for development version preferences
+gem 'activerecord',  '~> 5.1.0'
+gem 'activesupport', '~> 5.1.0'
+
+# Fetch private dependencies from git
+gem 'acts_as_manual_list',      git: 'https://github.com/iknow/acts_as_manual_list', branch: 'master'
+gem 'deep_preloader',           git: 'https://github.com/iknow/deep_preloader',      branch: 'master'
+gem 'iknow_cache',              git: 'https://github.com/iknow/iknow_cache',         branch: 'master'
+gem 'iknow_params', '~> 2.2.0', git: 'https://github.com/iknow/iknow_params',        branch: 'master'
+gem 'keyword_builder',          git: 'https://github.com/iknow/keyword_builder',     branch: 'master'
+gem 'safe_values',              git: 'https://github.com/iknow/safe_values',         branch: 'master'

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Chris Andreae
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,19 @@
+# IknowViewModels
+
+[![Build Status](https://travis-ci.org/iknow/iknow_view_models.svg?branch=master)](https://travis-ci.org/iknow/iknow_view_models)
+
+ViewModels provide a means of encapsulating a collection of related data and specifying its JSON serialization.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'iknow_view_models'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install iknow_view_models

data/Rakefile

@@ -0,0 +1,21 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.warning = true
+  t.verbose = true
+end
+
+desc "Open an IRB console with the test helpers"
+task :test_console do
+  ruby %{-r bundler/setup -Ilib -e 'load "test/helpers/arvm_test_models.rb"' -r irb -e 'IRB.start(__FILE__)'}
+end
+
+desc "Open a Pry console with the test helpers"
+task 'test_console:pry' do
+  ruby %{-r bundler/setup -Ilib  -e 'load "test/helpers/arvm_test_models.rb"' -r pry -e 'Pry.start'}
+end
+
+task :default => :test

data/appveyor.yml

@@ -0,0 +1,22 @@
+---
+version: "{build}"
+image: ubuntu
+
+stack:
+  - ruby 2.5.0, postgresql
+
+build: off
+
+install:
+  - sudo -u postgres createdb -O appveyor iknow_view_models
+  - sudo apt-get update
+  - sudo apt-get -y install postgresql-server-dev-10
+  - gem install bundler
+  - bundle install
+
+before_test:
+  - ruby -v
+  - bundle -v
+
+test_script:
+  - bundle exec rake

data/gemfiles/rails_5_2.gemfile

@@ -0,0 +1,15 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "minitest-ci"
+gem "activerecord", "~> 5.2.0"
+gem "activesupport", "~> 5.2.0"
+gem "acts_as_manual_list", git: "https://github.com/iknow/acts_as_manual_list", branch: "master"
+gem "deep_preloader", git: "https://github.com/iknow/deep_preloader", branch: "master"
+gem "iknow_cache", git: "https://github.com/iknow/iknow_cache", branch: "master"
+gem "iknow_params", "~> 2.2.0", git: "https://github.com/iknow/iknow_params", branch: "master"
+gem "keyword_builder", git: "https://github.com/iknow/keyword_builder", branch: "master"
+gem "safe_values", git: "https://github.com/iknow/safe_values", branch: "master"
+
+gemspec path: "../"

data/gemfiles/rails_6_0_beta.gemfile

@@ -0,0 +1,15 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "minitest-ci"
+gem "activerecord", "~> 6.0.0.beta"
+gem "activesupport", "~> 6.0.0.beta"
+gem "acts_as_manual_list", git: "https://github.com/iknow/acts_as_manual_list", branch: "master"
+gem "deep_preloader", git: "https://github.com/iknow/deep_preloader", branch: "master"
+gem "iknow_cache", git: "https://github.com/iknow/iknow_cache", branch: "master"
+gem "iknow_params", "~> 2.2.0", git: "https://github.com/iknow/iknow_params", branch: "master"
+gem "keyword_builder", git: "https://github.com/iknow/keyword_builder", branch: "master"
+gem "safe_values", git: "https://github.com/iknow/safe_values", branch: "master"
+
+gemspec path: "../"

data/iknow_view_models.gemspec

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+# coding: utf-8
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'iknow_view_models/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "iknow_view_models"
+  spec.version       = IknowViewModels::VERSION
+  spec.authors       = ["iKnow Team"]
+  spec.email         = ["edge@iknow.jp"]
+  spec.summary       = "ViewModels provide a means of encapsulating a collection of related data and specifying its JSON serialization."
+  spec.description   = ""
+  spec.homepage      = "https://github.com/iknow/cerego_view_models"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "activerecord", ">= 5.0"
+  spec.add_dependency "activesupport", ">= 5.0"
+
+  spec.add_dependency "acts_as_manual_list"
+  spec.add_dependency "deep_preloader"
+  spec.add_dependency "iknow_cache"
+  spec.add_dependency "iknow_params"
+  spec.add_dependency "safe_values"
+  spec.add_dependency "keyword_builder"
+
+  spec.add_dependency "concurrent-ruby"
+  spec.add_dependency "jbuilder"
+  spec.add_dependency "json_schema"
+  spec.add_dependency "lazily"
+  spec.add_dependency "renum"
+
+  spec.add_development_dependency "appraisal"
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "byebug"
+  spec.add_development_dependency "method_source"
+  spec.add_development_dependency "minitest-hooks"
+  spec.add_development_dependency "pg", '~> 0.18' # As of 5.1.4, Rails runtime check excludes pg 1.x, see #31669
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec-expectations"
+  spec.add_development_dependency "sqlite3"
+end

data/lib/iknow_view_models.rb

@@ -0,0 +1,12 @@
+require "iknow_view_models/version"
+require "view_model"
+require "view_model/controller"
+require "view_model/active_record"
+require "view_model/active_record/controller"
+require "view_model/active_record/singular_nested_controller"
+require "view_model/active_record/collection_nested_controller"
+
+module IknowViewModels
+end
+
+require 'iknow_view_models/railtie' if defined?(Rails)

data/lib/iknow_view_models/railtie.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+class IknowViewModels::Railtie < Rails::Railtie
+  # On code reload, clear registered viewmodels that are no longer present.
+  config.to_prepare do
+    ViewModel::Registry.clear_removed_classes!
+  end
+end

data/lib/iknow_view_models/version.rb

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

data/lib/view_model.rb

@@ -0,0 +1,333 @@
+# frozen_string_literal: true
+
+# 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 'deep_preloader'
+
+class ViewModel
+  REFERENCE_ATTRIBUTE = "_ref"
+  ID_ATTRIBUTE        = "id"
+  TYPE_ATTRIBUTE      = "_type"
+  VERSION_ATTRIBUTE   = "_version"
+  NEW_ATTRIBUTE       = "_new"
+
+  Metadata = Struct.new(:id, :view_name, :schema_version, :new) do
+    alias :new? :new
+  end
+
+  class << self
+    attr_accessor :_attributes
+    attr_accessor :schema_version
+    attr_reader   :view_aliases
+
+    def inherited(subclass)
+      subclass.initialize_as_viewmodel
+    end
+
+    def initialize_as_viewmodel
+      @_attributes    = []
+      @schema_version = 1
+      @view_aliases   = []
+    end
+
+    def view_name
+      @view_name ||=
+        begin
+          # try to auto-detect based on class name
+          match = /(.*)View$/.match(self.name)
+          raise ArgumentError.new("Could not auto-determine ViewModel name from class name '#{self.name}'") if match.nil?
+          ViewModel::Registry.default_view_name(match[1])
+        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 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.
+    def attributes(*attrs, **args)
+      attrs.each { |attr| attribute(attr, **args) }
+    end
+
+    def attribute(attr, **_args)
+      unless attr.is_a?(Symbol)
+        raise ArgumentError.new("ViewModel attributes must be symbols")
+      end
+
+      attr_accessor attr
+      define_method("deserialize_#{attr}") do |value, references: {}, deserialize_context: self.class.new_deserialize_context|
+        self.public_send("#{attr}=", value)
+      end
+      _attributes << attr
+    end
+
+    # An abstract viewmodel may want to define attributes to be shared by their
+    # subclasses. Redefine `_attributes` to close over the current class's
+    # _attributes and ignore children.
+    def lock_attribute_inheritance
+      _attributes.tap do |attrs|
+        define_singleton_method(:_attributes) { attrs }
+        attrs.freeze
+      end
+    end
+
+    def member_names
+      _attributes
+    end
+
+    # In deserialization, verify and extract metadata from a provided hash.
+    def extract_viewmodel_metadata(hash)
+      ViewModel::Schemas.verify_schema!(ViewModel::Schemas::VIEWMODEL_UPDATE, hash)
+      id             = hash.delete(ViewModel::ID_ATTRIBUTE)
+      type_name      = hash.delete(ViewModel::TYPE_ATTRIBUTE)
+      schema_version = hash.delete(ViewModel::VERSION_ATTRIBUTE)
+      new            = hash.delete(ViewModel::NEW_ATTRIBUTE) { false }
+
+      Metadata.new(id, type_name, schema_version, new)
+    end
+
+    def extract_reference_only_metadata(hash)
+      ViewModel::Schemas.verify_schema!(ViewModel::Schemas::VIEWMODEL_UPDATE, hash)
+      id             = hash.delete(ViewModel::ID_ATTRIBUTE)
+      type_name      = hash.delete(ViewModel::TYPE_ATTRIBUTE)
+
+      Metadata.new(id, type_name, nil, false)
+    end
+
+    def extract_reference_metadata(hash)
+      ViewModel::Schemas.verify_schema!(ViewModel::Schemas::VIEWMODEL_REFERENCE, hash)
+      hash.delete(ViewModel::REFERENCE_ATTRIBUTE)
+    end
+
+    def is_update_hash?(hash)
+      ViewModel::Schemas.verify_schema!(ViewModel::Schemas::VIEWMODEL_UPDATE, hash)
+      hash.has_key?(ViewModel::ID_ATTRIBUTE) &&
+        !hash.fetch(ViewModel::ActiveRecord::NEW_ATTRIBUTE, false)
+    end
+
+    # 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)
+      {}
+    end
+
+    # ViewModel can serialize ViewModels, Arrays and Hashes of ViewModels, and
+    # relies on Jbuilder#merge! for other values (e.g. primitives).
+    def serialize(target, json, serialize_context: new_serialize_context)
+      case target
+      when ViewModel
+        target.serialize(json, serialize_context: serialize_context)
+      when Array
+        json.array! target do |elt|
+          serialize(elt, json, serialize_context: serialize_context)
+        end
+      when Hash, Struct
+        json.merge!({})
+        target.each_pair do |key, value|
+          json.set! key do
+            serialize(value, json, serialize_context: serialize_context)
+          end
+        end
+      else
+        json.merge! target
+      end
+    end
+
+    def serialize_as_reference(target, json, serialize_context: new_serialize_context)
+      if serialize_context.flatten_references
+        serialize(target, json, serialize_context: serialize_context)
+      else
+        ref = serialize_context.add_reference(target)
+        json.set!(REFERENCE_ATTRIBUTE, ref)
+      end
+    end
+
+    def serialize_to_hash(viewmodel, serialize_context: new_serialize_context)
+      Jbuilder.new { |json| serialize(viewmodel, json, serialize_context: serialize_context) }.attributes!
+    end
+
+    # Rebuild this viewmodel from a serialized hash.
+    def deserialize_from_view(hash_data, references: {}, deserialize_context: new_deserialize_context)
+      viewmodel = self.new
+      deserialize_members_from_view(viewmodel, hash_data, references: references, deserialize_context: deserialize_context)
+      viewmodel
+    end
+
+    def deserialize_members_from_view(viewmodel, view_hash, references:, deserialize_context:)
+      ViewModel::Callbacks.wrap_deserialize(viewmodel, deserialize_context: deserialize_context) do |hook_control|
+        if (bad_attrs = view_hash.keys - member_names).present?
+          causes = bad_attrs.map do |bad_attr|
+            ViewModel::DeserializationError::UnknownAttribute.new(bad_attr, viewmodel.blame_reference)
+          end
+          raise ViewModel::DeserializationError::Collection.for_errors(causes)
+        end
+
+        member_names.each do |attr|
+          if view_hash.has_key?(attr)
+            viewmodel.public_send("deserialize_#{attr}",
+                                  view_hash[attr],
+                                  references: references,
+                                  deserialize_context: deserialize_context)
+          end
+        end
+
+        deserialize_context.run_callback(ViewModel::Callbacks::Hook::BeforeValidate, viewmodel)
+        viewmodel.validate!
+
+        # More complex viewmodels can use this hook to track changes to
+        # persistent backing models, and record the results. Primitive
+        # viewmodels record no changes.
+        if block_given?
+          yield(hook_control)
+        else
+          hook_control.record_changes(Changes.new)
+        end
+      end
+    end
+
+    def serialize_context_class
+      ViewModel::SerializeContext
+    end
+
+    def new_serialize_context(*args)
+      serialize_context_class.new(*args)
+    end
+
+    def deserialize_context_class
+      ViewModel::DeserializeContext
+    end
+
+    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)
+      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),
+                              lock: lock)
+      end
+    end
+  end
+
+  def initialize(*args)
+    self.class._attributes.each_with_index do |attr, idx|
+      self.public_send(:"#{attr}=", args[idx])
+    end
+  end
+
+  # Serialize this viewmodel to a jBuilder by calling serialize_view. May be
+  # overridden in subclasses to (for example) implement caching.
+  def serialize(json, serialize_context: self.class.new_serialize_context)
+    ViewModel::Callbacks.wrap_serialize(self, context: serialize_context) do
+      serialize_view(json, serialize_context: serialize_context)
+    end
+  end
+
+  def to_hash(serialize_context: self.class.new_serialize_context)
+    Jbuilder.new { |json| serialize(json, serialize_context: serialize_context) }.attributes!
+  end
+
+  # Render this viewmodel to a jBuilder. Usually overridden in subclasses.
+  # Default implementation visits each attribute with Viewmodel.serialize.
+  def serialize_view(json, serialize_context: self.class.new_serialize_context)
+    self.class._attributes.each do |attr|
+      json.set! attr do
+        ViewModel.serialize(self.send(attr), json, serialize_context: serialize_context)
+      end
+    end
+  end
+
+  # ViewModels are often used to serialize ActiveRecord models. For convenience,
+  # if necessary we assume that the wrapped model is the first attribute. To
+  # change this, override this method.
+  def model
+    self.public_send(self.class._attributes.first)
+  end
+
+  # Provide a stable way to identify this view through attribute changes. By
+  # default views cannot make assumptions about the identity of our attributes,
+  # so we fall back on the view's `object_id`. If a viewmodel is backed by a
+  # model with a concept of identity, this method should be overridden to use
+  # it.
+  def id
+    object_id
+  end
+
+  # Is this viewmodel backed by a model with a stable identity? Used to decide
+  # whether the id is included when constructing a ViewModel::Reference from
+  # this view.
+  def stable_id?
+    false
+  end
+
+  def validate!; end
+
+  def to_reference
+    ViewModel::Reference.new(self.class, (id if stable_id?))
+  end
+
+  # Delegate view_name to class in most cases. Polymorphic views may wish to
+  # override this to select a specific alias.
+  def view_name
+    self.class.view_name
+  end
+
+  # When deserializing, if an error occurs within this viewmodel, what viewmodel
+  # is reported as to blame. Can be overridden for example when a viewmodel is
+  # merged with its parent.
+  def blame_reference
+    to_reference
+  end
+
+  def context_for_child(member_name, context:)
+    context.for_child(self, association_name: member_name)
+  end
+
+  def preload_for_serialization(lock: nil, serialize_context: self.class.new_serialize_context)
+    ViewModel.preload_for_serialization([self], lock: lock, serialize_context: serialize_context)
+  end
+
+  def ==(other)
+    other.class == self.class && self.class._attributes.all? do |attr|
+      other.send(attr) == self.send(attr)
+    end
+  end
+
+  alias eql? ==
+
+  def hash
+    features = self.class._attributes.map { |attr| self.send(attr) }
+    features << self.class
+    features.hash
+  end
+end
+
+require 'view_model/config'
+require 'view_model/utils'
+require 'view_model/error'
+require 'view_model/callbacks'
+require 'view_model/access_control'
+require 'view_model/deserialization_error'
+require 'view_model/serialization_error'
+require 'view_model/registry'
+require 'view_model/references'
+require 'view_model/reference'
+require 'view_model/serialize_context'
+require 'view_model/deserialize_context'
+require 'view_model/changes'
+require 'view_model/schemas'
+require 'view_model/error_view'