jsi 0.7.0 → 0.8.0

data/lib/jsi/util/typelike.rb

@@ -1,23 +1,20 @@
 # frozen_string_literal: true
 
 module JSI
-  # @deprecated after v0.6
-  module Typelike
-    extend Util
-  end
-
   # a module of methods for objects which behave like Hash but are not Hash.
   #
   # this module is intended to be internal to JSI. no guarantees or API promises
   # are made for non-JSI classes including this module.
   module Util::Hashlike
+    include(Enumerable)
+
     # safe methods which can be delegated to #to_hash (which the includer is assumed to have defined).
     # 'safe' means, in this context, nondestructive - methods which do not modify the receiver.
 
     # methods which do not need to access the value.
-    SAFE_KEY_ONLY_METHODS = %w(each_key empty? has_key? include? key? keys length member? size)
-    SAFE_KEY_VALUE_METHODS = %w(< <= > >= any? assoc compact dig each_pair each_value fetch fetch_values has_value? invert key merge rassoc reject select to_h to_proc transform_values value? values values_at)
-    DESTRUCTIVE_METHODS = %w(clear delete delete_if keep_if reject! replace select! shift)
+    SAFE_KEY_ONLY_METHODS = %w(each_key empty? has_key? include? key? keys length member? size).map(&:freeze).freeze
+    SAFE_KEY_VALUE_METHODS = %w(< <= > >= any? assoc compact dig each_pair each_value fetch fetch_values has_value? invert key merge rassoc reject select to_h to_proc transform_values value? values values_at).map(&:freeze).freeze
+    DESTRUCTIVE_METHODS = %w(clear delete delete_if keep_if reject! replace select! shift).map(&:freeze).freeze
     # these return a modified copy
     safe_modified_copy_methods = %w(compact)
     # select and reject will return a modified copy but need the yielded block variable value from #[]
@@ -73,9 +70,8 @@ module JSI
       unless other.respond_to?(:to_hash)
         raise(TypeError, "cannot update with argument that does not respond to #to_hash: #{other.pretty_inspect.chomp}")
       end
-      self_respondingto_key = respond_to?(:key?) ? self : to_hash
       other.to_hash.each_pair do |key, value|
-        if block && self_respondingto_key.key?(key)
+        if block && key?(key)
           value = yield(key, self[key], value)
         end
         self[key] = value
@@ -92,7 +88,9 @@ module JSI
     # @return duplicate of this hash with the other hash merged in
     # @raise [TypeError] when `other` does not respond to #to_hash
     def merge(other, &block)
-      dup.update(other, &block)
+      jsi_modified_copy do |instance|
+        instance.merge(other.is_a?(Base) ? other.jsi_node_content : other, &block)
+      end
     end
 
     # basically the same #inspect as Hash, but has the class name and, if responsive,
@@ -100,19 +98,20 @@ module JSI
     # @return [String]
     def inspect
       object_group_str = (respond_to?(:jsi_object_group_text, true) ? jsi_object_group_text : [self.class]).join(' ')
-      "\#{<#{object_group_str}>#{map { |k, v| " #{k.inspect} => #{v.inspect}" }.join(',')}}"
+      -"\#{<#{object_group_str}>#{map { |k, v| " #{k.inspect} => #{v.inspect}" }.join(',')}}"
     end
 
-    alias_method :to_s, :inspect
+    def to_s
+      inspect
+    end
 
     # pretty-prints a representation of this hashlike to the given printer
     # @return [void]
     def pretty_print(q)
       object_group_str = (respond_to?(:jsi_object_group_text, true) ? jsi_object_group_text : [self.class]).join(' ')
       q.text "\#{<#{object_group_str}>"
