schemurai 1.0.0 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6c7e69c0dbcafac0bb00bc78aa315932cfd59a141d0727e1a6e4366f80dc416b
-  data.tar.gz: 1ddb9269a448dc6c088a7bf22f341e064c2bb3cd0712da6750fc29545379b268
+  metadata.gz: f1b157d6e772537cab2886ef6d89bd547992c7359b73a13a49b9d9cfcdcc9808
+  data.tar.gz: f0e8e28536c58c95cf1848db949dad8007df0c7a6550dd8b0fd76439841617cd
 SHA512:
-  metadata.gz: 5f201d9a44db39000dc36081d9212e221e3e1ba69d4650dcdd929f9709a401cbb6de1412587344246ed736bec0da0e576b19daadc9d91cda5eb4a4d9924d00a8
-  data.tar.gz: 604dd071010fffc73639338b7f84eefa9328f7c574156cd52077f1d6f6ae9c6ebe0ff1360c2c80c29328659242547b3a3652f0165d926ac944ab1b1fcb025c41
+  metadata.gz: b6f8206124aab29ae13908951efdd011e276ca347a75c0abf79da9fb3a9988f91a0a59b0ec559b85a88f01d5975b9ea251f9f14bb7aba634b7c8f3625c288167
+  data.tar.gz: 3fcd551c456cb81b53842c0736ae9e629676ca8c7c0e43017ee43991b00b995fde7a530f1c0cb38f81d5e7bb640b68a8ad8ad388934af73b06b4ef77c4e46a34

data/README.md

@@ -1,5 +1,9 @@
 # Schemurai
 
