json_schemer 1.0.3 → 2.1.0

data/lib/json_schemer/draft201909/meta.rb

@@ -0,0 +1,320 @@
+# frozen_string_literal: true
+module JSONSchemer
+  module Draft201909
+    BASE_URI = URI('https://json-schema.org/draft/2019-09/schema')
+    FORMATS = Draft202012::FORMATS
+    CONTENT_ENCODINGS = Draft202012::CONTENT_ENCODINGS
+    CONTENT_MEDIA_TYPES = Draft202012::CONTENT_MEDIA_TYPES
+    SCHEMA = {
+      '$schema' => 'https://json-schema.org/draft/2019-09/schema',
+      '$id' => 'https://json-schema.org/draft/2019-09/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
+      },
+      '$recursiveAnchor' => true,
+      'title' => 'Core and Validation specifications meta-schema',
+      'allOf' => [
+        {'$ref' => 'meta/core'},
+        {'$ref' => 'meta/applicator'},
+        {'$ref' => 'meta/validation'},
+        {'$ref' => 'meta/meta-data'},
+        {'$ref' => 'meta/format'},
+        {'$ref' => 'meta/content'}
+      ],
+      'type' => ['object', 'boolean'],
+      'properties' => {
+        'definitions' => {
+          '$comment' => 'While no longer an official keyword as it is replaced by $defs, this keyword is retained in the meta-schema to prevent incompatible extensions as it remains in common use.',
+          'type' => 'object',
+          'additionalProperties' => { '$recursiveRef' => '#' },
+          'default' => {}
+        },
+        'dependencies' => {
+          '$comment' => '"dependencies" is no longer a keyword, but schema authors should avoid redefining it to facilitate a smooth transition to "dependentSchemas" and "dependentRequired"',
+          'type' => 'object',
+          'additionalProperties' => {
+            'anyOf' => [
+              { '$recursiveRef' => '#' },
+              { '$ref' => 'meta/validation#/$defs/stringArray' }
+            ]
+          }
+        }
+      }
+    }
+
+    module Meta
+      CORE = {
+        '$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' => {}
+          }
+        }
+      }
+
+      APPLICATOR = {
+        '$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' => '#' }
+          }
+        }
+      }
+
+      VALIDATION = {
+        '$schema' => 'https://json-schema.org/draft/2019-09/schema',
+        '$id' => 'https://json-schema.org/draft/2019-09/meta/validation',
+        '$recursiveAnchor' => true,
+        'title' => 'Validation vocabulary meta-schema',
+        'type' => ['object', 'boolean'],
+        'properties' => {
+          'multipleOf' => {
+            'type' => 'number',
+            'exclusiveMinimum' => 0
+          },
+          'maximum' => {
+            'type' => 'number'
+          },
+          'exclusiveMaximum' => {
+            'type' => 'number'
+          },
+          'minimum' => {
+            'type' => 'number'
+          },
+          'exclusiveMinimum' => {
+            'type' => 'number'
+          },
+          'maxLength' => { '$ref' => '#/$defs/nonNegativeInteger' },
+          'minLength' => { '$ref' => '#/$defs/nonNegativeIntegerDefault0' },
+          'pattern' => {
+            'type' => 'string',
+            'format' => 'regex'
+          },
+          'maxItems' => { '$ref' => '#/$defs/nonNegativeInteger' },
+          'minItems' => { '$ref' => '#/$defs/nonNegativeIntegerDefault0' },
+          'uniqueItems' => {
+            'type' => 'boolean',
+            'default' => false
+          },
+          'maxContains' => { '$ref' => '#/$defs/nonNegativeInteger' },
+          'minContains' => {
+            '$ref' => '#/$defs/nonNegativeInteger',
+            'default' => 1
+          },
+          'maxProperties' => { '$ref' => '#/$defs/nonNegativeInteger' },
+          'minProperties' => { '$ref' => '#/$defs/nonNegativeIntegerDefault0' },
+          'required' => { '$ref' => '#/$defs/stringArray' },
+          'dependentRequired' => {
+            'type' => 'object',
+            'additionalProperties' => {
+              '$ref' => '#/$defs/stringArray'
+            }
+          },
+          'const' => true,
+          'enum' => {
+            'type' => 'array',
+            'items' => true
+          },
+          'type' => {
+            'anyOf' => [
+              { '$ref' => '#/$defs/simpleTypes' },
+              {
+                'type' => 'array',
+                'items' => { '$ref' => '#/$defs/simpleTypes' },
+                'minItems' => 1,
+                'uniqueItems' => true
+              }
+            ]
+          }
+        },
+        '$defs' => {
+          'nonNegativeInteger' => {
+            'type' => 'integer',
+            'minimum' => 0
+          },
+          'nonNegativeIntegerDefault0' => {
+            '$ref' => '#/$defs/nonNegativeInteger',
+            'default' => 0
+          },
+          'simpleTypes' => {
+            'enum' => [
+              'array',
+              'boolean',
+              'integer',
+              'null',
+              'number',
+              'object',
+              'string'
+            ]
+          },
+          'stringArray' => {
+            'type' => 'array',
+            'items' => { 'type' => 'string' },
+            'uniqueItems' => true,
+            'default' => []
+          }
+        }
+      }
+
+      META_DATA = {
+        '$schema' => 'https://json-schema.org/draft/2019-09/schema',
+        '$id' => 'https://json-schema.org/draft/2019-09/meta/meta-data',
+        '$recursiveAnchor' => true,
+        'title' => 'Meta-data vocabulary meta-schema',
+        'type' => ['object', 'boolean'],
+        'properties' => {
+          'title' => {
+            'type' => 'string'
+          },
+          'description' => {
+            'type' => 'string'
+          },
+          'default' => true,
+          'deprecated' => {
+            'type' => 'boolean',
+            'default' => false
+          },
+          'readOnly' => {
+            'type' => 'boolean',
+            'default' => false
+          },
+          'writeOnly' => {
+            'type' => 'boolean',
+            'default' => false
+          },
+          'examples' => {
+            'type' => 'array',
+            'items' => true
+          }
+        }
+      }
+
+      FORMAT = {
+        '$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' }
+        }
+      }
+
+      CONTENT = {
+        '$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' => '#' }
+        }
+      }
+
+      SCHEMAS = {
+        URI('https://json-schema.org/draft/2019-09/meta/core') => CORE,
+        URI('https://json-schema.org/draft/2019-09/meta/applicator') => APPLICATOR,
+        URI('https://json-schema.org/draft/2019-09/meta/validation') => VALIDATION,
+        URI('https://json-schema.org/draft/2019-09/meta/meta-data') => META_DATA,
+        URI('https://json-schema.org/draft/2019-09/meta/format') => FORMAT,
+        URI('https://json-schema.org/draft/2019-09/meta/content') => CONTENT
+      }
+    end
+  end
+end