-      q.group_sub {
-        q.nest(2) {
-          q.breakable(empty? ? '' : ' ')
+      q.group(2) {
+          q.breakable ' ' if !empty?
           q.seplist(self, nil, :each_pair) { |k, v|
             q.group {
               q.pp k
@@ -120,9 +119,8 @@ module JSI
               q.pp v
             }
           }
-        }
       }
-      q.breakable ''
+      q.breakable '' if !empty?
       q.text '}'
     end
   end
@@ -132,14 +130,16 @@ module JSI
   # this module is intended to be internal to JSI. no guarantees or API promises
   # are made for non-JSI classes including this module.
   module Util::Arraylike
+    include(Enumerable)
+
     # safe methods which can be delegated to #to_ary (which the includer is assumed to have defined).
     # 'safe' means, in this context, nondestructive - methods which do not modify the receiver.
 
     # methods which do not need to access the element.
-    SAFE_INDEX_ONLY_METHODS = %w(each_index empty? length size)
+    SAFE_INDEX_ONLY_METHODS = %w(each_index empty? length size).map(&:freeze).freeze
     # there are some ambiguous ones that are omitted, like #sort, #map / #collect.
-    SAFE_INDEX_ELEMENT_METHODS = %w(| & * + - <=> abbrev at bsearch bsearch_index combination compact count cycle dig drop drop_while fetch find_index first include? index join last pack permutation product reject repeated_combination repeated_permutation reverse reverse_each rindex rotate sample select shelljoin shuffle slice sort take take_while transpose uniq values_at zip)
-    DESTRUCTIVE_METHODS = %w(<< clear collect! compact! concat delete delete_at delete_if fill flatten! insert keep_if map! pop push reject! replace reverse! rotate! select! shift shuffle! slice! sort! sort_by! uniq! unshift)
+    SAFE_INDEX_ELEMENT_METHODS = %w(| & * + - <=> abbrev at bsearch bsearch_index combination compact count cycle dig drop drop_while fetch find_index first include? index join last pack permutation product reject repeated_combination repeated_permutation reverse reverse_each rindex rotate sample select shelljoin shuffle slice sort take take_while transpose uniq values_at zip).map(&:freeze).freeze
+    DESTRUCTIVE_METHODS = %w(<< clear collect! compact! concat delete delete_at delete_if fill flatten! insert keep_if map! pop push reject! replace reverse! rotate! select! shift shuffle! slice! sort! sort_by! uniq! unshift).map(&:freeze).freeze
 
     # methods (well, method) that returns a modified copy and doesn't need any handling of block variable(s)
     safe_modified_copy_methods = %w(compact)
@@ -204,25 +204,25 @@ module JSI
     # @return [String]
     def inspect
       object_group_str = (respond_to?(:jsi_object_group_text, true) ? jsi_object_group_text : [self.class]).join(' ')
-      "\#[<#{object_group_str}>#{map { |e| ' ' + e.inspect }.join(',')}]"
+      -"\#[<#{object_group_str}>#{map { |e| ' ' + e.inspect }.join(',')}]"
     end
 
-    alias_method :to_s, :inspect
+    def to_s
+      inspect
+    end
 
     # pretty-prints a representation of this arraylike to the given printer
     # @return [void]
     def pretty_print(q)
       object_group_str = (respond_to?(:jsi_object_group_text, true) ? jsi_object_group_text : [self.class]).join(' ')
       q.text "\#[<#{object_group_str}>"
-      q.group_sub {
-        q.nest(2) {
-          q.breakable(empty? ? '' : ' ')
+      q.group(2) {
+          q.breakable ' ' if !empty?
           q.seplist(self, nil, :each) { |e|
             q.pp e
           }
-        }
       }
-      q.breakable ''
+      q.breakable '' if !empty?
       q.text ']'
     end
   end

data/lib/jsi/util.rb

@@ -7,11 +7,13 @@ module JSI
 
     include Private
 
+    extend self
+
     autoload :Arraylike, 'jsi/util/typelike'
     autoload :Hashlike, 'jsi/util/typelike'
 
     # yields the content of the given param `object`. for objects which have a #jsi_modified_copy
-    # method of their own (JSI::Base, JSI::MetaschemaNode) that method is invoked with the given
+    # method of their own (JSI::Base, JSI::MetaSchemaNode) that method is invoked with the given
     # block. otherwise the given object itself is yielded.
     #
     # the given block must result in a modified copy of its block parameter
@@ -24,47 +26,69 @@ module JSI
       if object.respond_to?(:jsi_modified_copy)
         object.jsi_modified_copy(&block)
       else
-        return yield(object)
+        yield(object)
       end
     end
 
-    # recursive method to express the given argument object in json-compatible
-    # types of Hash, Array, and basic types of String/boolean/numeric/nil. this
-    # will raise TypeError if an object is given that is not a type that seems
-    # to be expressable as json.
+    # A structure like the given `object`, recursively coerced to JSON-compatible types.
     #
-    # similar effect could be achieved by requiring 'json/add/core' and using #as_json,
-    # but I don't much care for how it represents classes that are
-    # not naturally expressable in JSON, and prefer not to load its
-    # monkey-patching.
+    # - Structures of Hash, Array, and basic types of String/number/boolean/nil are returned as-is.
+    # - If the object responds to `#as_json`, that method is used, passing any given options.
+    # - If the object supports [implicit conversion](https://docs.ruby-lang.org/en/master/implicit_conversion_rdoc.html)
+    #   with `#to_hash`, `#to_ary`, `#to_str`, or `#to_int`, that is used.
+    # - Set becomes Array; Symbol becomes String.
+    # - Types with no known coersion to JSON-compatible raise TypeError.
     #
-    # @param object [Object] the object to be converted to jsonifiability
-    # @return [Array, Hash, String, Boolean, NilClass, Numeric] jsonifiable
-    #   expression of param object
-    # @raise [TypeError] when the object (or an object nested with a hash or
-    #   array of object) cannot be expressed as json
-    def as_json(object, *opt)
-      if object.is_a?(JSI::Base)
-        as_json(object.jsi_node_content, *opt)
-      elsif object.respond_to?(:to_hash)
-        (object.respond_to?(:map) ? object : object.to_hash).map do |k, v|
-          unless k.is_a?(Symbol) || k.respond_to?(:to_str)
+    # @param object [Object]
+    # @return [Array, Hash, String, Integer, Float, Boolean, NilClass] a JSON-compatible structure like the given `object`
+    # @raise [TypeError] If the object cannot be coerced to a JSON-compatible structure
+    def as_json(object, options = {})
+      type_err = proc { raise(TypeError, "cannot express object as json: #{object.pretty_inspect.chomp}") }
+      if object.respond_to?(:as_json)
+        options.empty? ? object.as_json : object.as_json(**options) # TODO remove eventually (keyword argument compatibility)
+      elsif object.is_a?(Addressable::URI)
+        object.to_s
+      elsif object.respond_to?(:to_hash) && (object_to_hash = object.to_hash).is_a?(Hash)
+        result = {}
+        object_to_hash.each_pair do |k, v|
+          ks = k.is_a?(String) ? k :
+            k.is_a?(Symbol) ? k.to_s :
+            k.respond_to?(:to_str) && (kstr = k.to_str).is_a?(String) ? kstr :
             raise(TypeError, "json object (hash) cannot be keyed with: #{k.pretty_inspect.chomp}")
-          end
-          {k.to_s => as_json(v, *opt)}
-        end.inject({}, &:update)
-      elsif object.respond_to?(:to_ary)
-        (object.respond_to?(:map) ? object : object.to_ary).map { |e| as_json(e, *opt) }
-      elsif [String, TrueClass, FalseClass, NilClass, Numeric].any? { |c| object.is_a?(c) }
+          result[ks] = as_json(v, **options)
+        end
+        result
+      elsif object.respond_to?(:to_ary) && (object_to_ary = object.to_ary).is_a?(Array)
+        object_to_ary.map { |e| as_json(e, **options) }
+      elsif [String, Integer, TrueClass, FalseClass, NilClass].any? { |c| object.is_a?(c) }
+        object
+      elsif object.is_a?(Float)
+        type_err.call unless object.finite?
         object
       elsif object.is_a?(Symbol)
         object.to_s
       elsif object.is_a?(Set)
-        as_json(object.to_a, *opt)
-      elsif object.respond_to?(:as_json)
-        as_json(object.as_json(*opt), *opt)
+        as_json(object.to_a, **options)
+      elsif object.respond_to?(:to_str) && (object_to_str = object.to_str).is_a?(String)
+        object_to_str
+      elsif object.respond_to?(:to_int) && (object_to_int = object.to_int).is_a?(Integer)
+        object_to_int
       else
-        raise(TypeError, "cannot express object as json: #{object.pretty_inspect.chomp}")
+        type_err.call
+      end
+    end
+
+    # A JSON encoded string of the given object.
+    #
+    # - If the object has a `#to_json` method that isn't defined by the stdlib `json` gem,
+    #   that method is used, passing any given options.
+    # - Otherwise, JSON is generated using {as_json} to coerce to compatible types.
+    # @return [String]
+    def to_json(object, options = {})
+      if USE_TO_JSON_METHOD[object.class]
+        options.empty? ? object.to_json : object.to_json(**options) # TODO remove eventually (keyword argument compatibility)
+      else
+        JSON.generate(as_json(object, **options))
       end
     end
 
@@ -96,11 +120,11 @@ module JSI
     end
 
     def deep_stringify_symbol_keys(object)
-      if object.respond_to?(:to_hash)
+      if object.respond_to?(:to_hash) && !object.is_a?(Addressable::URI)
         JSI::Util.modified_copy(object) do |hash|
           out = {}
           (hash.respond_to?(:each) ? hash : hash.to_hash).each do |k, v|
-            out[k.is_a?(Symbol) ? k.to_s : deep_stringify_symbol_keys(k)] = deep_stringify_symbol_keys(v)
+            out[k.is_a?(Symbol) ? k.to_s.freeze : deep_stringify_symbol_keys(k)] = deep_stringify_symbol_keys(v)
           end
           out
         end
@@ -115,9 +139,69 @@ module JSI
       end
     end
 
+    # returns an object which is equal to the param object, and is recursively frozen.
+    # the given object is not modified.
+    def deep_to_frozen(object, not_implemented: nil)
+      dtf = proc { |o| deep_to_frozen(o, not_implemented: not_implemented) }
+      if object.instance_of?(Hash)
+        out = {}
+        identical = object.frozen?
+        object.each do |k, v|
+          fk = dtf[k]
+          fv = dtf[v]
+          identical &&= fk.__id__ == k.__id__
+          identical &&= fv.__id__ == v.__id__
+          out[fk] = fv
+        end
+        if !object.default.nil?
+          out.default = dtf[object.default]
+          identical &&= out.default.__id__ == object.default.__id__
+        end
+        if object.default_proc
+          raise(ArgumentError, "cannot make immutable copy of a Hash with default_proc")
+        end
+        if identical
+          object
+        else
+          out.freeze
+        end
+      elsif object.instance_of?(Array)
+        identical = object.frozen?
+        out = Array.new(object.size)
+        object.each_with_index do |e, i|
+          fe = dtf[e]
+          identical &&= fe.__id__ == e.__id__
+          out[i] = fe
+        end
+        if identical
+          object
+        else
+          out.freeze
+        end
+      elsif object.instance_of?(String)
+        if object.frozen?
+          object
+        else
+          object.dup.freeze
+        end
+      elsif CLASSES_ALWAYS_FROZEN.any? { |c| object.is_a?(c) } # note: `is_a?`, not `instance_of?`, here because instance_of?(Integer) is false until Fixnum/Bignum is gone. this is fine here; there is no concern of subclasses of CLASSES_ALWAYS_FROZEN duping/freezing differently (as with e.g. ActiveSupport::HashWithIndifferentAccess)
+        object
+      else
+        if not_implemented
+          not_implemented.call(object)
+        else
+          raise(NotImplementedError, [
+            "deep_to_frozen not implemented for class: #{object.class}",
+            "object: #{object.pretty_inspect.chomp}",
+          ].join("\n"))
+        end
+      end
+    end
+
     # ensures the given param becomes a frozen Set of Modules.
     # returns the param if it is already that, otherwise initializes and freezes such a Set.
     #
+    # @api private
     # @param modules [Set, Enumerable] the object to ensure becomes a frozen Set of Modules
     # @return [Set] frozen Set containing the given modules
     # @raise [ArgumentError] when the modules param is not an Enumerable
@@ -125,8 +209,10 @@ module JSI
     def ensure_module_set(modules)
       if modules.is_a?(Set) && modules.frozen?
         set = modules
-      else
+      elsif modules.is_a?(Enumerable)
         set = Set.new(modules).freeze
+      else
+        raise(TypeError, "not given an Enumerable of Modules")
       end
       not_modules = set.reject { |s| s.is_a?(Module) }
       if !not_modules.empty?
@@ -138,7 +224,5 @@ module JSI
 
       set
     end
-
-    extend self
   end
 end

data/lib/jsi/validation/error.rb

@@ -29,6 +29,10 @@ module JSI
     #   document containing the instance at instance_ptr
     #   @return [Object]
     class Error
+      def initialize(attributes = {})
+        super
+        freeze
+      end
     end
   end
 end

data/lib/jsi/validation/result.rb

@@ -3,10 +3,7 @@
 module JSI
   module Validation
     # a result of validating an instance against schemas which describe it.
-    # virtual base class.
     class Result
-      include Util::Virtual
-
       Builder = Util::AttrStruct[*%w(
         result
         schema
@@ -24,7 +21,6 @@ module JSI
         end
 
         def schema_issue(*_)
-          virtual_method
         end
 
         def schema_error(message, keyword = nil)
@@ -48,12 +44,12 @@ module JSI
           subresult
         end
 
+        # @param instance_child_token [String, Integer]
         # @param subschema_ptr [JSI::Ptr, #to_ary]
-        # @param subinstance_ptr [JSI::Ptr, #to_ary]
         # @return [JSI::Validation::Result]
-        def child_subschema_validate(subschema_ptr, subinstance_ptr)
+        def child_subschema_validate(instance_child_token, subschema_ptr)
           subresult = schema.subschema(subschema_ptr).internal_validate_instance(
-            instance_ptr + subinstance_ptr,
+            instance_ptr[instance_child_token],
             instance_document,
             validate_only: validate_only,
           )
@@ -71,24 +67,13 @@ module JSI
           nil
         end
       end
+    end
 
-      def builder(schema, instance_ptr, instance_document, validate_only, visited_refs)
-        self.class::Builder.new(
-          result: self,
-          schema: schema,
-          instance_ptr: instance_ptr,
-          instance_document: instance_document,
-          validate_only: validate_only,
-          visited_refs: visited_refs,
-        )
-      end
-
+    class Result
       # is the instance valid against its schemas?
       # @return [Boolean]
       def valid?
-        # :nocov:
-        virtual_method
-        # :nocov:
+        #chkbug raise(NotImplementedError)
       end
 
       include Util::FingerprintHash
@@ -102,7 +87,7 @@ module JSI
             valid,
             message,
             keyword: nil,
-            results: []
+            results: Util::EMPTY_ARY
         )
           results.each { |res| result.schema_issues.merge(res.schema_issues) }
           if !valid
@@ -126,7 +111,9 @@ module JSI
           })
         end
       end
+    end
 
+    class FullResult
       def initialize
         @validation_errors = Set.new
         @schema_issues = Set.new
@@ -140,7 +127,6 @@ module JSI
       end
 
       def freeze
-        @validation_errors.each(&:freeze)
         @schema_issues.each(&:freeze)
         @validation_errors.freeze
         @schema_issues.freeze
@@ -156,17 +142,14 @@ module JSI
         self
       end
 
-      def +(result)
-        FullResult.new.merge(self).merge(result)
-      end
-
-      # @private
+      # see {Util::Private::FingerprintHash}
+      # @api private
       def jsi_fingerprint
         {
           class: self.class,
           validation_errors: validation_errors,
           schema_issues: schema_issues,
-        }
+        }.freeze
       end
     end
 
