jsi-dev 0.0.8 → 0.0.9

data/lib/jsi/validation/result.rb

@@ -3,36 +3,21 @@
 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(
+      Builder = Schema::Cxt.subclass(*%i(
         result
-        schema
         instance_ptr
         instance_document
         validate_only
         visited_refs
-      )]
+      ))
 
       # @private
-      # a structure used to build a Result. virtual base class.
-      class Builder
+      # context to build a Validation::Result
+      class Builder < Schema::Cxt
         def instance
-          instance_ptr.evaluate(instance_document)
-        end
-
-        def schema_issue(*_)
-          virtual_method
-        end
-
-        def schema_error(message, keyword = nil)
-          schema_issue(:error, message, keyword)
-        end
-
-        def schema_warning(message, keyword = nil)
-          schema_issue(:warning, message, keyword)
+          return @instance if instance_variable_defined?(:@instance)
+          @instance = instance_ptr.evaluate(instance_document)
         end
 
         # @param subschema_ptr [JSI::Ptr, #to_ary]
@@ -44,7 +29,6 @@ module JSI
             validate_only: validate_only,
             visited_refs: visited_refs,
           )
-          merge_schema_issues(subresult)
           subresult
         end
 
@@ -57,107 +41,133 @@ module JSI
             instance_document,
             validate_only: validate_only,
           )
-          merge_schema_issues(subresult)
           subresult
         end
 
-        # @param other_result [JSI::Validation::Result]
-        # @return [void]
-        def merge_schema_issues(other_result)
-          unless validate_only
-            # schema_issues are always merged from subschema results (not depending on validation results)
-            result.schema_issues.merge(other_result.schema_issues)
+        # @param results [Enumerable<Validation::Result>]
+        def inplace_results_validate(*a, results: , **kw)
+          results.select(&:valid?).each do |inplace_result|
+            result.evaluated_tokens.merge(inplace_result.evaluated_tokens)
           end
-          nil
+          validate(*a, **kw,
+            results: results,
+          )
         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,
-        )
+        # @param child_results [Hash<Object, Validation::Result>] token => child result
+        def child_results_validate(*a, child_results: , **kw)
+          result.evaluated_tokens.merge(child_results.each_key.select { |t| child_results[t].valid? })
+          validate(*a, **kw,
+            results: child_results.each_value,
+          )
+        end
       end
+    end
+
+    class Result
+      include(Util::Pretty)
 
       # is the instance valid against its schemas?
       # @return [Boolean]
       def valid?
-        # :nocov:
-        virtual_method
-        # :nocov:
+        #chkbug raise(NotImplementedError)
+      end
+
+      # @raise [JSI::Invalid]
+      # @return [nil]
+      def valid!
+        raise(JSI::Invalid, self) if !valid?
+      end
+
+      def pretty_print(q)
+        pretty_print_valid(q)
       end
 
       include Util::FingerprintHash
+
+      private
+
+      def pretty_print_valid(q, &block)
+        jsi_pp_object_group(q, [self.class.name, valid? ? "(VALID)" : "(INVALID)"].freeze, &block)
+      end
     end
 
     # a full result of validating an instance against its schemas, with each validation error
-    class FullResult < Result
+    class Result::Full < Result
       # @private
       class Builder < Result::Builder
         def validate(
             valid,
-            message,
+            message_key,
+            message_default,
             keyword: nil,
-            results: []
+            results: Util::EMPTY_ARY,
+            **additional
         )
-          results.each { |res| result.schema_issues.merge(res.schema_issues) }
           if !valid
