json_schemer 1.0.3 → 2.1.0

data/lib/json_schemer/schema.rb

@@ -0,0 +1,424 @@
+# frozen_string_literal: true
+module JSONSchemer
+  class Schema
+    Context = Struct.new(:instance, :dynamic_scope, :adjacent_results, :short_circuit, :access_mode) do
+      def original_instance(instance_location)
+        Hana::Pointer.parse(Location.resolve(instance_location)).reduce(instance) do |obj, token|
+          obj.fetch(obj.is_a?(Array) ? token.to_i : token)
+        end
+      end
+    end
+
+    include Output
+
+    DEFAULT_SCHEMA = Draft202012::BASE_URI.to_s.freeze
+    SCHEMA_KEYWORD_CLASS = Draft202012::Vocab::Core::Schema
+    VOCABULARY_KEYWORD_CLASS = Draft202012::Vocab::Core::Vocabulary
+    ID_KEYWORD_CLASS = Draft202012::Vocab::Core::Id
+    UNKNOWN_KEYWORD_CLASS = Draft202012::Vocab::Core::UnknownKeyword
+    NOT_KEYWORD_CLASS = Draft202012::Vocab::Applicator::Not
+    PROPERTIES_KEYWORD_CLASS = Draft202012::Vocab::Applicator::Properties
+    DEFAULT_BASE_URI = URI('json-schemer://schema').freeze
+    DEFAULT_FORMATS = {}.freeze
+    DEFAULT_CONTENT_ENCODINGS = {}.freeze
+    DEFAULT_CONTENT_MEDIA_TYPES = {}.freeze
+    DEFAULT_KEYWORDS = {}.freeze
+    DEFAULT_BEFORE_PROPERTY_VALIDATION = [].freeze
+    DEFAULT_AFTER_PROPERTY_VALIDATION = [].freeze
+    DEFAULT_REF_RESOLVER = proc { |uri| raise UnknownRef, uri.to_s }
+    NET_HTTP_REF_RESOLVER = proc { |uri| JSON.parse(Net::HTTP.get(uri)) }
+    RUBY_REGEXP_RESOLVER = proc { |pattern| Regexp.new(pattern) }
+    ECMA_REGEXP_RESOLVER = proc { |pattern| Regexp.new(EcmaRegexp.ruby_equivalent(pattern)) }
+
+    DEFAULT_PROPERTY_DEFAULT_RESOLVER = proc do |instance, property, results_with_tree_validity|
+      results_with_tree_validity = results_with_tree_validity.select(&:last) unless results_with_tree_validity.size == 1
+      annotations = results_with_tree_validity.to_set { |result, _tree_valid| result.annotation }
+      if annotations.size == 1
+        instance[property] = annotations.first.clone
+        true
+      else
+        false
+      end
+    end
+
+    attr_accessor :base_uri, :meta_schema, :keywords, :keyword_order
+    attr_reader :value, :parent, :root, :parsed
+    attr_reader :vocabulary, :format, :formats, :content_encodings, :content_media_types, :custom_keywords, :before_property_validation, :after_property_validation, :insert_property_defaults, :property_default_resolver
+
+    def initialize(
+      value,
+      parent = nil,
+      root = self,
+      keyword = nil,
+      base_uri: DEFAULT_BASE_URI,
+      meta_schema: nil,
+      vocabulary: nil,
+      format: true,
+      formats: DEFAULT_FORMATS,
+      content_encodings: DEFAULT_CONTENT_ENCODINGS,
+      content_media_types: DEFAULT_CONTENT_MEDIA_TYPES,
+      keywords: DEFAULT_KEYWORDS,
+      before_property_validation: DEFAULT_BEFORE_PROPERTY_VALIDATION,
+      after_property_validation: DEFAULT_AFTER_PROPERTY_VALIDATION,
+      insert_property_defaults: false,
+      property_default_resolver: DEFAULT_PROPERTY_DEFAULT_RESOLVER,
+      ref_resolver: DEFAULT_REF_RESOLVER,
+      regexp_resolver: 'ruby',
+      output_format: 'classic',
+      resolve_enumerators: false,
+      access_mode: nil
+    )
+      @value = deep_stringify_keys(value)
+      @parent = parent
+      @root = root
+      @keyword = keyword
+      @schema = self
+      @base_uri = base_uri
+      @meta_schema = meta_schema
+      @vocabulary = vocabulary
+      @format = format
+      @formats = formats
+      @content_encodings = content_encodings
+      @content_media_types = content_media_types
+      @custom_keywords = keywords
+      @before_property_validation = Array(before_property_validation)
+      @after_property_validation = Array(after_property_validation)
+      @insert_property_defaults = insert_property_defaults
+      @property_default_resolver = property_default_resolver
+      @original_ref_resolver = ref_resolver
+      @original_regexp_resolver = regexp_resolver
+      @output_format = output_format
+      @resolve_enumerators = resolve_enumerators
+      @access_mode = access_mode
+      @parsed = parse
+    end
+
+    def valid?(instance, **options)
+      validate(instance, :output_format => 'flag', **options).fetch('valid')
+    end
+
+    def validate(instance, output_format: @output_format, resolve_enumerators: @resolve_enumerators, access_mode: @access_mode)
+      instance_location = Location.root
+      context = Context.new(instance, [], nil, (!insert_property_defaults && output_format == 'flag'), access_mode)
+      result = validate_instance(deep_stringify_keys(instance), instance_location, root_keyword_location, context)
+      if insert_property_defaults && result.insert_property_defaults(context, &property_default_resolver)
+        result = validate_instance(deep_stringify_keys(instance), instance_location, root_keyword_location, context)
+      end
+      output = result.output(output_format)
+      resolve_enumerators!(output) if resolve_enumerators
+      output
+    end
+
+    def valid_schema?
+      meta_schema.valid?(value)
+    end
+
+    def validate_schema
+      meta_schema.validate(value)
+    end
+
+    def ref(value)
+      root.resolve_ref(URI.join(base_uri, value))
+    end
+
+    def validate_instance(instance, instance_location, keyword_location, context)
+      context.dynamic_scope.push(self)
+      original_adjacent_results = context.adjacent_results
+      adjacent_results = context.adjacent_results = {}
+      short_circuit = context.short_circuit
+
+      begin
+        return result(instance, instance_location, keyword_location, false) if value == false
+        return result(instance, instance_location, keyword_location, true) if value == true || value.empty?
+
+        valid = true
+        nested = []
+
+        parsed.each do |keyword, keyword_instance|
+          next unless keyword_result = keyword_instance.validate(instance, instance_location, join_location(keyword_location, keyword), context)
+          valid &&= keyword_result.valid
+          return result(instance, instance_location, keyword_location, false) if short_circuit && !valid
+          nested << keyword_result
+          adjacent_results[keyword_instance.class] = keyword_result
+        end
+
+        if custom_keywords.any?
+          custom_keywords.each do |custom_keyword, callable|
+            if value.key?(custom_keyword)
+              [*callable.call(instance, value, instance_location)].each do |custom_keyword_result|
+                custom_keyword_valid = custom_keyword_result == true
+                valid &&= custom_keyword_valid
+                type = custom_keyword_result.is_a?(String) ? custom_keyword_result : custom_keyword
+                details = { 'keyword' => custom_keyword, 'result' => custom_keyword_result }
+                nested << result(instance, instance_location, keyword_location, custom_keyword_valid, :type => type, :details => details)
+              end
+            end
+          end
+        end
+
+        result(instance, instance_location, keyword_location, valid, nested)
+      ensure
+        context.dynamic_scope.pop
+        context.adjacent_results = original_adjacent_results
+      end
+    end
+
+    def resolve_ref(uri)
+      pointer = ''
+      if Format.valid_json_pointer?(uri.fragment)
+        pointer = URI.decode_www_form_component(uri.fragment)
+        uri.fragment = nil
+      end
+
+      lexical_resources = resources.fetch(:lexical)
+      schema = lexical_resources[uri]
+
+      if !schema && uri.fragment.nil?
+        empty_fragment_uri = uri.dup
+        empty_fragment_uri.fragment = ''
+        schema = lexical_resources[empty_fragment_uri]
+      end
+
+      unless schema
+        location_independent_identifier = uri.fragment
+        uri.fragment = nil
+        remote_schema = JSONSchemer.schema(
+          ref_resolver.call(uri) || raise(InvalidRefResolution, uri.to_s),
+          :base_uri => uri,
+          :meta_schema => meta_schema,
+          :format => format,
+          :formats => formats,
+          :content_encodings => content_encodings,
+          :content_media_types => content_media_types,
+          :keywords => custom_keywords,
+          :before_property_validation => before_property_validation,
+          :after_property_validation => after_property_validation,
+          :property_default_resolver => property_default_resolver,
+          :ref_resolver => ref_resolver,
+          :regexp_resolver => regexp_resolver
+        )
+        remote_uri = remote_schema.base_uri.dup
+        remote_uri.fragment = location_independent_identifier if location_independent_identifier
+        schema = remote_schema.resources.fetch(:lexical).fetch(remote_uri)
+      end
+
+      schema = Hana::Pointer.parse(pointer).reduce(schema) do |obj, token|
+        if obj.is_a?(UNKNOWN_KEYWORD_CLASS)
+          obj.fetch_unknown!(token)
+        elsif obj.parsed.is_a?(Array)
+          obj.parsed.fetch(token.to_i)
+        else
+          obj.parsed.fetch(token)
+        end
+      rescue IndexError
+        raise InvalidRefPointer, pointer
+      end
+
+      schema = schema.unknown_schema! unless schema.is_a?(Schema)
+
+      schema
+    end
+
+    def resolve_regexp(pattern)
+      regexp_resolver.call(pattern) || raise(InvalidRegexpResolution, pattern)
+    end
+
+    def bundle
+      return value unless value.is_a?(Hash)
+
+      id_keyword = meta_schema.id_keyword
+      defs_keyword = meta_schema.defs_keyword
+
+      compound_document = value.dup
+      compound_document[id_keyword] = base_uri.to_s
+      compound_document['$schema'] = meta_schema.base_uri.to_s
+      embedded_resources = compound_document[defs_keyword] = (compound_document[defs_keyword]&.dup || {})
+
+      if compound_document.key?('$ref') && meta_schema.keywords.fetch('$ref').exclusive?
+        compound_document['allOf'] = (compound_document['allOf']&.dup || [])
+        compound_document['allOf'] << { '$ref' => compound_document.delete('$ref') }
+      end
+
+      values = [self]
+      while value = values.shift
+        case value
+        when Schema
+          values << value.parsed
+        when Keyword
+          if value.respond_to?(:ref_uri) && value.respond_to?(:ref_schema)
+            ref_uri = value.ref_uri.dup
+            ref_uri.fragment = nil
+            ref_id = ref_uri.to_s
+            ref_schema = value.ref_schema.root
+
+            next if ref_schema == root || embedded_resources.key?(ref_id)
+
+            embedded_resource = ref_schema.value.dup
+            embedded_resource[id_keyword] = ref_id
+            embedded_resource['$schema'] = ref_schema.meta_schema.base_uri.to_s
+            embedded_resources[ref_id] = embedded_resource
+
+            values << ref_schema
+          else
+            values << value.parsed
+          end
+        when Hash
+          values.concat(value.values)
+        when Array
+          values.concat(value)
+        end
+      end
+
+      compound_document
+    end
+
+    def absolute_keyword_location
+      # using `equal?` because `URI::Generic#==` is slow
+      @absolute_keyword_location ||= if !parent || (!parent.schema.base_uri.equal?(base_uri) && (base_uri.fragment.nil? || base_uri.fragment.empty?))
+        absolute_keyword_location_uri = base_uri.dup
+        absolute_keyword_location_uri.fragment = ''
+        absolute_keyword_location_uri.to_s
+      elsif keyword
+        "#{parent.absolute_keyword_location}/#{fragment_encode(escaped_keyword)}"
+      else
+        parent.absolute_keyword_location
+      end
+    end
+
+    def schema_pointer
+      @schema_pointer ||= if !parent
+        ''
+      elsif keyword
+        "#{parent.schema_pointer}/#{escaped_keyword}"
+      else
+        parent.schema_pointer
+      end
+    end
+
+    def error_key
+      '^'
+    end
+
+    def fetch_format(format, *args, &block)
+      if meta_schema == self
+        formats.fetch(format, *args, &block)
+      else
+        formats.fetch(format) { meta_schema.fetch_format(format, *args, &block) }
+      end
+    end
+
+    def fetch_content_encoding(content_encoding, *args, &block)
+      if meta_schema == self
+        content_encodings.fetch(content_encoding, *args, &block)
+      else
+        content_encodings.fetch(content_encoding) { meta_schema.fetch_content_encoding(content_encoding, *args, &block) }
+      end
+    end
+
+    def fetch_content_media_type(content_media_type, *args, &block)
+      if meta_schema == self
+        content_media_types.fetch(content_media_type, *args, &block)
+      else
+        content_media_types.fetch(content_media_type) { meta_schema.fetch_content_media_type(content_media_type, *args, &block) }
+      end
+    end
+
+    def id_keyword
+      @id_keyword ||= (keywords.key?('$id') ? '$id' : 'id')
+    end
+
+    def defs_keyword
+      @defs_keyword ||= (keywords.key?('$defs') ? '$defs' : 'definitions')
+    end
+
+    def resources
+      @resources ||= { :lexical => {}, :dynamic => {} }
+    end
+
+    def error(formatted_instance_location:, **options)
+      if value == false && parent&.respond_to?(:false_schema_error)
+        parent.false_schema_error(:formatted_instance_location => formatted_instance_location, **options)
+      else
+        "value at #{formatted_instance_location} does not match schema"
+      end
+    end
+
+    def inspect
+      "#<#{self.class.name} @value=#{@value.inspect} @parent=#{@parent.inspect} @keyword=#{@keyword.inspect}>"
+    end
+
+  private
+
+    def parse
+      @parsed = {}
+
+      if value.is_a?(Hash) && value.key?('$schema')
+        @parsed['$schema'] = SCHEMA_KEYWORD_CLASS.new(value.fetch('$schema'), self, '$schema')
+      elsif root == self && !meta_schema
+        SCHEMA_KEYWORD_CLASS.new(DEFAULT_SCHEMA, self, '$schema')
+      end
+
+      if value.is_a?(Hash) && value.key?('$vocabulary')
+        @parsed['$vocabulary'] = VOCABULARY_KEYWORD_CLASS.new(value.fetch('$vocabulary'), self, '$vocabulary')
+      elsif vocabulary
+        VOCABULARY_KEYWORD_CLASS.new(vocabulary, self, '$vocabulary')
+      end
+
+      keywords = meta_schema.keywords
+      exclusive_ref = value.is_a?(Hash) && value.key?('$ref') && keywords.fetch('$ref').exclusive?
+
+      if root == self && (!value.is_a?(Hash) || !value.key?(meta_schema.id_keyword) || exclusive_ref)
+        ID_KEYWORD_CLASS.new(base_uri, self, meta_schema.id_keyword)
+      end
+
+      if exclusive_ref
+        @parsed['$ref'] = keywords.fetch('$ref').new(value.fetch('$ref'), self, '$ref')
+        defs_keyword = meta_schema.defs_keyword
+        if value.key?(defs_keyword) && keywords.key?(defs_keyword)
+          @parsed[defs_keyword] = keywords.fetch(defs_keyword).new(value.fetch(defs_keyword), self, defs_keyword)
+        end
+      elsif value.is_a?(Hash)
+        keyword_order = meta_schema.keyword_order
+        last = keywords.size
+
+        value.sort do |(keyword_a, _value_a), (keyword_b, _value_b)|
+          keyword_order.fetch(keyword_a, last) <=> keyword_order.fetch(keyword_b, last)
+        end.each do |keyword, value|
+          @parsed[keyword] ||= keywords.fetch(keyword, UNKNOWN_KEYWORD_CLASS).new(value, self, keyword)
+        end
+      end
+
+      @parsed
+    end
+
+    def root_keyword_location
+      @root_keyword_location ||= Location.root
+    end
+
+    def ref_resolver
+      @ref_resolver ||= @original_ref_resolver == 'net/http' ? CachedResolver.new(&NET_HTTP_REF_RESOLVER) : @original_ref_resolver
+    end
+
+    def regexp_resolver
+      @regexp_resolver ||= case @original_regexp_resolver
+      when 'ecma'
+        CachedResolver.new(&ECMA_REGEXP_RESOLVER)
+      when 'ruby'
+        CachedResolver.new(&RUBY_REGEXP_RESOLVER)
+      else
+        @original_regexp_resolver
+      end
+    end
+
+    def resolve_enumerators!(output)
+      case output
+      when Hash
+        output.transform_values! { |value| resolve_enumerators!(value) }
+      when Enumerator
+        output.map { |value| resolve_enumerators!(value) }
+      else
+        output
+      end
+    end
+  end
+end