@@ -178,7 +161,7 @@ module JSI
             valid,
             message,
             keyword: nil,
-            results: []
+            results: Util::EMPTY_ARY
         )
           if !valid
             throw(:jsi_validation_result, INVALID)
@@ -189,7 +172,9 @@ module JSI
           # noop
         end
       end
+    end
 
+    class ValidityResult
       def initialize(valid)
         @valid = valid
       end
@@ -198,12 +183,13 @@ module JSI
         @valid
       end
 
-      # @private
+      # see {Util::Private::FingerprintHash}
+      # @api private
       def jsi_fingerprint
         {
           class: self.class,
           valid: valid?,
-        }
+        }.freeze
       end
     end
   end

data/lib/jsi/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module JSI
-  VERSION = "0.7.0".freeze
+  VERSION = "0.8.0".freeze
 end

data/lib/jsi.rb

@@ -8,8 +8,6 @@ require "pathname"
 require "bigdecimal"
 require "addressable/uri"
 
-require "jsi/util"
-
 module JSI
   # generally put in code paths that are not expected to be valid control flow paths.
   # rather a NotImplementedCorrectlyError. but that's too long.
@@ -19,6 +17,9 @@ module JSI
   class Bug < NotImplementedError
   end
 
+  # @private TODO remove, any ruby without this is already long EOL
+  FrozenError = Object.const_defined?(:FrozenError) ? ::FrozenError : Class.new(StandardError)
+
   # @private
   ROOT_PATH = Pathname.new(__FILE__).dirname.parent.expand_path
 