-            results.each { |res| result.validation_errors.merge(res.validation_errors) }
-            result.validation_errors << Validation::Error.new({
-              message: message,
+            result.nested_validation_errors << Validation::Error.new({
+              message: JSI.t(message_key, default: message_default, **additional),
               keyword: keyword,
+              additional: additional,
               schema: schema,
               instance_ptr: instance_ptr,
               instance_document: instance_document,
+              nested_errors: results.map(&:nested_validation_errors).inject(Set[], &:merge).freeze,
             })
           end
         end
+      end
+    end
 
-        def schema_issue(level, message, keyword = nil)
-          result.schema_issues << Schema::Issue.new({
-            level: level,
-            message: message,
-            keyword: keyword,
-            schema: schema,
-          })
+    class Result::Full
+      def initialize
+        @nested_validation_errors = Set.new
+        @evaluated_tokens = Set.new
+      end
+
+      # @return [Set<Validation::Error>]
+      attr_reader(:nested_validation_errors)
+
+      # @yield [Validation::Error]
+      def each_validation_error(&block)
+        return(to_enum(__method__)) if !block_given?
+        nested_validation_errors.each do |validation_error|
+          validation_error.each_validation_error(&block)
         end
+        nil
       end
 
-      def initialize
-        @validation_errors = Set.new
-        @schema_issues = Set.new
+      # @deprecated after v0.8
+      # iterating (recursively) is better done with #each_validation_error
+      def validation_errors
+        each_validation_error.to_set
       end
 
-      attr_reader :validation_errors
-      attr_reader :schema_issues
+      # @return [Set]
+      attr_reader(:evaluated_tokens)
 
       def valid?
-        validation_errors.empty?
+        nested_validation_errors.empty?
       end
 
       def freeze
-        @validation_errors.each(&:freeze)
-        @schema_issues.each(&:freeze)
-        @validation_errors.freeze
-        @schema_issues.freeze
+        @nested_validation_errors.freeze
+        @evaluated_tokens.freeze
         super
       end
 
       def merge(result)
-        unless result.is_a?(FullResult)
-          raise(TypeError, "not a #{FullResult.name}: #{result.pretty_inspect.chomp}")
-        end
-        validation_errors.merge(result.validation_errors)
-        schema_issues.merge(result.schema_issues)
+        raise(TypeError, "not a #{Result::Full}: #{result.pretty_inspect.chomp}") unless result.is_a?(Result::Full)
+        nested_validation_errors.merge(result.nested_validation_errors)
+        evaluated_tokens.merge(result.evaluated_tokens)
         self
       end
 
-      def +(result)
-        FullResult.new.merge(self).merge(result)
+      def pretty_print(q)
+        pretty_print_valid(q) do
+          q.text('validation errors: ')
+          q.pp(nested_validation_errors)
+        end
       end
 
       # see {Util::Private::FingerprintHash}
@@ -165,38 +175,46 @@ module JSI
       def jsi_fingerprint
         {
           class: self.class,
-          validation_errors: validation_errors,
-          schema_issues: schema_issues,
-        }
+          nested_validation_errors: nested_validation_errors,
+          evaluated_tokens: evaluated_tokens,
+        }.freeze
       end
     end
 
-    # a result indicating only whether an instance is valid against its schemas
-    class ValidityResult < Result
+    # A result indicating validation success of an instance against a schema
+    class Result::Valid < Result
       # @private
       class Builder < Result::Builder
         def validate(
             valid,
-            message,
+            message_key,
+            message_default,
             keyword: nil,
-            results: []
+            results: Util::EMPTY_ARY,
+            **additional
         )
           if !valid
             throw(:jsi_validation_result, INVALID)
           end
         end
-
-        def schema_issue(*_)
-          # noop
-        end
       end
+    end
 
-      def initialize(valid)
-        @valid = valid
+    class Result::Valid
+      def initialize
+        @evaluated_tokens = Set.new
       end
 
+      # @return [Set]
+      attr_reader(:evaluated_tokens)
+
       def valid?
-        @valid
+        true
+      end
+
+      def freeze
+        @evaluated_tokens.freeze
+        super
       end
 
       # see {Util::Private::FingerprintHash}
@@ -204,8 +222,21 @@ module JSI
       def jsi_fingerprint
         {
           class: self.class,
-          valid: valid?,
-        }
+          evaluated_tokens: evaluated_tokens,
+        }.freeze
+      end
+    end
+
+    # A result indicating validation failure of an instance against a schema
+    class Result::Invalid < Result
+      def valid?
+        false
+      end
+
+      # see {Util::Private::FingerprintHash}
+      # @api private
+      def jsi_fingerprint
+        self.class
       end
     end
   end

