json_schemer 1.0.3 → 2.4.0

data/lib/json_schemer/draft202012/vocab/unevaluated.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+module JSONSchemer
+  module Draft202012
+    module Vocab
+      module Unevaluated
+        class UnevaluatedItems < Keyword
+          def error(formatted_instance_location:, **)
+            "array items at #{formatted_instance_location} do not match `unevaluatedItems` schema"
+          end
+
+          def false_schema_error(formatted_instance_location:, **)
+            "array item at #{formatted_instance_location} is a disallowed unevaluated item"
+          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, 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, unevaluated_items)
+            case result.source
+            when Applicator::PrefixItems
+              unevaluated_items.subtract(0..result.annotation)
+            when Applicator::Items, UnevaluatedItems
+              unevaluated_items.clear if result.annotation
+            when Applicator::Contains
+              unevaluated_items.subtract(result.annotation)
+            end
+            result.nested&.each do |subresult|
+              if subresult.valid && subresult.instance_location == result.instance_location
+                collect_unevaluated_items(subresult, unevaluated_items)
+              end
+            end
+          end
+        end
+
+        class UnevaluatedProperties < Keyword
+          def error(formatted_instance_location:, **)
+            "object properties at #{formatted_instance_location} do not match `unevaluatedProperties` schema"
+          end
+
+          def false_schema_error(formatted_instance_location:, **)
+            "object property at #{formatted_instance_location} is a disallowed unevaluated property"
+          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?(Hash)
+
+            evaluated_keys = Set[]
+
+            context.adjacent_results.each_value do |adjacent_result|
+              collect_evaluated_keys(adjacent_result, evaluated_keys)
+            end
+
+            evaluated = instance.reject do |key, _value|
+              evaluated_keys.include?(key)
+            end
+
+            nested = evaluated.map do |key, value|
+              parsed.validate_instance(value, join_location(instance_location, key), keyword_location, context)
+            end
+
+            result(instance, instance_location, keyword_location, nested.all?(&:valid), nested, :annotation => evaluated.keys)
+          end
+
+        private
+
+          def collect_evaluated_keys(result, evaluated_keys)
+            case result.source
+            when Applicator::Properties, Applicator::PatternProperties, Applicator::AdditionalProperties, UnevaluatedProperties
+              evaluated_keys.merge(result.annotation)
+            end
+            result.nested&.each do |subresult|
+              if subresult.valid && subresult.instance_location == result.instance_location
+                collect_evaluated_keys(subresult, evaluated_keys)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/json_schemer/draft202012/vocab/validation.rb