@@ -28,53 +29,94 @@ module JSI
   # @private
   SCHEMAS_PATH = RESOURCES_PATH.join('schemas')
 
+  DEFAULT_CONTENT_TO_IMMUTABLE = proc do |content|
+    Util.deep_to_frozen(content, not_implemented: proc do |instance|
+      raise(ArgumentError, [
+        "JSI does not know how to make the given instance immutable.",
+        "See new_jsi / new_schema params `mutable` and `to_immutable` documentation for options.",
+        "https://www.rubydoc.info/gems/jsi/#{VERSION}/JSI/SchemaSet#new_jsi-instance_method",
+        "Given instance: #{instance.pretty_inspect.chomp}",
+      ].join("\n"))
+    end)
+  end
+
+  autoload :Util, 'jsi/util'
   autoload :Ptr, 'jsi/ptr'
-  autoload :Typelike, 'jsi/util/typelike'
   autoload :Schema, 'jsi/schema'
   autoload :SchemaSet, 'jsi/schema_set'
   autoload :Base, 'jsi/base'
-  autoload :Metaschema, 'jsi/metaschema'
-  autoload :MetaschemaNode, 'jsi/metaschema_node'
+  autoload(:MetaSchemaNode, 'jsi/metaschema_node')
+  autoload :SchemaModule, 'jsi/schema_classes'
   autoload :SchemaClasses, 'jsi/schema_classes'
   autoload :SchemaRegistry, 'jsi/schema_registry'
   autoload :Validation, 'jsi/validation'
   autoload :JSICoder, 'jsi/jsi_coder'
 