data/lib/json_schemer/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module JSONSchemer
-  VERSION = '1.0.3'
+  VERSION = '2.1.0'
 end

data/lib/json_schemer.rb

@@ -14,35 +14,93 @@ require 'regexp_parser'
 require 'simpleidn'
 
 require 'json_schemer/version'
+require 'json_schemer/format/duration'
 require 'json_schemer/format/hostname'
+require 'json_schemer/format/json_pointer'
 require 'json_schemer/format/uri_template'
 require 'json_schemer/format/email'
 require 'json_schemer/format'
+require 'json_schemer/content'
 require 'json_schemer/errors'
 require 'json_schemer/cached_resolver'
 require 'json_schemer/ecma_regexp'
-require 'json_schemer/schema/base'
-require 'json_schemer/schema/draft4'
-require 'json_schemer/schema/draft6'
-require 'json_schemer/schema/draft7'
+require 'json_schemer/location'
+require 'json_schemer/result'
+require 'json_schemer/output'
+require 'json_schemer/keyword'
+require 'json_schemer/draft202012/meta'
+require 'json_schemer/draft202012/vocab/core'
+require 'json_schemer/draft202012/vocab/applicator'
+require 'json_schemer/draft202012/vocab/unevaluated'
+require 'json_schemer/draft202012/vocab/validation'
+require 'json_schemer/draft202012/vocab/format_annotation'
+require 'json_schemer/draft202012/vocab/format_assertion'
+require 'json_schemer/draft202012/vocab/content'
+require 'json_schemer/draft202012/vocab/meta_data'
+require 'json_schemer/draft202012/vocab'
+require 'json_schemer/draft201909/meta'
+require 'json_schemer/draft201909/vocab/core'
+require 'json_schemer/draft201909/vocab/applicator'
+require 'json_schemer/draft201909/vocab'
+require 'json_schemer/draft7/meta'
+require 'json_schemer/draft7/vocab/validation'
+require 'json_schemer/draft7/vocab'
+require 'json_schemer/draft6/meta'
+require 'json_schemer/draft6/vocab'
+require 'json_schemer/draft4/meta'
+require 'json_schemer/draft4/vocab/validation'
+require 'json_schemer/draft4/vocab'
+require 'json_schemer/openapi31/meta'
+require 'json_schemer/openapi31/vocab/base'
+require 'json_schemer/openapi31/vocab'
+require 'json_schemer/openapi31/document'
+require 'json_schemer/openapi30/document'
+require 'json_schemer/openapi30/meta'
+require 'json_schemer/openapi30/vocab/base'
+require 'json_schemer/openapi30/vocab'
+require 'json_schemer/openapi'
+require 'json_schemer/schema'
 
 module JSONSchemer
   class UnsupportedMetaSchema < StandardError; end