+[![Gem Version](https://badge.fury.io/rb/schemurai.svg?icon=si%3Arubygems)](https://badge.fury.io/rb/schemurai)
+[![test / rspec](https://github.com/oakcask/schemurai/actions/workflows/test--rspec.yaml/badge.svg)](https://github.com/oakcask/schemurai/actions/workflows/test--rspec.yaml)
+[![lint / rubocop](https://github.com/oakcask/schemurai/actions/workflows/lint--rubocop.yaml/badge.svg)](https://github.com/oakcask/schemurai/actions/workflows/lint--rubocop.yaml)
+
 A small, light-weight-dependency JSON Schema validator for Ruby supporting Draft 7,
 Draft 2019-09, and Draft 2020-12. It covers the required cases in the official
 JSON-Schema-Test-Suite, as well as the applicable optional tests for numeric
@@ -93,6 +97,11 @@ validator. Repeatedly compiling the same schema object with one registry reuses
 its compiled schema graph. `Schemurai.validate` and `.valid?` continue
 to accept raw JSON-like schemas and perform compilation internally.
 
+Schema inputs are checked recursively before compilation. They must use the
+built-in JSON-shaped Ruby classes described in
+[`docs/compatibility-domain.md`](docs/compatibility-domain.md); rejected values
+are never retained by a registry.
+
 To resolve external references, pass a mapping of URIs to schemas using
 `schemas:`.
 
@@ -111,7 +120,39 @@ validation for `contentEncoding` and `contentMediaType` with `content: true`.
 Enable optional format assertions with `format: true`; support for each format is
 listed separately below.
 
-### Thread / Ractor native feature
+### Validation errors
+
+```ruby
+result = Schemurai.validate(
+  { "$ref" => "https://example.test/positive" },
+  -1,
+  schemas: { "https://example.test/positive" => { "type" => "integer", "minimum" => 1 } }
+)
+
+validation_error = result.errors[0]
+p validation_error.keyword # => "minimum"
+p validation_error.instance_path # => ""
+p validation_error.schema_path # => "/$ref/minimum"
+p validation_error.message # => "number must be greater than or equal to 1"
+```
+
+`Result#errors` contains `Schemurai::ValidationError` objects.
+Check the following attributes to investigate schema errors:
+
+- `keyword` identifies the failed JSON Schema keyword. Schemurai uses
+  `falseSchema` for a boolean `false` schema, which has no keyword of its own.
+- `instance_path` is a JSON Pointer to the value that failed validation.
+- `schema_path` is a JSON Pointer to the schema location that produced the
+  error.
+- `message` is a human-readable `String` describing the failure.
+
+An empty path points to the instance or schema root. Error order is stable.
+The presence and type of `message` are part of the public API, but its exact
+wording is not. Use `keyword`, `instance_path`, and `schema_path`, rather than
+matching `message`, when handling errors programmatically. `ValidationError#to_h`
+returns these four attributes as a Hash.
+
+### Thread / Ractor support
 
 To share a registry between threads or Ractors, finish registering schemas and
 make the registry shareable first. This eagerly compiles every registered
@@ -122,7 +163,9 @@ registry = Schemurai::SchemaRegistry.new(
   schemas: {
     "https://example.test/positive" => { "type" => "integer", "minimum" => 1 },
     "https://example.test/value" => { "$ref" => "https://example.test/positive" }
-  }
+  },
+  # enable virtual machine backend that is faster for iterative validation.
+  backend: :vm
 )
 registry.make_shareable
 
@@ -134,7 +177,46 @@ validator = registry.validator_for("https://example.test/value")
 `ResolutionError` if a reference cannot be resolved. After it returns,
 `validator_for` is read-only and may be called concurrently, while `compile` is
 no longer available. A `Validator` contains per-validation mutable state and
-must not be shared between threads or Ractors.
+must not be shared between threads or Ractors. With the VM backend, the registry
+compiles and shares its bytecode before this transition, so those validators do
+not compile separate instruction streams in each Ractor.
+
+### Meta-schema validation
+
+Meta-schema validation is opt-in so ordinary compilation does not pay its
+additional time and memory cost. Set `validate_schema: true` when creating a
+`SchemaRegistry` to validate every schema registered through `schemas:` and
+every schema passed to `compile`. The convenience `compile`, `validate`, and
+`valid?` methods accept the same option and apply it to their internal registry.
+Schemas without `$schema` use the Draft 7 meta-schema. An invalid schema raises
+`Schemurai::InvalidSchemaError`, whose `result` contains the detailed validation
+errors.
+
+```ruby
+Schemurai.compile(schema, validate_schema: true)
+
+registry = Schemurai::SchemaRegistry.new(
+  schemas: external_schemas,
+  validate_schema: true
+)
+validator = registry.compile(schema)
+
+result = Schemurai.validate_schema(schema)
+result.valid? # whether the schema itself is valid
+```
+
+`SchemaRegistry#validate_schema` and `#valid_schema?` perform explicit checks
+regardless of the registry option and reuse meta-schema graph data within that
+registry. The stateful validator used for a check is temporary; no global
+validator is retained.
+
+### Backend selection
+
+`Schemurai.backend`, `SchemaRegistry#backend`, and `Validator#backend` expose
+the actual backend. Pass `backend: :ruby` to force the Ruby oracle or
+`backend: :vm` to ahead-of-time compile schemas for the validator virtual machine.
+Schema graph construction remains shared Ruby infrastructure. Environment-based selection
+is documented in [`docs/backend-selection.md`](docs/backend-selection.md).
 
 ## JSON Schema conformance
 
@@ -195,6 +277,16 @@ Run the test suite with:
 bundle exec rspec
 ```
 
+Verify the reviewed official-suite classifications with:
+
+```sh
+ruby script/oracle-cases --summary
+```
+
+The serialized oracle tools are `script/oracle-runner` and
+`script/oracle-compare`. Ruby interpreter and YJIT baseline instructions are in
+[`benchmark/baselines/README.md`](benchmark/baselines/README.md).
+
 Run the linter with:
 
 ```sh

data/lib/schemurai/backend.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Schemurai
+  module Backend
+    VM_FEATURE = "vm/evaluator"
+    CHOICES = %i[default ruby vm].freeze
+
+    module_function def requested
+      value = ENV.fetch("SCHEMURAI_BACKEND", "default").to_sym
+      return value if CHOICES.include?(value)
+
+      raise Error, "unknown Schemurai backend #{value.inspect}"
+    end
+
+    module_function def resolve(selection = requested)
+      selection = selection.to_sym
+      raise Error, "unknown Schemurai backend #{selection.inspect}" unless CHOICES.include?(selection)
+
+      selection = production_default if selection == :default
+      load_vm! if selection == :vm
+      selection
+    end
+
+    module_function def production_default
+      :ruby
+    end
+
+    module_function def load_vm!
+      require_relative VM_FEATURE
+    end
+  end
+end

data/lib/schemurai/error_message.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Schemurai
+  module Internal
+    # Builds validation messages shared by every evaluator backend.
+    module ErrorMessage
+      module_function def false_schema = "value is not allowed by this schema"
+
+      module_function def type(expected, value)
+        expected = Array(expected).map { |name| name.inspect }.join(" or ")
+        "value has type #{json_type(value).inspect}, but must have type #{expected}"
+      end
+
+      module_function def enum = "value must equal one of the values defined by `enum`"
+      module_function def const = "value must equal the value defined by `const`"
+
+      module_function def numeric_limit(keyword, limit)
+        comparison = {
+          "maximum" => "less than or equal to",
+          "minimum" => "greater than or equal to",
+          "exclusiveMaximum" => "less than",
+          "exclusiveMinimum" => "greater than"
+        }.fetch(keyword)
+        "number must be #{comparison} #{display_number(limit)}"
+      end
+
+      module_function def multiple_of(divisor) = "number must be a multiple of #{display_number(divisor)}"
+
+      module_function def size(keyword, limit, actual)
+        subject, unit, comparison = {
+          "maxLength" => ["string", "characters", "at most"],
+          "minLength" => ["string", "characters", "at least"],
+          "maxItems" => ["array", "items", "at most"],
+          "minItems" => ["array", "items", "at least"],
+          "maxProperties" => ["object", "properties", "at most"],
+          "minProperties" => ["object", "properties", "at least"]
+        }.fetch(keyword)
+        unit = {"characters" => "character", "items" => "item", "properties" => "property"}.fetch(unit) if limit == 1
+        "#{subject} must contain #{comparison} #{limit} #{unit} (found #{actual})"
+      end
+
+      module_function def pattern(pattern) = "string must match pattern #{pattern.inspect}"
+      module_function def invalid_pattern(pattern) = "schema pattern #{pattern.inspect} is not a valid regular expression"
+      module_function def format(name) = "string must match the #{name} format"
+      module_function def content_encoding = "string must be valid base64"
+      module_function def content_media_type = "string must contain valid JSON"
+      module_function def unique_items = "array items must be unique"
+
+      module_function def contains(actual, minimum, maximum)
+        expected = if maximum.infinite?
+          "at least #{minimum}"
+        elsif minimum == maximum
+          "exactly #{minimum}"
+        elsif minimum.zero?
+          "at most #{maximum}"
+        else
+          "between #{minimum} and #{maximum}"
+        end
+        "array must contain #{expected} items matching `contains` (found #{actual})"
+      end
+
+      module_function def required(name) = "object is missing required property #{name.inspect}"
+
+      module_function def dependent_required(name, required_name)
+        "property #{required_name.inspect} is required when property #{name.inspect} is present"
+      end
+
+      module_function def any_of = "value must match at least one subschema"
+      module_function def one_of(matches) = "value must match exactly one subschema (matched #{matches})"
+      module_function def not = "value must not match the subschema"
+
+      module_function def json_type(value)
+        case value
+        when nil then "null"
+        when true, false then "boolean"
+        when Hash then "object"
+        when Array then "array"
+        when String then "string"
+        when Numeric
+          if value.is_a?(Complex)
+            value.class.name
+          elsif value.finite? && value.to_i == value
+            "integer"
+          else
+            "number"
+          end
+        else
+          value.class.name
+        end
+      end
+      private_class_method :json_type
+
+      module_function def display_number(value)
+        rational = value.is_a?(Rational) ? value : Rational(value.to_s)
+        return rational.numerator.to_s if rational.denominator == 1
+
+        rational.to_f.to_s
+      end
+      private_class_method :display_number
+    end
+  end
+end

data/lib/schemurai/evaluator.rb

@@ -3,12 +3,15 @@
 require "json"
 require "base64"
 require_relative "evaluation"
+require_relative "error_message"
 
 module Schemurai
   module Internal
     class Evaluator
       MISSING_SEGMENT = Object.new.freeze
 
+      def backend = :ruby
+
       def initialize(graph, root, content: false, format: false)
         @validate_content = content
         @validate_format = format
@@ -28,6 +31,7 @@ module Schemurai
         @error_callback = nil
         @error_count = 0
         @track_dynamic_scope = @graph.dynamic_scope?
+        @dynamic_scope = nil
         @instance_path = nil
         @schema_path = nil
         evaluate_valid(@root, instance)
@@ -37,6 +41,7 @@ module Schemurai
         @error_callback = callback
         @error_count = 0
         @track_dynamic_scope = @graph.dynamic_scope?
+        @dynamic_scope = nil
         @instance_path = []
         @schema_path = []
         evaluate(@root, instance)
@@ -329,7 +334,7 @@ module Schemurai
         schema = node.schema
         return Evaluation.valid if schema == true
         if schema == false
-          add_error("falseSchema", "boolean schema is false", append_keyword: false)
+          add_error("falseSchema", append_keyword: false) { ErrorMessage.false_schema }
           return Evaluation.invalid
         end
         return Evaluation.valid unless schema.is_a?(Hash)
@@ -411,7 +416,7 @@ module Schemurai
         target = @graph.resolve(node, reference)
         return target unless reference.to_s.end_with?("#") && target.schema.is_a?(Hash) && target.schema["$recursiveAnchor"] == true
 
-        @dynamic_scope.filter_map { |resource| resource.root if resource.root.schema.is_a?(Hash) && resource.root.schema["$recursiveAnchor"] == true }.first || target
+        Array(@dynamic_scope).filter_map { |resource| resource.root if resource.root.schema.is_a?(Hash) && resource.root.schema["$recursiveAnchor"] == true }.first || target
       end
 
       private def dynamic_target(node, reference)
@@ -420,7 +425,7 @@ module Schemurai
         return target if raw_fragment.nil? || raw_fragment.empty? || raw_fragment.start_with?("/")
         return target unless target.schema.is_a?(Hash) && target.schema["$dynamicAnchor"] == raw_fragment
 
-        @dynamic_scope.each do |resource|
+        Array(@dynamic_scope).each do |resource|
           dynamic = @graph.dynamic_anchor(resource, raw_fragment)
           return dynamic if dynamic
         end
@@ -438,15 +443,15 @@ module Schemurai
         types = Array(schema["type"])
         return if types.any? { |type| type?(value, type) }
 
-        add_error("type", "expected #{types.join(" or ")}")
+        add_error("type") { ErrorMessage.type(types, value) }
       end
 
       private def check_enum(schema, value)
         if schema.key?("enum") && !schema["enum"].any? { |candidate| json_equal?(candidate, value) }
-          add_error("enum", "value is not in enum")
+          add_error("enum") { ErrorMessage.enum }
         end
         if schema.key?("const") && !json_equal?(schema["const"], value)
-          add_error("const", "value does not equal const")
+          add_error("const") { ErrorMessage.const }
         end
       end
 
@@ -468,7 +473,7 @@ module Schemurai
             matches << result if result.valid?
           end
           if matches.empty?
-            add_error("anyOf", "no subschema matched")
+            add_error("anyOf") { ErrorMessage.any_of }
           else
             matches.each { |result| evaluation = evaluation.merge(result) }
           end
@@ -483,12 +488,12 @@ module Schemurai
           if matches.length == 1
             evaluation = evaluation.merge(matches.first)
           else
-            add_error("oneOf", "expected exactly one match, got #{matches.length}")
+            add_error("oneOf") { ErrorMessage.one_of(matches.length) }
           end
         end
 
         if schema.key?("not") && trial_at(node.child("not"), value, MISSING_SEGMENT, "not").valid?
-          add_error("not", "subschema matched")
+          add_error("not") { ErrorMessage.not }
         end
 
         if schema.key?("if")
@@ -512,14 +517,14 @@ module Schemurai
 
         divisor = decimal(schema["multipleOf"])
         valid = divisor.positive? && decimal(value).remainder(divisor).zero?
-        add_error("multipleOf", "number is not a multiple") unless valid
+        add_error("multipleOf") { ErrorMessage.multiple_of(schema["multipleOf"]) } unless valid
       end
 
       private def compare(schema, keyword, value)
         return unless schema.key?(keyword)
         return if yield(decimal(value), decimal(schema[keyword]))
 
-        add_error(keyword, "numeric limit was exceeded")
+        add_error(keyword) { ErrorMessage.numeric_limit(keyword, schema[keyword]) }
       end
 
       private def check_string(node, value)
@@ -530,14 +535,14 @@ module Schemurai
 
         if schema.key?("pattern")
           matched = ecma_regexp(schema["pattern"]).match?(value)
-          add_error("pattern", "string does not match pattern") unless matched
+          add_error("pattern") { ErrorMessage.pattern(schema["pattern"]) } unless matched
         end
         if format_asserted?(node)
-          add_error("format", "string is not a valid #{node.format.name}") unless node.format.call(value)
+          add_error("format") { ErrorMessage.format(node.format.name) } unless node.format.call(value)
         end
         check_content(schema, value) if @validate_content
       rescue RegexpError
-        add_error("pattern", "invalid regular expression")
+        add_error("pattern") { ErrorMessage.invalid_pattern(schema["pattern"]) }
       end
 
       private def format_asserted?(node)
@@ -554,7 +559,7 @@ module Schemurai
           duplicate = value.each_with_index.any? do |item, index|
             value[0...index].any? { |previous| json_equal?(previous, item) }
           end
-          add_error("uniqueItems", "array items are not unique") if duplicate
+          add_error("uniqueItems") { ErrorMessage.unique_items } if duplicate
         end
 
         prefix_items = schema["prefixItems"]
@@ -596,7 +601,7 @@ module Schemurai
           minimum = schema.fetch("minContains", 1)
           maximum = schema.fetch("maxContains", Float::INFINITY)
           unless matched.length.between?(minimum, maximum)
-            add_error("contains", "matched #{matched.length} array items")
+            add_error("contains") { ErrorMessage.contains(matched.length, minimum, maximum) }
           end
           evaluated.concat(matched)
         end
@@ -619,7 +624,7 @@ module Schemurai
         limit(schema, "minProperties", value.length) { |actual, expected| actual >= expected }
 
         Array(schema["required"]).each do |name|
-          add_error("required", "required property #{name.inspect} is missing") unless value.key?(name)
+          add_error("required") { ErrorMessage.required(name) } unless value.key?(name)
         end
 
         properties = schema.fetch("properties", {})
@@ -653,7 +658,7 @@ module Schemurai
           next unless value.key?(name)
           if dependency.is_a?(Array)
             dependency.each do |required_name|
-              add_error("dependencies", "property #{required_name.inspect} is required by #{name.inspect}") unless value.key?(required_name)
+              add_error("dependencies") { ErrorMessage.dependent_required(name, required_name) } unless value.key?(required_name)
             end
           else
             result = evaluate_at(node.child("dependencies", name), value, MISSING_SEGMENT, "dependencies", name)
@@ -665,7 +670,7 @@ module Schemurai
           next unless value.key?(name)
           required_names.each do |required_name|
             unless value.key?(required_name)
-              add_error("dependentRequired", "property #{required_name.inspect} is required by #{name.inspect}")
+              add_error("dependentRequired") { ErrorMessage.dependent_required(name, required_name) }
             end
           end
         end
@@ -703,7 +708,7 @@ module Schemurai
         return unless schema.key?(keyword)
         return if yield(actual, schema[keyword])
 
-        add_error(keyword, "size limit was exceeded")
+        add_error(keyword) { ErrorMessage.size(keyword, schema[keyword], actual) }
       end
 
       private def type?(value, type)
@@ -799,10 +804,12 @@ module Schemurai
         JSON.parse(decoded)
       rescue ArgumentError, JSON::ParserError
         keyword = (schema["contentEncoding"] == "base64") ? "contentEncoding" : "contentMediaType"
-        add_error(keyword, "string content is invalid")
+        add_error(keyword) do
+          (keyword == "contentEncoding") ? ErrorMessage.content_encoding : ErrorMessage.content_media_type
+        end
       end
 
-      private def add_error(keyword, message, append_keyword: true)
+      private def add_error(keyword, message = nil, append_keyword: true)
         @error_count += 1
         if @error_callback
           schema_keyword = append_keyword ? keyword : MISSING_SEGMENT
@@ -811,7 +818,7 @@ module Schemurai
               keyword: keyword,
               instance_path: pointer(@instance_path),
               schema_path: pointer(@schema_path, schema_keyword),
-              message: message
+              message: message || yield
             )
           )
         end

data/lib/schemurai/meta_schemas/draft2019_09.rb

@@ -13,8 +13,47 @@ module Schemurai
           "$recursiveAnchor" => true,
           "type" => ["object", "boolean"],
           "properties" => {
+            "$id" => {"type" => "string"},
+            "$schema" => {"type" => "string"},
+            "$ref" => {"type" => "string"},
+            "$anchor" => {"type" => "string", "pattern" => "^[A-Za-z][-A-Za-z0-9.:_]*$"},
+            "$recursiveRef" => {"type" => "string"},
+            "$recursiveAnchor" => {"type" => "boolean"},
+            "$vocabulary" => {"type" => "object", "additionalProperties" => {"type" => "boolean"}},
+            "$comment" => {"type" => "string"},
             "$defs" => {"type" => "object", "additionalProperties" => {"$recursiveRef" => "#"}},
             "definitions" => {"type" => "object", "additionalProperties" => {"$recursiveRef" => "#"}},
+            "items" => {
+              "anyOf" => [
+                {"$recursiveRef" => "#"},
+                {"type" => "array", "minItems" => 1, "items" => {"$recursiveRef" => "#"}}
+              ]
+            },
+            "additionalItems" => {"$recursiveRef" => "#"},
+            "contains" => {"$recursiveRef" => "#"},
+            "additionalProperties" => {"$recursiveRef" => "#"},
+            "unevaluatedItems" => {"$recursiveRef" => "#"},
+            "unevaluatedProperties" => {"$recursiveRef" => "#"},
+            "properties" => {"type" => "object", "additionalProperties" => {"$recursiveRef" => "#"}},
+            "patternProperties" => {"type" => "object", "additionalProperties" => {"$recursiveRef" => "#"}},
+            "dependentSchemas" => {"type" => "object", "additionalProperties" => {"$recursiveRef" => "#"}},
+            "dependencies" => {
+              "type" => "object",
+              "additionalProperties" => {
+                "anyOf" => [
+                  {"$recursiveRef" => "#"},
+                  {"type" => "array", "items" => {"type" => "string"}, "uniqueItems" => true}
+                ]
+              }
+            },
+            "propertyNames" => {"$recursiveRef" => "#"},
+            "if" => {"$recursiveRef" => "#"},
+            "then" => {"$recursiveRef" => "#"},
+            "else" => {"$recursiveRef" => "#"},
+            "allOf" => {"type" => "array", "minItems" => 1, "items" => {"$recursiveRef" => "#"}},
+            "anyOf" => {"type" => "array", "minItems" => 1, "items" => {"$recursiveRef" => "#"}},
+            "oneOf" => {"type" => "array", "minItems" => 1, "items" => {"$recursiveRef" => "#"}},
+            "not" => {"$recursiveRef" => "#"},
             "type" => {
               "anyOf" => [
                 {"enum" => ["null", "boolean", "object", "array", "number", "integer", "string"]},
@@ -26,20 +65,82 @@ module Schemurai
                 }
               ]
             },
+            "enum" => {"type" => "array"},
+            "multipleOf" => {"type" => "number", "exclusiveMinimum" => 0},
+            "maximum" => {"type" => "number"},
+            "exclusiveMaximum" => {"type" => "number"},
+            "minimum" => {"type" => "number"},
+            "exclusiveMinimum" => {"type" => "number"},
             "minLength" => {"type" => "integer", "minimum" => 0},
             "maxLength" => {"type" => "integer", "minimum" => 0},
+            "pattern" => {"type" => "string"},
             "minItems" => {"type" => "integer", "minimum" => 0},
             "maxItems" => {"type" => "integer", "minimum" => 0},
+            "uniqueItems" => {"type" => "boolean"},
             "minContains" => {"type" => "integer", "minimum" => 0},
             "maxContains" => {"type" => "integer", "minimum" => 0},
             "minProperties" => {"type" => "integer", "minimum" => 0},
-            "maxProperties" => {"type" => "integer", "minimum" => 0}
+            "maxProperties" => {"type" => "integer", "minimum" => 0},
+            "required" => {
+              "type" => "array",
+              "items" => {"type" => "string"},
+              "uniqueItems" => true
+            },
+            "dependentRequired" => {
+              "type" => "object",
+              "additionalProperties" => {
+                "type" => "array",
+                "items" => {"type" => "string"},
+                "uniqueItems" => true
+              }
+            },
+            "title" => {"type" => "string"},
+            "description" => {"type" => "string"},
+            "deprecated" => {"type" => "boolean"},
+            "readOnly" => {"type" => "boolean"},
+            "writeOnly" => {"type" => "boolean"},
+            "examples" => {"type" => "array"},
+            "format" => {"type" => "string"},
+            "contentEncoding" => {"type" => "string"},
+            "contentMediaType" => {"type" => "string"},
+            "contentSchema" => {"$recursiveRef" => "#"}
           }
         }.freeze
 
         MetaSchemas.register(META_SCHEMA_URI, SCHEMA)
 
-        private_constant :META_SCHEMA_URI, :SCHEMA
+        COMPONENT_KEYWORDS = {
+          "core" => %w[
+            $id $schema $ref $anchor $recursiveRef $recursiveAnchor $vocabulary $comment $defs
+          ],
+          "applicator" => %w[
+            additionalItems unevaluatedItems items contains additionalProperties
+            unevaluatedProperties properties patternProperties dependentSchemas propertyNames
+            if then else allOf anyOf oneOf not
+          ],
+          "validation" => %w[
+            type const enum multipleOf maximum exclusiveMaximum minimum exclusiveMinimum
+            maxLength minLength pattern maxItems minItems uniqueItems maxContains minContains
+            maxProperties minProperties required dependentRequired
+          ],
+          "meta-data" => %w[title description default deprecated readOnly writeOnly examples],
+          "format" => %w[format],
+          "content" => %w[contentEncoding contentMediaType contentSchema]
+        }.freeze
+
+        COMPONENT_KEYWORDS.each do |name, keywords|
+          uri = "https://json-schema.org/draft/2019-09/meta/#{name}"
+          component = {
+            "$schema" => META_SCHEMA_URI,
+            "$id" => uri,
+            "$recursiveAnchor" => true,
+            "type" => ["object", "boolean"],
+            "properties" => SCHEMA.fetch("properties").slice(*keywords)
+          }.freeze
+          MetaSchemas.register(uri, component)
+        end
+
+        private_constant :META_SCHEMA_URI, :SCHEMA, :COMPONENT_KEYWORDS
       end
     end
   end