json_schemer 0.2.18 → 2.1.1

data/exe/json_schemer

@@ -0,0 +1,62 @@
+#!/usr/bin/env ruby
+
+require 'json'
+require 'optparse'
+require 'pathname'
+require 'json_schemer'
+
+parser = OptionParser.new('Usage:', 32, '  ')
+parser.separator("  #{parser.program_name} [options] <schema> <data>...")
+parser.separator("  #{parser.program_name} [options] <schema> -")
+parser.separator("  #{parser.program_name} [options] - <data>...")
+parser.separator("  #{parser.program_name} -h | --help")
+parser.separator("  #{parser.program_name} --version")
+parser.separator('')
+parser.separator('Options:')
+parser.on('-e', '--errors MAX', Integer, 'Maximum number of errors to output', 'Use "0" to validate with no output')
+parser.on_tail('-h', '--help', 'Show help')
+parser.on_tail('-v', '--version', 'Show version')
+
+options = {}
+parser.parse!(:into => options)
+
+if options[:help]
+  $stdout.puts(parser)
+  exit
+end
+
+if options[:version]
+  $stdout.puts("#{parser.program_name} #{JSONSchemer::VERSION}")
+  exit
+end
+
+if ARGV.size == 0
+  $stderr.puts("#{parser.program_name}: no schema or data")
+  exit(false)
+end
+
+if ARGV.size == 1
+  $stderr.puts("#{parser.program_name}: no data")
+  exit(false)
+end
+
+if ARGV.count('-') > 1
+  $stderr.puts("#{parser.program_name}: multiple stdin")
+  exit(false)
+end
+
+errors = 0
+schema = ARGF.file.is_a?(File) ? Pathname.new(ARGF.file.path) : ARGF.file.read
+schemer = JSONSchemer.schema(schema)
+
+while ARGV.any?
+  data = JSON.parse(ARGF.skip.file.read)
+  schemer.validate(data).each do |error|
+    exit(false) if options[:errors] == 0
+    errors += 1
+    $stdout.puts(JSON.generate(error))
+    exit(false) if options[:errors] == errors
+  end
+end
+
+exit(errors.zero?)

data/json_schemer.gemspec

@@ -9,7 +9,7 @@ Gem::Specification.new do |spec|
   spec.authors       = ["David Harsha"]
   spec.email         = ["davishmcclurg@gmail.com"]
 
-  spec.summary       = "JSON Schema validator. Supports drafts 4, 6, and 7."
+  spec.summary       = "JSON Schema validator. Supports drafts 4, 6, 7, 2019-09, 2020-12, OpenAPI 3.0, and OpenAPI 3.1."
   spec.homepage      = "https://github.com/davishmcclurg/json_schemer"
   spec.license       = "MIT"
 
@@ -20,22 +20,16 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.required_ruby_version = '>= 2.4'
+  spec.required_ruby_version = '>= 2.5'
 
   spec.add_development_dependency "bundler", "~> 2.0"
   spec.add_development_dependency "rake", "~> 13.0"
   spec.add_development_dependency "minitest", "~> 5.0"
+  spec.add_development_dependency "simplecov", "~> 0.22"
+  spec.add_development_dependency "i18n"
+  spec.add_development_dependency "i18n-debug"
 
-  # spec.add_development_dependency "benchmark-ips", "~> 2.7.2"
-  # spec.add_development_dependency "jschema", "~> 0.2.1"
-  # spec.add_development_dependency "json-schema", "~> 2.8.0"
-  # spec.add_development_dependency "json_schema", "~> 0.17.0"
-  # spec.add_development_dependency "json_validation", "~> 0.1.0"
-  # spec.add_development_dependency "jsonschema", "~> 2.0.2"
-  # spec.add_development_dependency "rj_schema", "~> 0.2.0"
-
-  spec.add_runtime_dependency "ecma-re-validator", "~> 0.3"
   spec.add_runtime_dependency "hana", "~> 1.3"
-  spec.add_runtime_dependency "uri_template", "~> 0.7"
   spec.add_runtime_dependency "regexp_parser", "~> 2.0"
+  spec.add_runtime_dependency "simpleidn", "~> 0.2"
 end

data/lib/json_schemer/cached_resolver.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+module JSONSchemer
+  class CachedResolver
+    def initialize(&resolver)
+      @resolver = resolver
+      @cache = {}
+    end
+
+    def call(*args)
+      @cache[args] = @resolver.call(*args) unless @cache.key?(args)
+      @cache[args]
+    end
+  end
+
+  class CachedRefResolver < CachedResolver; end
+end

data/lib/json_schemer/content.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+module JSONSchemer
+  module ContentEncoding
+    BASE64 = proc do |instance|
+      [true, Base64.strict_decode64(instance)]
+    rescue
+      [false, nil]
+    end
+  end
+
+  module ContentMediaType
+    JSON = proc do |instance|
+      [true, ::JSON.parse(instance)]
+    rescue
+      [false, nil]
+    end
+  end
+end

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