@@ -0,0 +1,290 @@
+# frozen_string_literal: true
+module JSONSchemer
+  module Draft202012
+    module Vocab
+      module Validation
+        class Type < Keyword
+          def self.valid_integer?(instance)
+            instance.is_a?(Numeric) && (instance.is_a?(Integer) || instance.floor == instance)
+          end
+
+          def error(formatted_instance_location:, **)
+            case value
+            when 'null'
+              "value at #{formatted_instance_location} is not null"
+            when 'boolean'
+              "value at #{formatted_instance_location} is not a boolean"
+            when 'number'
+              "value at #{formatted_instance_location} is not a number"
+            when 'integer'
+              "value at #{formatted_instance_location} is not an integer"
+            when 'string'
+              "value at #{formatted_instance_location} is not a string"
+            when 'array'
+              "value at #{formatted_instance_location} is not an array"
+            when 'object'
+              "value at #{formatted_instance_location} is not an object"
+            else
+              "value at #{formatted_instance_location} is not one of the types: #{value}"
+            end
+          end
+
+          def validate(instance, instance_location, keyword_location, _context)
+            case parsed
+            when String
+              result(instance, instance_location, keyword_location, valid_type(parsed, instance), :type => parsed)
+            when Array
+              result(instance, instance_location, keyword_location, parsed.any? { |type| valid_type(type, instance) })
+            end
+          end
+
+        private
+
+          def valid_type(type, instance)
+            case type
+            when 'null'
+              instance.nil?
+            when 'boolean'
+              instance == true || instance == false
+            when 'number'
+              instance.is_a?(Numeric)
+            when 'integer'
+              self.class.valid_integer?(instance)
+            when 'string'
+              instance.is_a?(String)
+            when 'array'
+              instance.is_a?(Array)
+            when 'object'
+              instance.is_a?(Hash)
+            else
+              true
+            end
+          end
+        end
+
+        class Enum < Keyword
+          def error(formatted_instance_location:, **)
+            "value at #{formatted_instance_location} is not one of: #{value}"
+          end
+
+          def validate(instance, instance_location, keyword_location, _context)
+            result(instance, instance_location, keyword_location, !value || value.include?(instance))
+          end
+        end
+
+        class Const < Keyword
+          def error(formatted_instance_location:, **)
+            "value at #{formatted_instance_location} is not: #{value}"
+          end
+
+          def validate(instance, instance_location, keyword_location, _context)
+            result(instance, instance_location, keyword_location, value == instance)
+          end
+        end
+
+        class MultipleOf < Keyword
+          def error(formatted_instance_location:, **)
+            "number at #{formatted_instance_location} is not a multiple of: #{value}"
+          end
+
+          def validate(instance, instance_location, keyword_location, _context)
+            result(instance, instance_location, keyword_location, !instance.is_a?(Numeric) || BigDecimal(instance.to_s).modulo(value).zero?)
+          end
+        end
+
+        class Maximum < Keyword
+          def error(formatted_instance_location:, **)
+            "number at #{formatted_instance_location} is greater than: #{value}"
+          end
+
+          def validate(instance, instance_location, keyword_location, _context)
+            result(instance, instance_location, keyword_location, !instance.is_a?(Numeric) || instance <= value)
+          end
+        end
+
+        class ExclusiveMaximum < Keyword
+          def error(formatted_instance_location:, **)
+            "number at #{formatted_instance_location} is greater than or equal to: #{value}"
+          end
+
+          def validate(instance, instance_location, keyword_location, _context)
+            result(instance, instance_location, keyword_location, !instance.is_a?(Numeric) || instance < value)
+          end
+        end
+
+        class Minimum < Keyword
+          def error(formatted_instance_location:, **)
+            "number at #{formatted_instance_location} is less than: #{value}"
+          end
+
+          def validate(instance, instance_location, keyword_location, _context)
+            result(instance, instance_location, keyword_location, !instance.is_a?(Numeric) || instance >= value)
+          end
+        end
+
+        class ExclusiveMinimum < Keyword
+          def error(formatted_instance_location:, **)
+            "number at #{formatted_instance_location} is less than or equal to: #{value}"
+          end
+
+          def validate(instance, instance_location, keyword_location, _context)
+            result(instance, instance_location, keyword_location, !instance.is_a?(Numeric) || instance > value)
+          end
+        end
+
+        class MaxLength < Keyword
+          def error(formatted_instance_location:, **)
+            "string length at #{formatted_instance_location} is greater than: #{value}"
+          end
+
+          def validate(instance, instance_location, keyword_location, _context)
+            result(instance, instance_location, keyword_location, !instance.is_a?(String) || instance.size <= value)
+          end
+        end
+
+        class MinLength < Keyword
+          def error(formatted_instance_location:, **)
+            "string length at #{formatted_instance_location} is less than: #{value}"
+          end
+
+          def validate(instance, instance_location, keyword_location, _context)
+            result(instance, instance_location, keyword_location, !instance.is_a?(String) || instance.size >= value)
+          end
+        end
+
+        class Pattern < Keyword
+          def error(formatted_instance_location:, **)
+            "string at #{formatted_instance_location} does not match pattern: #{value}"
+          end
+
+          def parse
+            root.resolve_regexp(value)
+          end
+
+          def validate(instance, instance_location, keyword_location, _context)
+            result(instance, instance_location, keyword_location, !instance.is_a?(String) || parsed.match?(instance))
+          end
+        end
+
+        class MaxItems < Keyword
+          def error(formatted_instance_location:, **)
+            "array size at #{formatted_instance_location} is greater than: #{value}"
+          end
+
+          def validate(instance, instance_location, keyword_location, _context)
+            result(instance, instance_location, keyword_location, !instance.is_a?(Array) || instance.size <= value)
+          end
+        end
+
+        class MinItems < Keyword
+          def error(formatted_instance_location:, **)
+            "array size at #{formatted_instance_location} is less than: #{value}"
+          end
+
+          def validate(instance, instance_location, keyword_location, _context)
+            result(instance, instance_location, keyword_location, !instance.is_a?(Array) || instance.size >= value)
+          end
+        end
+
+        class UniqueItems < Keyword
+          def error(formatted_instance_location:, **)
+            "array items at #{formatted_instance_location} are not unique"
+          end
+
+          def validate(instance, instance_location, keyword_location, _context)
+            result(instance, instance_location, keyword_location, !instance.is_a?(Array) || value == false || instance.size == instance.uniq.size)
+          end
+        end
+
+        class MaxContains < Keyword
+          def error(formatted_instance_location:, **)
+            "number of array items at #{formatted_instance_location} matching `contains` schema is greater than: #{value}"
+          end
+
+          def validate(instance, instance_location, keyword_location, context)
+            return result(instance, instance_location, keyword_location, true) unless instance.is_a?(Array) && context.adjacent_results.key?(Applicator::Contains)
+            evaluated_items = context.adjacent_results.fetch(Applicator::Contains).annotation
+            result(instance, instance_location, keyword_location, evaluated_items.size <= value)
+          end
+        end
+
+        class MinContains < Keyword
+          def error(formatted_instance_location:, **)
+            "number of array items at #{formatted_instance_location} matching `contains` schema is less than: #{value}"
+          end
+
+          def validate(instance, instance_location, keyword_location, context)
+            return result(instance, instance_location, keyword_location, true) unless instance.is_a?(Array) && context.adjacent_results.key?(Applicator::Contains)
+            evaluated_items = context.adjacent_results.fetch(Applicator::Contains).annotation
+            result(instance, instance_location, keyword_location, evaluated_items.size >= value)
+          end
+        end
+
+        class MaxProperties < Keyword
+          def error(formatted_instance_location:, **)
+            "object size at #{formatted_instance_location} is greater than: #{value}"
+          end
+
+          def validate(instance, instance_location, keyword_location, _context)
+            result(instance, instance_location, keyword_location, !instance.is_a?(Hash) || instance.size <= value)
+          end
+        end
+
+        class MinProperties < Keyword
+          def error(formatted_instance_location:, **)
+            "object size at #{formatted_instance_location} is less than: #{value}"
+          end
+
+          def validate(instance, instance_location, keyword_location, _context)
+            result(instance, instance_location, keyword_location, !instance.is_a?(Hash) || instance.size >= value)
+          end
+        end
+
+        class Required < Keyword
+          def error(formatted_instance_location:, details:, **)
+            "object at #{formatted_instance_location} is missing required properties: #{details.fetch('missing_keys').join(', ')}"
+          end
+
+          def validate(instance, instance_location, keyword_location, context)
+            return result(instance, instance_location, keyword_location, true) unless instance.is_a?(Hash)
+
+            required_keys = value
+
+            if context.access_mode && schema.parsed.key?('properties')
+              inapplicable_access_mode_keys = []
+              schema.parsed.fetch('properties').parsed.each do |property, subschema|
+                read_only, write_only = subschema.parsed.values_at('readOnly', 'writeOnly')
+                inapplicable_access_mode_keys << property if context.access_mode == 'write' && read_only&.parsed == true
+                inapplicable_access_mode_keys << property if context.access_mode == 'read' && write_only&.parsed == true
+              end
+              required_keys -= inapplicable_access_mode_keys
+            end
+
+            missing_keys = required_keys - instance.keys
+            result(instance, instance_location, keyword_location, missing_keys.none?, :details => { 'missing_keys' => missing_keys })
+          end
+        end
+
+        class DependentRequired < Keyword
+          def error(formatted_instance_location:, **)
+            "object at #{formatted_instance_location} is missing required `dependentRequired` properties"
+          end
+
+          def validate(instance, instance_location, keyword_location, _context)
+            return result(instance, instance_location, keyword_location, true) unless instance.is_a?(Hash)
+
+            existing_keys = instance.keys
+
+            nested = value.select do |key, _required_keys|
+              instance.key?(key)
+            end.map do |key, required_keys|
+              result(instance, join_location(instance_location, key), join_location(keyword_location, key), (required_keys - existing_keys).none?)
+            end
+
+            result(instance, instance_location, keyword_location, nested.all?(&:valid), nested)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/json_schemer/draft202012/vocab.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+module JSONSchemer
+  module Draft202012
+    module Vocab
+      # https://datatracker.ietf.org/doc/html/draft-bhutton-json-schema-01#section-8
+      CORE = {
+        # https://datatracker.ietf.org/doc/html/draft-bhutton-json-schema-01#section-8.1
+        '$schema' => Core::Schema,
+        '$vocabulary' => Core::Vocabulary,
+        # https://datatracker.ietf.org/doc/html/draft-bhutton-json-schema-01#section-8.2
+        '$id' => Core::Id,
+        '$anchor' => Core::Anchor,
+        '$ref' => Core::Ref,
+        '$dynamicAnchor' => Core::DynamicAnchor,
+        '$dynamicRef' => Core::DynamicRef,
+        '$defs' => Core::Defs,
+        'definitions' => Core::Defs,
+        # https://datatracker.ietf.org/doc/html/draft-bhutton-json-schema-01#section-8.3
+        '$comment' => Core::Comment,
+        # https://github.com/orgs/json-schema-org/discussions/329
+        'x-error' => Core::XError
+      }
+      # https://datatracker.ietf.org/doc/html/draft-bhutton-json-schema-01#section-10
+      APPLICATOR = {
+        # https://datatracker.ietf.org/doc/html/draft-bhutton-json-schema-01#section-10.2
+        'allOf' => Applicator::AllOf,
+        'anyOf' => Applicator::AnyOf,
+        'oneOf' => Applicator::OneOf,
+        'not' => Applicator::Not,
+        # https://datatracker.ietf.org/doc/html/draft-bhutton-json-schema-01#section-10.2.2
+        'if' => Applicator::If,
+        'then' => Applicator::Then,
+        'else' => Applicator::Else,
+        'dependentSchemas' => Applicator::DependentSchemas,
+        # https://datatracker.ietf.org/doc/html/draft-bhutton-json-schema-01#section-10.3
+        'prefixItems' => Applicator::PrefixItems,
+        'items' => Applicator::Items,
+        'contains' => Applicator::Contains,
+        # https://datatracker.ietf.org/doc/html/draft-bhutton-json-schema-01#section-10.3.2
+        'properties' => Applicator::Properties,
+        'patternProperties' => Applicator::PatternProperties,
+        'additionalProperties' => Applicator::AdditionalProperties,
+        'propertyNames' => Applicator::PropertyNames,
+        'dependencies' => Applicator::Dependencies
+      }
+      # https://datatracker.ietf.org/doc/html/draft-bhutton-json-schema-01#section-11
+      UNEVALUATED = {
+        'unevaluatedItems' => Unevaluated::UnevaluatedItems,
+        'unevaluatedProperties' => Unevaluated::UnevaluatedProperties
+      }
+      # https://datatracker.ietf.org/doc/html/draft-bhutton-json-schema-validation-01#section-6
+      VALIDATION = {
+        # https://datatracker.ietf.org/doc/html/draft-bhutton-json-schema-validation-01#section-6.1
+        'type' => Validation::Type,
+        'enum' => Validation::Enum,
+        'const' => Validation::Const,
+        # https://datatracker.ietf.org/doc/html/draft-bhutton-json-schema-validation-01#section-6.2
+        'multipleOf' => Validation::MultipleOf,
+        'maximum' => Validation::Maximum,
+        'exclusiveMaximum' => Validation::ExclusiveMaximum,
+        'minimum' => Validation::Minimum,
+        'exclusiveMinimum' => Validation::ExclusiveMinimum,
+        # https://datatracker.ietf.org/doc/html/draft-bhutton-json-schema-validation-01#section-6.3
+        'maxLength' => Validation::MaxLength,
+        'minLength' => Validation::MinLength,
+        'pattern' => Validation::Pattern,
+        # https://datatracker.ietf.org/doc/html/draft-bhutton-json-schema-validation-01#section-6.4
+        'maxItems' => Validation::MaxItems,
+        'minItems' => Validation::MinItems,
+        'uniqueItems' => Validation::UniqueItems,
+        'maxContains' => Validation::MaxContains,
+        'minContains' => Validation::MinContains,
+        # https://datatracker.ietf.org/doc/html/draft-bhutton-json-schema-validation-01#section-6.5
+        'maxProperties' => Validation::MaxProperties,
+        'minProperties' => Validation::MinProperties,
+        'required' => Validation::Required,
+        'dependentRequired' => Validation::DependentRequired
+      }
+      # https://datatracker.ietf.org/doc/html/draft-bhutton-json-schema-validation-01#section-7.2.1
+      FORMAT_ANNOTATION = {
+        'format' => FormatAnnotation::Format
+      }
+      # https://datatracker.ietf.org/doc/html/draft-bhutton-json-schema-validation-01#section-7.2.2
+      FORMAT_ASSERTION = {
+        'format' => FormatAssertion::Format
+      }
+      # https://datatracker.ietf.org/doc/html/draft-bhutton-json-schema-validation-01#section-8
+      CONTENT = {
+        'contentEncoding' => Content::ContentEncoding,
+        'contentMediaType' => Content::ContentMediaType,
+        'contentSchema' => Content::ContentSchema
+      }
+      # https://datatracker.ietf.org/doc/html/draft-bhutton-json-schema-validation-01#section-9
+      META_DATA = {
+        # 'title' => MetaData::Title,
+        # 'description' => MetaData::Description,
+        # 'default' => MetaData::Default,
+        # 'deprecated' => MetaData::Deprecated,
+        'readOnly' => MetaData::ReadOnly,
+        'writeOnly' => MetaData::WriteOnly,
+        # 'examples' => MetaData::Examples
+      }
+    end
+  end
+end

