jsi 0.8.2 → 0.9.0

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.8.2".freeze
+  VERSION = "0.9.0".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
 
@@ -33,14 +76,17 @@ module JSI
     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.",
+        "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'
@@ -48,75 +94,146 @@ module JSI
   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}.
   #
+  # @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
 
-  # @private pending dialect/vocabularies
-  # Instantiates the given document as a JSI Meta-Schema.
+  # Instantiates the given metaschema_document as a MetaSchemaNode.
   #
-  # @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
+  # @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
   )
-    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,
-    )
+    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
 
-  # @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}.
+  # `JSI.registry` is the default {JSI::Registry} in which schemas are registered and from
+  # which they resolve references.
   #
-  # @return [JSI::SchemaModule + JSI::SchemaModule::MetaSchemaModule]
-  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,67 @@
+# 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
+    def jsi_schema_module_connection_created(mod)
+      mod.define_singleton_method(:defs) { |**kw| self['$defs', **kw] }
+      super
+    end
+  end
+
+  module JSONSchemaDraft202012::PropertyReaders
+    def ref(**kw) self['$ref', **kw] end
+    def anchor(**kw) self['$anchor', **kw] end
+    def dynamicRef(**kw) self['$dynamicRef', **kw] end
+    def dynamicAnchor(**kw) self['$dynamicAnchor', **kw] end
+    def comment(**kw) self['$comment', **kw] end
+    def defs(**kw) self['$defs', **kw] end
+    def format(**kw) self['format', **kw] end
+  end
+  JSONSchemaDraft202012.include(JSONSchemaDraft202012::PropertyReaders)
+end

data/lib/schemas/json-schema.org/draft-04/schema.rb

@@ -1,25 +1,26 @@
 # frozen_string_literal: true
 
 module JSI
-  metaschema_document = ::JSON.parse(SCHEMAS_PATH.join('json-schema.org/draft-04/schema.json').read)
-  JSONSchemaDraft04 = JSI.new_metaschema_module(metaschema_document,
-    schema_implementation_modules: [JSI::Schema::Draft04],
-  )
+  metaschema_document = Util.json_parse_freeze(SCHEMAS_PATH.join('json-schema.org/draft-04/schema.json').read)
 
-  # in draft 4, boolean schemas are not described in the root, but on anyOf schemas on
-  # properties/additionalProperties and properties/additionalItems.
-  # these still describe schemas, despite not being described by the meta-schema.
-  also_describe_schemas =
-    JSONSchemaDraft04.schema["properties"]["additionalProperties"]["anyOf"] +
-    JSONSchemaDraft04.schema["properties"]["additionalItems"]["anyOf"]
-  also_describe_schemas.each do |schema|
-    schema.describes_schema!([JSI::Schema::Draft04])
-  end
+  describe_schema_ptrs = Set[
+    Ptr[],
+    # in draft 4, boolean schemas are not described by the main meta-schema (which specifies type: object),
+    # but by anyOf schemas in /properties/additionalProperties and /properties/additionalItems.
+    Ptr['properties', 'additionalProperties', 'anyOf', 0],
+    Ptr['properties', 'additionalItems', 'anyOf', 0]
+  ].freeze
+
+  JSONSchemaDraft04 = JSI.new_metaschema_node(metaschema_document,
+    dialect: JSI::Schema::Draft04::DIALECT,
+    is_metaschema: proc do |node|
+      describe_schema_ptrs.include?(node.jsi_ptr)
+    end,
+  ).jsi_schema_module
 
   # the JSI schema module for `http://json-schema.org/draft-04/schema`
   module JSONSchemaDraft04
     # @!parse extend JSI::SchemaModule::MetaSchemaModule
-    # @!parse include JSI::Schema::Draft04
 
 
     Id        = properties['id']
@@ -62,83 +63,45 @@ module JSI
     SimpleType             = definitions['simpleTypes']
     StringArray           = definitions['stringArray']
 
-    module Id
-    end
-    module Xschema
-    end
-    module Title
-    end
-    module Description
-    end
-    module Default
-    end
-    module MultipleOf
-    end
-    module Maximum
-    end
-    module ExclusiveMaximum
-    end
-    module Minimum
-    end
-    module ExclusiveMinimum
-    end
-    module MaxLength
-    end
-    module MinLength
-    end
-    module Pattern
-    end
-    module AdditionalItems
-    end
-    module Items
-    end
-    module MaxItems
-    end
-    module MinItems
-    end
-    module UniqueItems
-    end
-    module MaxProperties
-    end
-    module MinProperties
-    end
-    module Required
-    end
-    module AdditionalProperties
-    end
-    module Definitions
-    end
-    module Properties
-    end
-    module PatternProperties
-    end
-    module Dependencies
-    end
-    module Enum
-    end
-    module Type
-    end
-    module Format
-    end
-    module AllOf
-    end
-    module AnyOf
-    end
-    module OneOf
-    end
-    module Not
-    end
+    module Id end
+    module Xschema end
+    module Title end
+    module Description end
+    module Default end
+    module MultipleOf end
+    module Maximum end
+    module ExclusiveMaximum end
+    module Minimum end
+    module ExclusiveMinimum end
+    module MaxLength end
+    module MinLength end
+    module Pattern end
+    module AdditionalItems end
+    module Items end
+    module MaxItems end
+    module MinItems end
+    module UniqueItems end
+    module MaxProperties end
+    module MinProperties end
+    module Required end
+    module AdditionalProperties end
+    module Definitions end
+    module Properties end
+    module PatternProperties end
+    module Dependencies end
+    module Enum end
+    module Type end
+    module Format end
+    module AllOf end
+    module AnyOf end
+    module OneOf end
+    module Not end
 
-    module SchemaArray
-    end
-    module PositiveInteger
-    end
-    module PositiveIntegerDefault0
-    end
-    module SimpleType
-    end
-    module StringArray
-    end
+    module SchemaArray end
+    module PositiveInteger end
+    module PositiveIntegerDefault0 end
+    module SimpleType end
+    module StringArray end
 
     AdditionalItems::Boolean = AdditionalItems.anyOf[0]
     AdditionalProperties::Boolean = AdditionalProperties.anyOf[0]
@@ -147,23 +110,17 @@ module JSI
     PositiveIntegerDefault0::Default0 = PositiveIntegerDefault0.allOf[1]
     StringItem = StringArray.items
 
-    module AdditionalItems::Boolean
-    end
-    module AdditionalProperties::Boolean
-    end
-    module Dependencies::Dependency
-    end
-    module Type::Array
-    end
-    module PositiveIntegerDefault0::Default0
-    end
-    module StringItem
-    end
+    module AdditionalItems::Boolean end
+    module AdditionalProperties::Boolean end
+    module Dependencies::Dependency end
+    module Type::Array end
+    module PositiveIntegerDefault0::Default0 end
+    module StringItem end
   end
 
-  JSONSchemaOrgDraft04 = JSONSchemaDraft04
-
-  # @deprecated after v0.7.0, alias of {JSONSchemaDraft04}
-  module JSONSchemaOrgDraft04
+  module JSONSchemaDraft04::PropertyReaders
+    def ref(**kw) self['$ref', **kw] end
+    def format(**kw) self['format', **kw] end
   end
+  JSONSchemaDraft04.include(JSONSchemaDraft04::PropertyReaders)
 end