+  autoload :JSONSchemaDraft04, 'schemas/json-schema.org/draft-04/schema'
+  autoload :JSONSchemaDraft06, 'schemas/json-schema.org/draft-06/schema'
+  autoload :JSONSchemaDraft07, 'schemas/json-schema.org/draft-07/schema'
   autoload :JSONSchemaOrgDraft04, 'schemas/json-schema.org/draft-04/schema'
   autoload :JSONSchemaOrgDraft06, 'schemas/json-schema.org/draft-06/schema'
   autoload :JSONSchemaOrgDraft07, 'schemas/json-schema.org/draft-07/schema'
 
   autoload :SimpleWrap, 'jsi/simple_wrap'
 
-  # instantiates a given schema object as a JSI Schema.
+  # Instantiates the given schema content as a JSI Schema, passing all params to
+  # {JSI.new_schema}, and returns its {Schema#jsi_schema_module JSI Schema Module}.
   #
-  # see {JSI::Schema.new_schema}
-  #
-  # @param (see JSI::Schema.new_schema)
-  # @return (see JSI::Schema.new_schema)
-  def self.new_schema(schema_object, **kw)
-    JSI::Schema.new_schema(schema_object, **kw)
+  # @return (see JSI::Schema::MetaSchema#new_schema_module)
+  def self.new_schema_module(schema_content, **kw, &block)
+    new_schema(schema_content, **kw, &block).jsi_schema_module
   end
 
