json_skooma 0.2.5 → 0.2.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eb2d7d35ec23d77daeda2fbc2e13a04a22265ecb549c2450b7f3e01fc0351a2a
-  data.tar.gz: f9c354da7ac5cd8354a968bc728313af943189f9b06279d3812e91dd88086139
+  metadata.gz: 0c9b29eaf20596ff580928de020aadb7e54bc70e449ae85bdcabc03124b205c5
+  data.tar.gz: 4a3b4949d29cd5a56785776929234907320d7df6ce86101a6527a5c29e8795c2
 SHA512:
-  metadata.gz: 5352834d1a61ad40c9416bfad5fb8543da5d872151a4e6925194c42b87639dc125fd1268343b6fc6b8b7bb0b047144dd21e95049cddfec065bc5e3990b54768a
-  data.tar.gz: 1095a00a437945ab384154da3f0f75a401636c39c21b9a7a2fd2b8de88140c909393c49f900c3295c289d6bb9795e238f3ccc2f7263348367076938ebf88bc8f
+  metadata.gz: 39af1cfcaf160b8b871a0d3e3f1a27f01f3327db0f767feb691b836591f7c07ebab5595f57317a229f366e32ecac56a2f4a0b718bb09821a2462186c14edb835
+  data.tar.gz: 4d279524b54059e230873d9b602017e299a7f76ef4ab8c907d0c540be036739c430a4c3821346aa9ae20cb63b808ed1b45373b847ab2f8bedfe6428372eb0418

data/CHANGELOG.md

@@ -7,6 +7,15 @@ and this project adheres to [Semantic Versioning].
 
 ## [Unreleased]
 