+  class UnsupportedOpenAPIVersion < StandardError; end
   class UnknownRef < StandardError; end
   class UnknownFormat < StandardError; end
+  class UnknownVocabulary < StandardError; end
+  class UnknownContentEncoding < StandardError; end
+  class UnknownContentMediaType < StandardError; end
+  class UnknownOutputFormat < StandardError; end
   class InvalidRefResolution < StandardError; end
+  class InvalidRefPointer < StandardError; end
   class InvalidRegexpResolution < StandardError; end
   class InvalidFileURI < StandardError; end
-  class InvalidSymbolKey < StandardError; end
   class InvalidEcmaRegexp < StandardError; end
 
-  DEFAULT_SCHEMA_CLASS = Schema::Draft7
-  SCHEMA_CLASS_BY_META_SCHEMA = {
-    'http://json-schema.org/schema#' => Schema::Draft4, # Version-less $schema deprecated after Draft 4
-    'http://json-schema.org/draft-04/schema#' => Schema::Draft4,
-    'http://json-schema.org/draft-06/schema#' => Schema::Draft6,
-    'http://json-schema.org/draft-07/schema#' => Schema::Draft7
-  }.freeze
+  VOCABULARIES = {
+    'https://json-schema.org/draft/2020-12/vocab/core' => Draft202012::Vocab::CORE,
+    'https://json-schema.org/draft/2020-12/vocab/applicator' => Draft202012::Vocab::APPLICATOR,
+    'https://json-schema.org/draft/2020-12/vocab/unevaluated' => Draft202012::Vocab::UNEVALUATED,
+    'https://json-schema.org/draft/2020-12/vocab/validation' => Draft202012::Vocab::VALIDATION,
+    'https://json-schema.org/draft/2020-12/vocab/format-annotation' => Draft202012::Vocab::FORMAT_ANNOTATION,
+    'https://json-schema.org/draft/2020-12/vocab/format-assertion' => Draft202012::Vocab::FORMAT_ASSERTION,
+    'https://json-schema.org/draft/2020-12/vocab/content' => Draft202012::Vocab::CONTENT,
+    'https://json-schema.org/draft/2020-12/vocab/meta-data' => Draft202012::Vocab::META_DATA,
+
+    'https://json-schema.org/draft/2019-09/vocab/core' => Draft201909::Vocab::CORE,
+    'https://json-schema.org/draft/2019-09/vocab/applicator' => Draft201909::Vocab::APPLICATOR,
+    'https://json-schema.org/draft/2019-09/vocab/validation' => Draft201909::Vocab::VALIDATION,
+    'https://json-schema.org/draft/2019-09/vocab/format' => Draft201909::Vocab::FORMAT,
+    'https://json-schema.org/draft/2019-09/vocab/content' => Draft201909::Vocab::CONTENT,
+    'https://json-schema.org/draft/2019-09/vocab/meta-data' => Draft201909::Vocab::META_DATA,
+
+    'json-schemer://draft7' => Draft7::Vocab::ALL,
+    'json-schemer://draft6' => Draft6::Vocab::ALL,
+    'json-schemer://draft4' => Draft4::Vocab::ALL,
+
+    'https://spec.openapis.org/oas/3.1/vocab/base' => OpenAPI31::Vocab::BASE,
+    'json-schemer://openapi30' => OpenAPI30::Vocab::BASE
+  }
+  VOCABULARY_ORDER = VOCABULARIES.transform_values.with_index { |_vocabulary, index| index }
 
   WINDOWS_URI_PATH_REGEX = /\A\/[a-z]:/i
 