-  # instantiates a given schema object as a JSI Schema and returns its JSI Schema Module.
+  # @private pending dialect/vocabularies
+  # Instantiates the given document as a JSI Meta-Schema.
   #
-  # shortcut to chain {JSI::Schema.new_schema} + {Schema#jsi_schema_module}.
+  # @param metaschema_document an object to be instantiated as a JSI Meta-Schema
+  # @param schema_implementation_modules (see MetaSchemaNode#initialize)
+  # @param to_immutable (see SchemaSet#new_jsi)
+  # @return [JSI::MetaSchemaNode + JSI::Schema::MetaSchema + JSI::Schema]
+  def self.new_metaschema(metaschema_document,
+      schema_implementation_modules: ,
+      to_immutable: DEFAULT_CONTENT_TO_IMMUTABLE
+  )
+    metaschema_document = to_immutable.call(metaschema_document) if to_immutable
+
+    MetaSchemaNode.new(metaschema_document,
+      schema_implementation_modules: schema_implementation_modules,
+      jsi_content_to_immutable: to_immutable,
+    )
+  end
+
+  # @private pending dialect/vocabularies
+  # Instantiates the given document as a JSI Meta-Schema, passing all params to
+  # {new_metaschema}, and returns its {Schema#jsi_schema_module JSI Schema Module}.
   #