+## [0.2.6] - 2026-06-10
+
+### Added
+
+- New `:annotated` output format interleaves the instance data with annotations collected during evaluation (`title`/`description` by default, configurable via `keywords:`). Each node becomes `{"title" => ..., "value" => ...}`, mirroring the shape of the data — handy for rendering values alongside their schema-defined labels. ([@skryukov], [#13](https://github.com/skryukov/json_skooma/issues/13))
+- `JSONSkooma::UnexpectedSchemaClassError < RegistryError` is now raised by `Registry#schema` when the resolved fragment does not match the expected class. Extensions can rescue this specific error instead of matching on message text. ([@skryukov])
+- `Registry#load_json(uri)` is now public so extensions can load a raw document via registered sources. ([@skryukov])
+- `Keywords::ValueSchemas.default_schema_class=` lets extensions set the fallback class used to wrap sub-schemas when a keyword does not specify its own `schema_value_class`. ([@skryukov])
+
 ## [0.2.5] - 2024-12-25
 
 ### Added
@@ -63,7 +72,8 @@ and this project adheres to [Semantic Versioning].
 [@killondark]: https://github.com/killondark
 [@skryukov]: https://github.com/skryukov
 
-[Unreleased]: https://github.com/skryukov/json_skooma/compare/v0.2.5...HEAD
+[Unreleased]: https://github.com/skryukov/json_skooma/compare/v0.2.6...HEAD
+[0.2.6]: https://github.com/skryukov/json_skooma/compare/v0.2.5...v0.2.6
 [0.2.5]: https://github.com/skryukov/json_skooma/compare/v0.2.4...v0.2.5
 [0.2.4]: https://github.com/skryukov/json_skooma/compare/v0.2.3...v0.2.4
 [0.2.3]: https://github.com/skryukov/json_skooma/compare/v0.2.2...v0.2.3

data/README.md

@@ -156,6 +156,44 @@ schema_registry.add_source(
 # - http://remote.example/product_definition.yaml -> http://example.com/schemas/product_definition.yaml
 ```
 
+### Extracting annotations
+
+The `:annotated` output format re-shapes collected annotations into a hash that mirrors your data: every node becomes a hash of its annotations plus a `"value"` key holding the original value. Useful for rendering data alongside the `title`/`description` texts defined in the schema.
+
+```ruby
+schema = JSONSkooma::JSONSchema.new({
+  "$schema" => "https://json-schema.org/draft/2020-12/schema",
+  "type" => "object",
+  "properties" => {
+    "user_id" => {
+      "type" => "integer",
+      "title" => "User Identifier",
+      "description" => "A unique numeric ID for the user."
+    }
+  }
+})
+
+result = schema.evaluate({"user_id" => 123})
+
+result.output(:annotated)
+# {"user_id"=>
+#   {"title"=>"User Identifier",
+#    "description"=>"A unique numeric ID for the user.",
+#    "value"=>123}}
+
+# Pick which annotation keywords to include (default: title and description):
+result.output(:annotated, keywords: %w[title description default deprecated])
+
+# Rename the wrapper key:
+result.output(:annotated, value_key: "data")
+```
+
+Notes:
+
+- Annotations contributed through `$ref`/`allOf` are merged into the same location; if several subschemas annotate the same keyword at the same location, the last one wins.
+- Annotations from failed subschemas (e.g. a non-matching `anyOf` branch) are dropped, as the spec prescribes.
+- The root node is returned unwrapped to keep the output data-shaped, so annotations on the root schema itself are not included.
+
 ## Alternatives
 
 - [json_schemer](https://github.com/davishmcclurg/json_schemer) – Draft 4, 6, 7, 2019-09 and 2020-12 compliant

data/lib/json_skooma/formatters.rb

@@ -133,5 +133,61 @@ module JSONSkooma
       end
     end
     register :verbose, Verbose
+
+    # Re-shapes collected annotations into a hash that mirrors the instance
+    # data: every node (except the root) becomes a hash of its annotations
+    # plus a "value" key holding the original value (with nested nodes wrapped
+    # the same way). Annotations contributed through $ref/allOf land on the
+    # same instance location, so they merge naturally; annotations from failed
+    # subschemas are dropped, per the JSON Schema spec.
+    #
+    #   result.output(:annotated)
+    #   # => {"user_id" => {"title" => "User Identifier", "value" => 123}, ...}
+    #
+    # Options:
+    #   keywords: list of annotation keywords to include (default: title, description)
+    #   value_key: key under which the original value is placed (default: "value")
+    module Annotated
+      DEFAULT_KEYWORDS = %w[title description].freeze
+
+      class << self
+        def call(result, keywords: DEFAULT_KEYWORDS, value_key: "value", **_options)
+          annotations = {}
+          collect(result, keywords.map(&:to_s), annotations)
+          represent(result.instance, annotations, value_key, root: true)
+        end
+
+        private
+
+        def collect(node, keywords, annotations)
+          return unless node.valid?
+
+          if node.annotation && keywords.include?(node.key)
+            annotation = node.annotation
+            annotation = annotation.value if annotation.is_a?(JSONNode)
+            (annotations[node.instance.path.to_s] ||= {})[node.key] = annotation
+          end
+
+          node.each_children { |child| collect(child, keywords, annotations) }
+        end
+
+        def represent(instance, annotations, value_key, root: false)
+          value =
+            case instance.type
+            when "object"
+              instance.transform_values { |child| represent(child, annotations, value_key) }
+            when "array"
+              instance.map { |child| represent(child, annotations, value_key) }
+            else
+              instance.value
+            end
+
+          return value if root
+
+          (annotations[instance.path.to_s] || {}).merge(value_key => value)
+        end
+      end
+    end
+    register :annotated, Annotated
   end
 end

data/lib/json_skooma/keywords/value_schemas.rb

@@ -4,6 +4,8 @@ module JSONSkooma
   module Keywords
     module ValueSchemas
       class << self
+        attr_writer :default_schema_class
+
         def [](key)
           value_schemas&.[](key) or raise "Unknown value schema: #{key}, known schemas: #{value_schemas.keys.inspect}"
         end
@@ -12,6 +14,14 @@ module JSONSkooma
           (self.value_schemas ||= {})[key] = klass
         end
 
+        # Class used to wrap schema values when a keyword does not set its own
+        # `schema_value_class`. Extensions (e.g. Skooma) override this to plug
+        # their own JSONSchema subclass into every sub-schema created by the
+        # built-in applicator keywords.
+        def default_schema_class
+          @default_schema_class || JSONSchema
+        end
+
         private
 
         attr_accessor :value_schemas
@@ -21,7 +31,7 @@ module JSONSkooma
         def wrap_value(value)
           return super unless value.is_a?(Hash) || value.is_a?(TrueClass) || value.is_a?(FalseClass)
 
-          (self.class.schema_value_class || JSONSchema).new(
+          (self.class.schema_value_class || ValueSchemas.default_schema_class).new(
             value,
             parent: parent_schema,
             key: key,
@@ -46,7 +56,7 @@ module JSONSkooma
             value,
             parent: parent_schema,
             key: key,
-            item_class: self.class.schema_value_class || JSONSchema,
+            item_class: self.class.schema_value_class || ValueSchemas.default_schema_class,
             registry: parent_schema.registry,
             cache_id: parent_schema.cache_id
           )
@@ -69,7 +79,7 @@ module JSONSkooma
             value,
             parent: parent_schema,
             key: key,
-            item_class: self.class.schema_value_class || JSONSchema,
+            item_class: self.class.schema_value_class || ValueSchemas.default_schema_class,
             registry: parent_schema.registry,
             cache_id: parent_schema.cache_id
           )

data/lib/json_skooma/registry.rb

@@ -3,6 +3,19 @@
 module JSONSkooma
   class RegistryError < Error; end
 
+  # Raised when a ref resolves to an object that is not the class the caller expected.
+  # Extension points (e.g. typed OpenAPI refs) can rescue this and load the subtree
+  # as the right class without matching on error message text.
+  class UnexpectedSchemaClassError < RegistryError
+    attr_reader :uri, :expected_class
+
+    def initialize(uri, expected_class)
+      @uri = uri
+      @expected_class = expected_class
+      super("The object referenced by #{uri} is not #{expected_class}")
+    end
+  end
+
   class Registry
     class << self
       attr_accessor :registries
@@ -79,7 +92,7 @@ module JSONSkooma
       schema = JSONPointer.new(uri.fragment).eval(schema) if uri.fragment
       return schema if schema.is_a?(expected_class)
 
-      raise RegistryError, "The object referenced by #{uri} is not #{expected_class}"
+      raise UnexpectedSchemaClassError.new(uri, expected_class)
     end
 
     def add_metaschema(uri, default_core_vocabulary_uri = nil, *default_vocabulary_uris)
@@ -113,8 +126,6 @@ module JSONSkooma
       @uri_sources[uri] = source
     end
 
-    private
-
     def load_json(uri)
       candidates = @uri_sources
         .select { |source_uri| uri.to_s.start_with?(source_uri) }

data/lib/json_skooma/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module JSONSkooma
-  VERSION = "0.2.5"
+  VERSION = "0.2.6"
 end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: json_skooma
 version: !ruby/object:Gem::Version
-  version: 0.2.5
+  version: 0.2.6
 platform: ruby
 authors:
 - Svyatoslav Kryukov
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-12-25 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bigdecimal
@@ -90,40 +89,6 @@ files:
 - CHANGELOG.md
 - LICENSE.txt
 - README.md
-- data/draft-2019-09/README.md
-- data/draft-2019-09/hyper-schema.json
-- data/draft-2019-09/links.json
-- data/draft-2019-09/meta/applicator.json
-- data/draft-2019-09/meta/content.json
-- data/draft-2019-09/meta/core.json
-- data/draft-2019-09/meta/format.json
-- data/draft-2019-09/meta/hyper-schema.json
-- data/draft-2019-09/meta/meta-data.json
-- data/draft-2019-09/meta/validation.json
-- data/draft-2019-09/output/hyper-schema.json
-- data/draft-2019-09/output/schema.json
-- data/draft-2019-09/output/verbose-example.json
-- data/draft-2019-09/schema.json
-- data/draft-2020-12/README.md
-- data/draft-2020-12/adr/README.md
-- data/draft-2020-12/archive/hyper-schema.json
-- data/draft-2020-12/archive/links.json
-- data/draft-2020-12/archive/meta/hyper-schema.json
-- data/draft-2020-12/hyper-schema.json
-- data/draft-2020-12/links.json
-- data/draft-2020-12/meta/applicator.json
-- data/draft-2020-12/meta/content.json
-- data/draft-2020-12/meta/core.json
-- data/draft-2020-12/meta/format-annotation.json
-- data/draft-2020-12/meta/format-assertion.json
-- data/draft-2020-12/meta/hyper-schema.json
-- data/draft-2020-12/meta/meta-data.json
-- data/draft-2020-12/meta/unevaluated.json
-- data/draft-2020-12/meta/validation.json
-- data/draft-2020-12/output/hyper-schema.json
-- data/draft-2020-12/output/schema.json
-- data/draft-2020-12/output/verbose-example.json
-- data/draft-2020-12/schema.json
 - lib/json_skooma.rb
 - lib/json_skooma/dialects/draft201909.rb
 - lib/json_skooma/dialects/draft202012.rb
@@ -236,7 +201,6 @@ metadata:
   homepage_uri: https://github.com/skryukov/json_skooma
   source_code_uri: https://github.com/skryukov/json_skooma
   rubygems_mfa_required: 'true'
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -251,8 +215,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.23
-signing_key:
+rubygems_version: 4.0.6
 specification_version: 4
 summary: I bring some sugar for your JSONs.
 test_files: []

data/data/draft-2019-09/README.md

@@ -1,60 +0,0 @@
-# Welcome to JSON Schema
-
-JSON Schema is a vocabulary that allows you to validate, annotate, and manipulate JSON documents.
-
-This repository contains the sources for the **work in progress** of the next set of JSON Schema IETF Internet Draft (I-D) documents.
-For the latest released I-Ds, please see the [Specification page](http://json-schema.org/documentation.html) on the website.
-
-## Call for contributions and feedback
-
-Reviews, comments and suggestions are most welcome!
-Please read our [guidelines for contributing](CONTRIBUTING.md).
-
-## Status
-For the current status of issues and pull requests, please see the following labels
-
-[![Available](https://img.shields.io/github/issues/json-schema-org/json-schema-spec/Status:%20Available.svg?color=brightgreen)](https://github.com/json-schema-org/json-schema-spec/issues?q=is%3Aopen+is%3Aissue+label%3A%22Status%3A+Available%22) [![In Progress](https://img.shields.io/github/issues/json-schema-org/json-schema-spec/Status:%20In%20Progress.svg)](https://github.com/json-schema-org/json-schema-spec/labels/Status:%20In%20Progress) [![Review Needed](https://img.shields.io/github/issues/json-schema-org/json-schema-spec/Status:%20Review%20Needed.svg)](https://github.com/json-schema-org/json-schema-spec/labels/Status%3A%20Review%20Needed)
-
-[![Critical](https://img.shields.io/github/issues/json-schema-org/json-schema-spec/Priority:%20Critical.svg?color=critical
-)](https://github.com/json-schema-org/json-schema-spec/labels/Priority%3A%20Critical) [![High](https://img.shields.io/github/issues/json-schema-org/json-schema-spec/Priority:%20High.svg?color=important)](https://github.com/json-schema-org/json-schema-spec/labels/Priority%3A%20High) [![Medium](https://img.shields.io/github/issues/json-schema-org/json-schema-spec/Priority:%20Medium.svg)](https://github.com/json-schema-org/json-schema-spec/labels/Priority%3A%20Medium) [![Low](https://img.shields.io/github/issues/json-schema-org/json-schema-spec/Priority:%20Low.svg)](https://github.com/json-schema-org/json-schema-spec/labels/Priority%3A%20Low) 
-
-
-Labels are assigned based on [Sensible Github Labels](https://github.com/Relequestual/sensible-github-labels).
-
-## Contents
-
-* Makefile - scripts to build the Internet-Draft txt/html
-* _Internet-Draft sources_
-    * jsonschema-core.xml - source for JSON Schema's "core" I-D
-    * jsonschema-validation.xml - source for the validation vocabulary I-D
-    * jsonschema-hyperschema.xml - source for the hyper-schema vocabulary I-D
-    * relative-json-pointer.xml - source for the Relative JSON Pointer I-D
-* _meta-schemas and recommended output formats_
-    * schema.json - JSON Schema "core" and Validation meta-schema
-    * hyper-schema.json - JSON Hyper-Schema meta-schema
-    * links.json - JSON Hyper-Schema's Link Description Object meta-schema
-    * hyper-schema-output.json - The recommended output format for JSON Hyper-Schema links
-
-Type "make" at a shell to build the .txt and .html spec files.
-
-Descriptions of the xml2rfc, I-D documents, and RFC processes:
-
-* https://xml2rfc.tools.ietf.org/authoring/draft-mrose-writing-rfcs.html
-* https://www.ietf.org/tao.html
-* https://www.ietf.org/ietf-ftp/1id-guidelines.html
-* https://www.rfc-editor.org/rfc/rfc7322.txt
-
-## Test suites
-
-Conformance tests for JSON Schema and its vocabularies may be found
-[in their own repository](https://github.com/json-schema-org/JSON-Schema-Test-Suite).
-
-## The website
-
-The JSON Schema web site is at http://json-schema.org/
-
-The source for the website is [maintained in a separate repository](https://github.com/json-schema-org/website).
-
-## License
-
-The source material in this repository is licensed under the AFL or BSD license.

data/data/draft-2019-09/hyper-schema.json

@@ -1,26 +0,0 @@
-{
-    "$schema": "https://json-schema.org/draft/2019-09/hyper-schema",
-    "$id": "https://json-schema.org/draft/2019-09/hyper-schema",
-    "$vocabulary": {
-        "https://json-schema.org/draft/2019-09/vocab/core": true,
-        "https://json-schema.org/draft/2019-09/vocab/applicator": true,
-        "https://json-schema.org/draft/2019-09/vocab/validation": true,
-        "https://json-schema.org/draft/2019-09/vocab/meta-data": true,
-        "https://json-schema.org/draft/2019-09/vocab/format": false,
-        "https://json-schema.org/draft/2019-09/vocab/content": true,
-        "https://json-schema.org/draft/2019-09/vocab/hyper-schema": true
-    },
-    "$recursiveAnchor": true,
-
-    "title": "JSON Hyper-Schema",
-    "allOf": [
-        {"$ref": "https://json-schema.org/draft/2019-09/schema"},
-        {"$ref": "https://json-schema.org/draft/2019-09/meta/hyper-schema"}
-    ],
-    "links": [
-        {
-            "rel": "self",
-            "href": "{+%24id}"
-        }
-    ]
-}

data/data/draft-2019-09/links.json

@@ -1,91 +0,0 @@
-{
-    "$schema": "https://json-schema.org/draft/2019-09/schema",
-    "$id": "https://json-schema.org/draft/2019-09/links",
-    "title": "Link Description Object",
-    "allOf": [
-        { "required": [ "rel", "href" ] },
-        { "$ref": "#/$defs/noRequiredFields" }
-    ],
-    "$defs": {
-        "noRequiredFields": {
-            "type": "object",
-            "properties": {
-                "anchor": {
-                    "type": "string",
-                    "format": "uri-template"
-                },
-                "anchorPointer": {
-                    "type": "string",
-                    "anyOf": [
-                        { "format": "json-pointer" },
-                        { "format": "relative-json-pointer" }
-                    ]
-                },
-                "rel": {
-                    "anyOf": [
-                        { "type": "string" },
-                        {
-                            "type": "array",
-                            "items": { "type": "string" },
-                            "minItems": 1
-                        }
-                    ]
-                },
-                "href": {
-                    "type": "string",
-                    "format": "uri-template"
-                },
-                "hrefSchema": {
-                    "$ref": "https://json-schema.org/draft/2019-09/hyper-schema",
-                    "default": false
-                },
-                "templatePointers": {
-                    "type": "object",
-                    "additionalProperties": {
-                        "type": "string",
-                        "anyOf": [
-                            { "format": "json-pointer" },
-                            { "format": "relative-json-pointer" }
-                        ]
-                    }
-                },
-                "templateRequired": {
-                    "type": "array",
-                    "items": {
-                        "type": "string"
-                    },
-                    "uniqueItems": true
-                },
-                "title": {
-                    "type": "string"
-                },
-                "description": {
-                    "type": "string"
-                },
-                "targetSchema": {
-                    "$ref": "https://json-schema.org/draft/2019-09/hyper-schema",
-                    "default": true
-                },
-                "targetMediaType": {
-                    "type": "string"
-                },
-                "targetHints": { },
-                "headerSchema": {
-                    "$ref": "https://json-schema.org/draft/2019-09/hyper-schema",
-                    "default": true
-                },
-                "submissionMediaType": {
-                    "type": "string",
-                    "default": "application/json"
-                },
-                "submissionSchema": {
-                    "$ref": "https://json-schema.org/draft/2019-09/hyper-schema",
-                    "default": true
-                },
-                "$comment": {
-                    "type": "string"
-                }
-            }
-        }
-    }
-}

data/data/draft-2019-09/meta/applicator.json

@@ -1,53 +0,0 @@
-{
-    "$schema": "https://json-schema.org/draft/2019-09/schema",
-    "$id": "https://json-schema.org/draft/2019-09/meta/applicator",
-    "$recursiveAnchor": true,
-
-    "title": "Applicator vocabulary meta-schema",
-    "type": ["object", "boolean"],
-    "properties": {
-        "additionalItems": { "$recursiveRef": "#" },
-        "unevaluatedItems": { "$recursiveRef": "#" },
-        "items": {
-            "anyOf": [
-                { "$recursiveRef": "#" },
-                { "$ref": "#/$defs/schemaArray" }
-            ]
-        },
-        "contains": { "$recursiveRef": "#" },
-        "additionalProperties": { "$recursiveRef": "#" },
-        "unevaluatedProperties": { "$recursiveRef": "#" },
-        "properties": {
-            "type": "object",
-            "additionalProperties": { "$recursiveRef": "#" },
-            "default": {}
-        },
-        "patternProperties": {
-            "type": "object",
-            "additionalProperties": { "$recursiveRef": "#" },
-            "propertyNames": { "format": "regex" },
-            "default": {}
-        },
-        "dependentSchemas": {
-            "type": "object",
-            "additionalProperties": {
-                "$recursiveRef": "#"
-            }
-        },
-        "propertyNames": { "$recursiveRef": "#" },
-        "if": { "$recursiveRef": "#" },
-        "then": { "$recursiveRef": "#" },
-        "else": { "$recursiveRef": "#" },
-        "allOf": { "$ref": "#/$defs/schemaArray" },
-        "anyOf": { "$ref": "#/$defs/schemaArray" },
-        "oneOf": { "$ref": "#/$defs/schemaArray" },
-        "not": { "$recursiveRef": "#" }
-    },
-    "$defs": {
-        "schemaArray": {
-            "type": "array",
-            "minItems": 1,
-            "items": { "$recursiveRef": "#" }
-        }
-    }
-}

data/data/draft-2019-09/meta/content.json

@@ -1,14 +0,0 @@
-{
-    "$schema": "https://json-schema.org/draft/2019-09/schema",
-    "$id": "https://json-schema.org/draft/2019-09/meta/content",
-    "$recursiveAnchor": true,
-
-    "title": "Content vocabulary meta-schema",
-
-    "type": ["object", "boolean"],
-    "properties": {
-        "contentMediaType": { "type": "string" },
-        "contentEncoding": { "type": "string" },
-        "contentSchema": { "$recursiveRef": "#" }
-    }
-}

data/data/draft-2019-09/meta/core.json

@@ -1,54 +0,0 @@
-{
-    "$schema": "https://json-schema.org/draft/2019-09/schema",
-    "$id": "https://json-schema.org/draft/2019-09/meta/core",
-    "$recursiveAnchor": true,
-
-    "title": "Core vocabulary meta-schema",
-    "type": ["object", "boolean"],
-    "properties": {
-        "$id": {
-            "type": "string",
-            "format": "uri-reference",
-            "$comment": "Non-empty fragments not allowed.",
-            "pattern": "^[^#]*#?$"
-        },
-        "$schema": {
-            "type": "string",
-            "format": "uri"
-        },
-        "$anchor": {
-            "type": "string",
-            "pattern": "^[A-Za-z][-A-Za-z0-9.:_]*$"
-        },
-        "$ref": {
-            "type": "string",
-            "format": "uri-reference"
-        },
-        "$recursiveRef": {
-            "type": "string",
-            "format": "uri-reference"
-        },
-        "$recursiveAnchor": {
-            "type": "boolean",
-            "default": false
-        },
-        "$vocabulary": {
-            "type": "object",
-            "propertyNames": {
-                "type": "string",
-                "format": "uri"
-            },
-            "additionalProperties": {
-                "type": "boolean"
-            }
-        },
-        "$comment": {
-            "type": "string"
-        },
-        "$defs": {
-            "type": "object",
-            "additionalProperties": { "$recursiveRef": "#" },
-            "default": {}
-        }
-    }
-}

data/data/draft-2019-09/meta/format.json

@@ -1,11 +0,0 @@
-{
-    "$schema": "https://json-schema.org/draft/2019-09/schema",
-    "$id": "https://json-schema.org/draft/2019-09/meta/format",
-    "$recursiveAnchor": true,
-
-    "title": "Format vocabulary meta-schema",
-    "type": ["object", "boolean"],
-    "properties": {
-        "format": { "type": "string" }
-    }
-}

data/data/draft-2019-09/meta/hyper-schema.json

@@ -1,26 +0,0 @@
-{
-    "$schema": "https://json-schema.org/draft/2019-09/hyper-schema",
-    "$id": "https://json-schema.org/draft/2019-09/meta/hyper-schema",
-    "$recursiveAnchor": true,
-
-    "title": "JSON Hyper-Schema Vocabulary Schema",
-    "type": ["object", "boolean"],
-    "properties": {
-        "base": {
-            "type": "string",
-            "format": "uri-template"
-        },
-        "links": {
-            "type": "array",
-            "items": {
-                "$ref": "https://json-schema.org/draft/2019-09/links"
-            }
-        }
-    },
-    "links": [
-        {
-            "rel": "self",
-            "href": "{+%24id}"
-        }
-    ]
-}