@@ -55,7 +113,7 @@ module JSONSchemer
   end
 
   class << self
-    def schema(schema, default_schema_class: DEFAULT_SCHEMA_CLASS, **options)
+    def schema(schema, meta_schema: draft202012, **options)
       case schema
       when String
         schema = JSON.parse(schema)
@@ -70,23 +128,139 @@ module JSONSchemer
           ref_resolver.call(base_uri)
         end
       end
-
-      schema_class = if schema.is_a?(Hash) && schema.key?('$schema')
-        meta_schema = schema.fetch('$schema')
-        SCHEMA_CLASS_BY_META_SCHEMA[meta_schema] || raise(UnsupportedMetaSchema, meta_schema)
-      else
-        default_schema_class
+      unless meta_schema.is_a?(Schema)
+        meta_schema = META_SCHEMAS_BY_BASE_URI_STR[meta_schema] || raise(UnsupportedMetaSchema, meta_schema)
       end
+      Schema.new(schema, :meta_schema => meta_schema, **options)
+    end
+
+    def valid_schema?(schema, **options)
+      schema(schema, **options).valid_schema?
+    end
+
+    def validate_schema(schema, **options)
+      schema(schema, **options).validate_schema
+    end
+
+    def draft202012
+      @draft202012 ||= Schema.new(
+        Draft202012::SCHEMA,
+        :base_uri => Draft202012::BASE_URI,
+        :formats => Draft202012::FORMATS,
+        :content_encodings => Draft202012::CONTENT_ENCODINGS,
+        :content_media_types => Draft202012::CONTENT_MEDIA_TYPES,
+        :ref_resolver => Draft202012::Meta::SCHEMAS.to_proc,
+        :regexp_resolver => 'ecma'
+      )
+    end
+
+    def draft201909
+      @draft201909 ||= Schema.new(
+        Draft201909::SCHEMA,
+        :base_uri => Draft201909::BASE_URI,
+        :formats => Draft201909::FORMATS,
+        :content_encodings => Draft201909::CONTENT_ENCODINGS,
+        :content_media_types => Draft201909::CONTENT_MEDIA_TYPES,
+        :ref_resolver => Draft201909::Meta::SCHEMAS.to_proc,
+        :regexp_resolver => 'ecma'
+      )
+    end
 