data/lib/jsi/validation.rb

@@ -3,13 +3,8 @@
 module JSI
   module Validation
     autoload :Error, 'jsi/validation/error'
-
     autoload :Result, 'jsi/validation/result'
-    autoload :FullResult, 'jsi/validation/result'
-    autoload :ValidityResult, 'jsi/validation/result'
-
-    VALID = ValidityResult.new(true).freeze
 
-    INVALID = ValidityResult.new(false).freeze
+    INVALID = Result::Invalid.new.freeze
   end
 end

data/lib/jsi/version.rb

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

data/lib/jsi.rb

@@ -8,18 +8,61 @@ require "pathname"
 require "bigdecimal"
 require "addressable/uri"
 
-module JSI
+module JSI::Error
   # generally put in code paths that are not expected to be valid control flow paths.
   # rather a NotImplementedCorrectlyError. but that's too long.
   #
   # if you've found this class because JSI has raised this error, please open an issue with the backtrace
   # and any context you can provide at https://github.com/notEthan/jsi/issues
   class Bug < NotImplementedError
+    # implementation note: use `fail` with Bug instead of `raise` to avoid
+    # YARD's ExceptionHandler adding an inferred `@raise` tag for it.
   end
 
   # @private TODO remove, any ruby without this is already long EOL
   FrozenError = Object.const_defined?(:FrozenError) ? ::FrozenError : Class.new(StandardError)
 
+  class BlockGivenError < ArgumentError
+    def initialize(msg = "Block given to a method that does not yield", *)
+      super
+    end
+  end
+
+  # A reference or pointer cannot be resolved
+  class ResolutionError < StandardError
+    # @param msg [String, Array]
+    # @param uri [URI, nil]
+    def initialize(msg = nil, *a, uri: nil)
+      super([*msg].compact.join("\n"), *a)
+      @uri = JSI::Util.uri(uri, nnil: false)
+    end
+
+    # @return [URI, nil]
+    attr_accessor(:uri)
+  end
+
+  # A URI does not meet some requirement where it is used - absent
+  # when it's required, relative when it must be absolute, etc.
+  class URIError < Addressable::URI::InvalidURIError
+  end
+
+  # A schema instance is not valid against schemas that describe it
+  class Invalid < StandardError
+    # @param result [Validation::Result]
+    def initialize(result, *a, &b)
+      @result = result
+      super(result.pretty_inspect.chomp, *a, &b)
+    end
+
+    attr_reader(:result)
+  end
+end
+
+module JSI
+  include(Error)
+  # include(Error) doesn't make its constants available in nested namespaces; fix
+  Error.constants.each { |n| const_set(n, const_get(n)) }
+
   # @private
   ROOT_PATH = Pathname.new(__FILE__).dirname.parent.expand_path
 
@@ -29,77 +72,168 @@ 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 `mutable` param and `to_immutable` configuration 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(:URI, 'jsi/uri')
   autoload :Util, 'jsi/util'
+  autoload(:Set, 'jsi/set')
+  autoload(:Struct, 'jsi/struct')
   autoload :Ptr, 'jsi/ptr'
   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(:Registry, 'jsi/registry')
+  autoload(:SchemaRegistry, 'jsi/registry')
+  autoload(:Ref, 'jsi/ref')
   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(:JSONSchemaDraft202012, 'schemas/json-schema.org/draft/2020-12/schema')
 
   autoload :SimpleWrap, 'jsi/simple_wrap'
 
   # 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}.
   #