data/lib/json_schemer/draft201909/vocab/applicator.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+module JSONSchemer
+  module Draft201909
+    module Vocab
+      module Applicator
+        class Items < Keyword
+          def error(formatted_instance_location:, **)
+            "array items at #{formatted_instance_location} do not match `items` schema(s)"
+          end
+
+          def parse
+            if value.is_a?(Array)
+              value.map.with_index do |subschema, index|
+                subschema(subschema, index.to_s)
+              end
+            else
+              subschema(value)
+            end
+          end
+
+          def validate(instance, instance_location, keyword_location, context)
+            return result(instance, instance_location, keyword_location, true) unless instance.is_a?(Array)
+
+            nested = if parsed.is_a?(Array)
+              instance.take(parsed.size).map.with_index do |item, index|
+                parsed.fetch(index).validate_instance(item, join_location(instance_location, index.to_s), join_location(keyword_location, index.to_s), context)
+              end
+            else
+              instance.map.with_index do |item, index|
+                parsed.validate_instance(item, join_location(instance_location, index.to_s), keyword_location, context)
+              end
+            end
+
+            result(instance, instance_location, keyword_location, nested.all?(&:valid), nested, :annotation => (nested.size - 1))
+          end
+        end
+
+        class AdditionalItems < Keyword
+          def error(formatted_instance_location:, **)
+            "array items at #{formatted_instance_location} do not match `additionalItems` schema"
+          end
+
+          def parse
+            subschema(value)
+          end
+
+          def validate(instance, instance_location, keyword_location, context)
+            return result(instance, instance_location, keyword_location, true) unless instance.is_a?(Array)
+
+            evaluated_index = context.adjacent_results[Items]&.annotation
+            offset = evaluated_index ? (evaluated_index + 1) : instance.size
+
+            nested = instance.slice(offset..-1).map.with_index do |item, index|
+              parsed.validate_instance(item, join_location(instance_location, (offset + index).to_s), keyword_location, context)
+            end
+
+            result(instance, instance_location, keyword_location, nested.all?(&:valid), nested, :annotation => nested.any?)
+          end
+        end
+
+        class UnevaluatedItems < Keyword
+          def error(formatted_instance_location:, **)
+            "array items at #{formatted_instance_location} do not match `unevaluatedItems` schema"
+          end
+
+          def parse
+            subschema(value)
+          end
+
+          def validate(instance, instance_location, keyword_location, context)
+            return result(instance, instance_location, keyword_location, true) unless instance.is_a?(Array)
+
+            unevaluated_items = instance.size.times.to_set
+
+            context.adjacent_results.each_value do |adjacent_result|
+              collect_unevaluated_items(adjacent_result, instance_location, unevaluated_items)
+            end
+
+            nested = unevaluated_items.map do |index|
+              parsed.validate_instance(instance.fetch(index), join_location(instance_location, index.to_s), keyword_location, context)
+            end
+
+            result(instance, instance_location, keyword_location, nested.all?(&:valid), nested, :annotation => nested.any?)
+          end
+
+        private
+
+          def collect_unevaluated_items(result, instance_location, unevaluated_items)
+            return unless result.valid && result.instance_location == instance_location
+            case result.source
+            when Items
+              unevaluated_items.subtract(0..result.annotation)
+            when AdditionalItems, UnevaluatedItems
+              unevaluated_items.clear if result.annotation
+            end
+            result.nested&.each do |nested_result|
+              collect_unevaluated_items(nested_result, instance_location, unevaluated_items)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/json_schemer/draft201909/vocab/core.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+module JSONSchemer
+  module Draft201909
+    module Vocab
+      module Core
+        class RecursiveAnchor < Keyword
+          def parse
+            root.resources[:dynamic][schema.base_uri] = schema if value == true
+            value
+          end
+        end
+
+        class RecursiveRef < Keyword
+          def ref_uri
+            @ref_uri ||= URI.join(schema.base_uri, value)
+          end
+
+          def ref_schema
+            @ref_schema ||= root.resolve_ref(ref_uri)
+          end
+
+          def recursive_anchor
+            return @recursive_anchor if defined?(@recursive_anchor)
+            @recursive_anchor = (ref_schema.parsed['$recursiveAnchor']&.parsed == true)
+          end
+
+          def validate(instance, instance_location, keyword_location, context)
+            schema = ref_schema
+
+            if recursive_anchor
+              context.dynamic_scope.each do |ancestor|
+                if ancestor.root.resources.fetch(:dynamic).key?(ancestor.base_uri)
+                  schema = ancestor.root.resources.fetch(:dynamic).fetch(ancestor.base_uri)
+                  break
+                end
+              end
+            end
+
+            schema.validate_instance(instance, instance_location, keyword_location, context)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/json_schemer/draft201909/vocab.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+module JSONSchemer
+  module Draft201909
+    module Vocab
+      CORE = Draft202012::Vocab::CORE.dup
+      CORE.delete('$dynamicAnchor')
+      CORE.delete('$dynamicRef')
+      CORE.merge!(
+        # https://datatracker.ietf.org/doc/html/draft-handrews-json-schema-02#section-8.2.4.2
+        '$recursiveAnchor' => Core::RecursiveAnchor,
+        '$recursiveRef' => Core::RecursiveRef
+      )
+
+      APPLICATOR = Draft202012::Vocab::APPLICATOR.dup
+      APPLICATOR.delete('prefixItems')
+      APPLICATOR.merge!(
+        # https://datatracker.ietf.org/doc/html/draft-handrews-json-schema-02#section-9.3.1
+        'items' => Applicator::Items,
+        'additionalItems' => Applicator::AdditionalItems,
+        'unevaluatedItems' => Applicator::UnevaluatedItems,
+        # https://datatracker.ietf.org/doc/html/draft-handrews-json-schema-02#section-9.3.2.4
+        'unevaluatedProperties' => Draft202012::Vocab::Unevaluated::UnevaluatedProperties
+      )
+
+      VALIDATION = Draft202012::Vocab::VALIDATION
+      FORMAT = Draft202012::Vocab::FORMAT_ANNOTATION
+      CONTENT = Draft202012::Vocab::CONTENT
+      META_DATA = Draft202012::Vocab::META_DATA
+    end
+  end
+end