-      schema_class.new(schema, **options)
+    def draft7
+      @draft7 ||= Schema.new(
+        Draft7::SCHEMA,
+        :vocabulary => { 'json-schemer://draft7' => true },
+        :base_uri => Draft7::BASE_URI,
+        :formats => Draft7::FORMATS,
+        :content_encodings => Draft7::CONTENT_ENCODINGS,
+        :content_media_types => Draft7::CONTENT_MEDIA_TYPES,
+        :regexp_resolver => 'ecma'
+      )
     end
 
-    def valid_schema?(schema, default_schema_class: DEFAULT_SCHEMA_CLASS)
-      schema(schema, default_schema_class: default_schema_class).valid_schema?
+    def draft6
+      @draft6 ||= Schema.new(
+        Draft6::SCHEMA,
+        :vocabulary => { 'json-schemer://draft6' => true },
+        :base_uri => Draft6::BASE_URI,
+        :formats => Draft6::FORMATS,
+        :content_encodings => Draft6::CONTENT_ENCODINGS,
+        :content_media_types => Draft6::CONTENT_MEDIA_TYPES,
+        :regexp_resolver => 'ecma'
+      )
     end
 
-    def validate_schema(schema, default_schema_class: DEFAULT_SCHEMA_CLASS)
-      schema(schema, default_schema_class: default_schema_class).validate_schema
+    def draft4
+      @draft4 ||= Schema.new(
+        Draft4::SCHEMA,
+        :vocabulary => { 'json-schemer://draft4' => true },
+        :base_uri => Draft4::BASE_URI,
+        :formats => Draft4::FORMATS,
+        :content_encodings => Draft4::CONTENT_ENCODINGS,
+        :content_media_types => Draft4::CONTENT_MEDIA_TYPES,
+        :regexp_resolver => 'ecma'
+      )
     end