-  # @return (see JSI::Schema::DescribesSchema#new_schema_module)
+  # @yield (see Schema::MetaSchema#new_schema_module)
+  # @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
+    schema_jsi = new_schema(schema_content, **kw)
+    schema_jsi.jsi_schema_module_exec(&block) if block
+    schema_jsi.jsi_schema_module
   end
 
-  # Instantiates the given document as a JSI Metaschema.
+  # Instantiates the given metaschema_document as a MetaSchemaNode.
   #
-  # @param metaschema_document an object to be instantiated as a JSI Metaschema
-  # @param schema_implementation_modules (see MetaschemaNode#initialize)
-  # @return [JSI::MetaschemaNode + JSI::DescribesSchema + JSI::Schema]
-  def self.new_metaschema(metaschema_document,
-      schema_implementation_modules:
+  # @api private
+  # @param metaschema_document
+  # @param conf_kw Passed to initialize a {MetaSchemaNode::Conf} for {Base#jsi_conf}.
+  # @return [MetaSchemaNode]
+  def self.new_metaschema_node(metaschema_document,
+      schema_documents: nil,
+      **conf_kw
   )
-    MetaschemaNode.new(metaschema_document,
-      schema_implementation_modules: schema_implementation_modules,
-    )
+    raise(BlockGivenError) if block_given?
+
+    conf = MetaSchemaNode::Conf.new(**conf_kw)
+
+    # need the metaschema_document root to be registered in the bootstrap_registry if...
+    register_bootstrap_metaschema =
+      # the root is a schema
+      conf.root_schema_ref == conf.metaschema_root_ref &&
+      # and the metaschema ref is not fragment-only
+      !conf.metaschema_root_ref.merge(fragment: nil).empty? &&
+      # and it's not already registered (I don't know that an externally supplied bootstrap_registry
+      # would ever need to register the meta-schema differently than this does, but allow for it)
+      (!conf.bootstrap_registry || !conf.bootstrap_registry.registered?(conf.metaschema_root_ref.merge(fragment: nil)))
+
+    if !conf.bootstrap_registry && (register_bootstrap_metaschema || schema_documents)
+      conf = conf.merge(bootstrap_registry: Registry.new)
+    end
+    if !conf.registry && (register_bootstrap_metaschema || schema_documents)
+      conf = conf.merge(registry: Registry.new)
+    end
+
+    metaschema_document = conf.to_immutable.call(metaschema_document) if conf.to_immutable
+    schema_documents = schema_documents.map(&conf.to_immutable) if schema_documents && conf.to_immutable
+
+    to_register = []
+    to_register.concat(schema_documents) if schema_documents
+    to_register.push(metaschema_document) if register_bootstrap_metaschema
+    to_register.each do |document|
+      conf.bootstrap_registry.register_immediate(conf.dialect.bootstrap_schema(
+        jsi_document: document,
+        jsi_registry: conf.bootstrap_registry,
+      ))
+    end
+
+    MetaSchemaNode.new(
+      jsi_document: metaschema_document,
+      jsi_conf: conf,
+    ).jsi_initialize_finish
   end
 
-  # Instantiates the given document as a JSI Metaschema, passing all params to
-  # {new_metaschema}, and returns its {Schema#jsi_schema_module JSI Schema Module}.
+  # `JSI.registry` is the default {JSI::Registry} in which schemas are registered and from
+  # which they resolve references.
   #
-  # @return [Module + JSI::SchemaModule::DescribesSchemaModule + JSI::SchemaModule]
-  def self.new_metaschema_module(metaschema_document, **kw)
-    new_metaschema(metaschema_document, **kw).jsi_schema_module
+  # @return [Registry]
+  def self.registry
+    @registry
   end
 
-  # `JSI.schema_registry` is the default {JSI::SchemaRegistry} in which schemas are registered and from
-  # which they resolve references.
-  #
-  # @return [JSI::SchemaRegistry]
+  # @deprecated after v0.8
   def self.schema_registry
-    @schema_registry
+    @registry
   end
 
-  # @param schema_registry [JSI::SchemaRegistry]
-  def self.schema_registry=(schema_registry)
-    @schema_registry = schema_registry
+  # @param registry [Registry]
+  def self.registry=(registry)
+    @registry = registry
   end
 
-  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 }
+  DEFAULT_REGISTRY = Registry.new.tap do |registry|
+    registry.autoload_uri("http://json-schema.org/draft-04/schema") { JSI::JSONSchemaDraft04.schema }
+    registry.autoload_uri("http://json-schema.org/draft-06/schema") { JSI::JSONSchemaDraft06.schema }
+    registry.autoload_uri("http://json-schema.org/draft-07/schema") { JSI::JSONSchemaDraft07.schema }
+    registry.autoload_uri("https://json-schema.org/draft/2020-12/schema") { JSI::JSONSchemaDraft202012.schema }
+    registry.autoload_uri("https://json-schema.org/draft/2020-12/meta/core")         { JSI::JSONSchemaDraft202012::Core.schema }
+    registry.autoload_uri("https://json-schema.org/draft/2020-12/meta/applicator")    { JSI::JSONSchemaDraft202012::Applicator.schema }
+    registry.autoload_uri("https://json-schema.org/draft/2020-12/meta/unevaluated")    { JSI::JSONSchemaDraft202012::Unevaluated.schema }
+    registry.autoload_uri("https://json-schema.org/draft/2020-12/meta/validation")      { JSI::JSONSchemaDraft202012::Validation.schema }
+    registry.autoload_uri("https://json-schema.org/draft/2020-12/meta/meta-data")        { JSI::JSONSchemaDraft202012::MetaData.schema }
+    registry.autoload_uri("https://json-schema.org/draft/2020-12/meta/format-annotation") { JSI::JSONSchemaDraft202012::FormatAnnotation.schema }
+    registry.autoload_uri("https://json-schema.org/draft/2020-12/meta/content")          { JSI::JSONSchemaDraft202012::Content.schema }
+    registry.autoload_vocabulary_uri("https://json-schema.org/draft/2020-12/vocab/core")            { JSI::Schema::Draft202012::Vocab::CORE }
+    registry.autoload_vocabulary_uri("https://json-schema.org/draft/2020-12/vocab/unevaluated")      { JSI::Schema::Draft202012::Vocab::UNEVALUATED }
+    registry.autoload_vocabulary_uri("https://json-schema.org/draft/2020-12/vocab/format-annotation") { JSI::Schema::Draft202012::Vocab::FORMAT_ANNOTATION }
+    registry.autoload_vocabulary_uri("https://json-schema.org/draft/2020-12/vocab/validation")       { JSI::Schema::Draft202012::Vocab::VALIDATION }
+    registry.autoload_vocabulary_uri("https://json-schema.org/draft/2020-12/vocab/content")         { JSI::Schema::Draft202012::Vocab::CONTENT }
+    registry.autoload_vocabulary_uri("https://json-schema.org/draft/2020-12/vocab/applicator")     { JSI::Schema::Draft202012::Vocab::APPLICATOR }
+    registry.autoload_vocabulary_uri("https://json-schema.org/draft/2020-12/vocab/meta-data")     { JSI::Schema::Draft202012::Vocab::METADATA }
+    registry.autoload_dialect_uri("http://json-schema.org/draft-04/schema") { Schema::Draft04::DIALECT }
+    registry.autoload_dialect_uri("http://json-schema.org/draft-06/schema") { Schema::Draft06::DIALECT }
+    registry.autoload_dialect_uri("http://json-schema.org/draft-07/schema") { Schema::Draft07::DIALECT }
+    registry.autoload_dialect_uri("https://json-schema.org/draft/2020-12/schema") { Schema::Draft202012::DIALECT }
   end.freeze
 