-  # @param (see JSI::Schema.new_schema)
-  # @return [Module, JSI::SchemaModule] the JSI Schema Module of the schema
-  def self.new_schema_module(schema_object, **kw)
-    JSI::Schema.new_schema(schema_object, **kw).jsi_schema_module
+  # @return [JSI::SchemaModule + JSI::SchemaModule::MetaSchemaModule]
+  def self.new_metaschema_module(metaschema_document, **kw)
+    new_metaschema(metaschema_document, **kw).jsi_schema_module
   end
 
-  # `JSI.schema_registry` is the {JSI::SchemaRegistry} in which schemas are registered.
+  # `JSI.schema_registry` is the default {JSI::SchemaRegistry} in which schemas are registered and from
+  # which they resolve references.
   #
   # @return [JSI::SchemaRegistry]
   def self.schema_registry
-    return @schema_registry if instance_variable_defined?(:@schema_registry)
-    @schema_registry = SchemaRegistry.new
+    @schema_registry
+  end
+
+  # @param schema_registry [JSI::SchemaRegistry]
+  def self.schema_registry=(schema_registry)
+    @schema_registry = schema_registry
   end
-end
 
-JSI.schema_registry.autoload_uri("http://json-schema.org/draft-04/schema") { JSI::JSONSchemaOrgDraft04.schema }
-JSI.schema_registry.autoload_uri("http://json-schema.org/draft-06/schema") { JSI::JSONSchemaOrgDraft06.schema }
-JSI.schema_registry.autoload_uri("http://json-schema.org/draft-07/schema") { JSI::JSONSchemaOrgDraft07.schema }
+  DEFAULT_SCHEMA_REGISTRY = SchemaRegistry.new.tap do |schema_registry|
+    schema_registry.autoload_uri("http://json-schema.org/draft-04/schema") { JSI::JSONSchemaDraft04.schema }
+    schema_registry.autoload_uri("http://json-schema.org/draft-06/schema") { JSI::JSONSchemaDraft06.schema }
+    schema_registry.autoload_uri("http://json-schema.org/draft-07/schema") { JSI::JSONSchemaDraft07.schema }
+  end.freeze
+
+  self.schema_registry = DEFAULT_SCHEMA_REGISTRY.dup
+
+  Schema # trigger autoload, ensure JSI methods (new_schema etc) defined in schema.rb load
+end