+
+    def openapi31
+      @openapi31 ||= Schema.new(
+        OpenAPI31::SCHEMA,
+        :base_uri => OpenAPI31::BASE_URI,
+        :formats => OpenAPI31::FORMATS,
+        :ref_resolver => OpenAPI31::Meta::SCHEMAS.to_proc,
+        :regexp_resolver => 'ecma'
+      )
+    end
+
+    def openapi30
+      @openapi30 ||= Schema.new(
+        OpenAPI30::SCHEMA,
+        :vocabulary => {
+          'json-schemer://draft4' => true,
+          'json-schemer://openapi30' => true
+        },
+        :base_uri => OpenAPI30::BASE_URI,
+        :formats => OpenAPI30::FORMATS,
+        :ref_resolver => OpenAPI30::Meta::SCHEMAS.to_proc,
+        :regexp_resolver => 'ecma'
+      )
+    end
+
+    def openapi31_document
+      @openapi31_document ||= Schema.new(
+        OpenAPI31::Document::SCHEMA_BASE,
+        :ref_resolver => OpenAPI31::Document::SCHEMAS.to_proc,
+        :regexp_resolver => 'ecma'
+      )
+    end
+
+    def openapi30_document
+      @openapi30_document ||= Schema.new(
+        OpenAPI30::Document::SCHEMA,
+        :ref_resolver => OpenAPI30::Document::SCHEMAS.to_proc,
+        :regexp_resolver => 'ecma'
+      )
+    end
+
+    def openapi(document, **options)
+      OpenAPI.new(document, **options)
+    end
+  end
+
+  META_SCHEMA_CALLABLES_BY_BASE_URI_STR = {
+    Draft202012::BASE_URI.to_s => method(:draft202012),
+    Draft201909::BASE_URI.to_s => method(:draft201909),
+    Draft7::BASE_URI.to_s => method(:draft7),
+    Draft6::BASE_URI.to_s => method(:draft6),
+    Draft4::BASE_URI.to_s => method(:draft4),
+    # version-less $schema deprecated after Draft 4
+    'http://json-schema.org/schema#' => method(:draft4),
+    OpenAPI31::BASE_URI.to_s => method(:openapi31),
+    OpenAPI30::BASE_URI.to_s => method(:openapi30)
+  }.freeze
+
+  META_SCHEMAS_BY_BASE_URI_STR = Hash.new do |hash, base_uri_str|
+    next unless META_SCHEMA_CALLABLES_BY_BASE_URI_STR.key?(base_uri_str)
+    hash[base_uri_str] = META_SCHEMA_CALLABLES_BY_BASE_URI_STR.fetch(base_uri_str).call
   end
 end