-  self.schema_registry = DEFAULT_SCHEMA_REGISTRY.dup
+  self.registry = DEFAULT_REGISTRY.dup
+
+  # translation
+  # @param key [String]
+  # @param default [String]
+  # @return [String]
+  def self.t(key, default: , **options)
+    translator.call(key, default: default, **options)
+  end
+
+  # @return [#call]
+  def self.translator
+    @translator
+  end
+
+  # e.g. `JSI.translator = I18n.method(:translate)`
+  # @param translator [#call]
+  def self.translator=(translator)
+    @translator = translator
+  end
+
+  DEFAULT_TRANSLATOR = proc { |_key, default: , **_| default }
+  self.translator = DEFAULT_TRANSLATOR
 
   Schema # trigger autoload, ensure JSI methods (new_schema etc) defined in schema.rb load
 end

data/lib/schemas/json-schema.org/draft/2020-12/schema.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module JSI
+  path = SCHEMAS_PATH.join('json-schema.org/draft/2020-12')
+  metaschema_document = Util.json_parse_freeze(path.join('schema.json').read)
+  vocabulary_schema_documents = metaschema_document['allOf'].map do |schema|
+    Util.json_parse_freeze(path.join(schema['$ref'] + '.json').read)
+  end
+
+  JSONSchemaDraft202012 = JSI.new_metaschema_node(metaschema_document,
+    dialect: Schema::Draft202012::DIALECT,
+    metaschema_root_ref: 'https://json-schema.org/draft/2020-12/schema',
+    schema_documents: vocabulary_schema_documents,
+  ).jsi_schema_module
+
+  module JSONSchemaDraft202012
+    # @!parse extend JSI::SchemaModule::MetaSchemaModule
+
+
+    def self.name_vocab_schemas(metaschema_module, namespace: metaschema_module)
+      find_module = proc { |uri| metaschema_module.schema.jsi_registry.find(uri).with_dynamic_scope_from(metaschema_module).jsi_schema_module }
+      namespace.const_set(:Core,       find_module["https://json-schema.org/draft/2020-12/meta/core"])
+      namespace.const_set(:Applicator,  find_module["https://json-schema.org/draft/2020-12/meta/applicator"])
+      namespace.const_set(:Unevaluated,  find_module["https://json-schema.org/draft/2020-12/meta/unevaluated"])
+      namespace.const_set(:Validation,    find_module["https://json-schema.org/draft/2020-12/meta/validation"])
+      namespace.const_set(:MetaData,       find_module["https://json-schema.org/draft/2020-12/meta/meta-data"])
+      namespace.const_set(:FormatAnnotation, find_module["https://json-schema.org/draft/2020-12/meta/format-annotation"])
+      namespace.const_set(:Content,         find_module["https://json-schema.org/draft/2020-12/meta/content"])
+      metaschema_module
+    end
+
+    name_vocab_schemas(self)
+  end
+
+  module JSONSchemaDraft202012::Core
+  end
+  module JSONSchemaDraft202012::Applicator
+  end
+  module JSONSchemaDraft202012::Unevaluated
+  end
+  module JSONSchemaDraft202012::Validation
+  end
+  module JSONSchemaDraft202012::MetaData
+  end
+  module JSONSchemaDraft202012::FormatAnnotation
+  end
+  module JSONSchemaDraft202012::Content
+  end
+
+  module JSONSchemaDraft202012
+    # `$defs` property reader
+    # @return [Base + JSONSchemaDraft202012::Defs, nil]
+    def defs
+      self['$defs']
+    end
+
+    def jsi_schema_module_connection_created(mod)
+      mod.define_singleton_method(:defs) { |**kw| self['$defs', **kw] }
+      super
+    end
+  end
+end