data/lib/json_schemer/draft4/meta.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+module JSONSchemer
+  module Draft4
+    BASE_URI = URI('http://json-schema.org/draft-04/schema#')
+    FORMATS = Draft6::FORMATS.dup
+    FORMATS.delete('uri-reference')
+    FORMATS.delete('uri-template')
+    FORMATS.delete('json-pointer')
+    CONTENT_ENCODINGS = Draft6::CONTENT_ENCODINGS
+    CONTENT_MEDIA_TYPES = Draft6::CONTENT_MEDIA_TYPES
+    SCHEMA = {
+      'id' => 'http://json-schema.org/draft-04/schema#',
+      '$schema' => 'http://json-schema.org/draft-04/schema#',
+      'description' => 'Core schema meta-schema',
+      'definitions' => {
+        'schemaArray' => {
+          'type' => 'array',
+          'minItems' => 1,
+          'items' => { '$ref' => '#' }
+        },
+        'positiveInteger' => {
+          'type' => 'integer',
+          'minimum' => 0
+        },
+        'positiveIntegerDefault0' => {
+          'allOf' => [ { '$ref' => '#/definitions/positiveInteger' }, { 'default' => 0 } ]
+        },
+        'simpleTypes' => {
+          'enum' => [ 'array', 'boolean', 'integer', 'null', 'number', 'object', 'string' ]
+        },
+        'stringArray' => {
+          'type' => 'array',
+          'items' => { 'type' => 'string' },
+          'minItems' => 1,
+          'uniqueItems' => true
+        }
+      },
+      'type' => 'object',
+      'properties' => {
+        'id' => {
+          'type' => 'string'
+        },
+        '$schema' => {
+          'type' => 'string'
+        },
+        'title' => {
+          'type' => 'string'
+        },
+        'description' => {
+          'type' => 'string'
+        },
+        'default' => {},
+        'multipleOf' => {
+          'type' => 'number',
+          'minimum' => 0,
+          'exclusiveMinimum' => true
+        },
+        'maximum' => {
+          'type' => 'number'
+        },
+        'exclusiveMaximum' => {
+          'type' => 'boolean',
+          'default' => false
+        },
+        'minimum' => {
+          'type' => 'number'
+        },
+        'exclusiveMinimum' => {
+          'type' => 'boolean',
+          'default' => false
+        },
+        'maxLength' => { '$ref' => '#/definitions/positiveInteger' },
+        'minLength' => { '$ref' => '#/definitions/positiveIntegerDefault0' },
+        'pattern' => {
+          'type' => 'string',
+          'format' => 'regex'
+        },
+        'additionalItems' => {
+          'anyOf' => [
+            { 'type' => 'boolean' },
+            { '$ref' => '#' }
+          ],
+          'default' => {}
+        },
+        'items' => {
+          'anyOf' => [
+            { '$ref' => '#' },
+            { '$ref' => '#/definitions/schemaArray' }
+          ],
+          'default' => {}
+        },
+        'maxItems' => { '$ref' => '#/definitions/positiveInteger' },
+        'minItems' => { '$ref' => '#/definitions/positiveIntegerDefault0' },
+        'uniqueItems' => {
+          'type' => 'boolean',
+          'default' => false
+        },
+        'maxProperties' => { '$ref' => '#/definitions/positiveInteger' },
+        'minProperties' => { '$ref' => '#/definitions/positiveIntegerDefault0' },
+        'required' => { '$ref' => '#/definitions/stringArray' },
+        'additionalProperties' => {
+          'anyOf' => [
+            { 'type' => 'boolean' },
+            { '$ref' => '#' }
+          ],
+          'default' => {}
+        },
+        'definitions' => {
+          'type' => 'object',
+          'additionalProperties' => { '$ref' => '#' },
+          'default' => {}
+        },
+        'properties' => {
+          'type' => 'object',
+          'additionalProperties' => { '$ref' => '#' },
+          'default' => {}
+        },
+        'patternProperties' => {
+          'type' => 'object',
+          'additionalProperties' => { '$ref' => '#' },
+          'default' => {}
+        },
+        'dependencies' => {
+          'type' => 'object',
+          'additionalProperties' => {
+            'anyOf' => [
+              { '$ref' => '#' },
+              { '$ref' => '#/definitions/stringArray' }
+            ]
+          }
+        },
+        'enum' => {
+          'type' => 'array',
+          'minItems' => 1,
+          'uniqueItems' => true
+        },
+        'type' => {
+          'anyOf' => [
+            { '$ref' => '#/definitions/simpleTypes' },
+            {
+              'type' => 'array',
+              'items' => { '$ref' => '#/definitions/simpleTypes' },
+              'minItems' => 1,
+              'uniqueItems' => true
+            }
+          ]
+        },
+        'format' => { 'type' => 'string' },
+        'allOf' => { '$ref' => '#/definitions/schemaArray' },
+        'anyOf' => { '$ref' => '#/definitions/schemaArray' },
+        'oneOf' => { '$ref' => '#/definitions/schemaArray' },
+        'not' => { '$ref' => '#' }
+      },
+      'dependencies' => {
+        'exclusiveMaximum' => [ 'maximum' ],
+        'exclusiveMinimum' => [ 'minimum' ]
+      },
+      'default' => {}
+    }
+  end
+end