json_schemer 1.0.3 → 2.0.0

data/lib/json_schemer/openapi31/meta.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+module JSONSchemer
+  module OpenAPI31
+    BASE_URI = URI('https://spec.openapis.org/oas/3.1/dialect/base')
+    SCHEMA = {
+      '$id' => 'https://spec.openapis.org/oas/3.1/dialect/base',
+      '$schema' => 'https://json-schema.org/draft/2020-12/schema',
+
+      'title' => 'OpenAPI 3.1 Schema Object Dialect',
+      'description' => 'A JSON Schema dialect describing schemas found in OpenAPI documents',
+
+      '$vocabulary' => {
+        'https://json-schema.org/draft/2020-12/vocab/core' => true,
+        'https://json-schema.org/draft/2020-12/vocab/applicator' => true,
+        'https://json-schema.org/draft/2020-12/vocab/unevaluated' => true,
+        'https://json-schema.org/draft/2020-12/vocab/validation' => true,
+        'https://json-schema.org/draft/2020-12/vocab/meta-data' => true,
+        'https://json-schema.org/draft/2020-12/vocab/format-annotation' => true,
+        'https://json-schema.org/draft/2020-12/vocab/content' => true,
+        'https://spec.openapis.org/oas/3.1/vocab/base' => false
+      },
+
+      '$dynamicAnchor' => 'meta',
+
+      'allOf' => [
+        { '$ref' => 'https://json-schema.org/draft/2020-12/schema' },
+        { '$ref' => 'https://spec.openapis.org/oas/3.1/meta/base' }
+      ]
+    }
+
+
+    module Meta
+      BASE = {
+        '$id' => 'https://spec.openapis.org/oas/3.1/meta/base',
+        '$schema' => 'https://json-schema.org/draft/2020-12/schema',
+
+        'title' => 'OAS Base vocabulary',
+        'description' => 'A JSON Schema Vocabulary used in the OpenAPI Schema Dialect',
+
+        '$vocabulary' => {
+          'https://spec.openapis.org/oas/3.1/vocab/base' => true
+        },
+
+        '$dynamicAnchor' => 'meta',
+
+        'type' => ['object', 'boolean'],
+        'properties' => {
+          'example' => true,
+          'discriminator' => { '$ref' => '#/$defs/discriminator' },
+          'externalDocs' => { '$ref' => '#/$defs/external-docs' },
+          'xml' => { '$ref' => '#/$defs/xml' }
+        },
+
+        '$defs' => {
+          'extensible' => {
+            'patternProperties' => {
+              '^x-' => true
+            }
+          },
+
+          'discriminator' => {
+            '$ref' => '#/$defs/extensible',
+            'type' => 'object',
+            'properties' => {
+              'propertyName' => {
+                'type' => 'string'
+              },
+              'mapping' => {
+                'type' => 'object',
+                'additionalProperties' => {
+                  'type' => 'string'
+                }
+              }
+            },
+            'required' => ['propertyName'],
+            'unevaluatedProperties' => false
+          },
+
+          'external-docs' => {
+            '$ref' => '#/$defs/extensible',
+            'type' => 'object',
+            'properties' => {
+              'url' => {
+                'type' => 'string',
+                'format' => 'uri-reference'
+              },
+              'description' => {
+                'type' => 'string'
+              }
+            },
+            'required' => ['url'],
+            'unevaluatedProperties' => false
+          },
+
+          'xml' => {
+            '$ref' => '#/$defs/extensible',
+            'type' => 'object',
+            'properties' => {
+              'name' => {
+                'type' => 'string'
+              },
+              'namespace' => {
+                'type' => 'string',
+                'format' => 'uri'
+              },
+              'prefix' => {
+                'type' => 'string'
+              },
+              'attribute' => {
+                'type' => 'boolean'
+              },
+              'wrapped' => {
+                'type' => 'boolean'
+              }
+            },
+            'unevaluatedProperties' => false
+          }
+        }
+      }
+
+
+      SCHEMAS = Draft202012::Meta::SCHEMAS.merge(
+        Draft202012::BASE_URI => Draft202012::SCHEMA,
+        URI('https://spec.openapis.org/oas/3.1/meta/base') => BASE
+      )
+    end
+  end
+end

data/lib/json_schemer/openapi31/vocab/base.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+module JSONSchemer
+  module OpenAPI31
+    module Vocab
+      module Base
+        class AllOf < Draft202012::Vocab::Applicator::AllOf
+          attr_accessor :skip_ref_once
+
+          def validate(instance, instance_location, keyword_location, context)
+            nested = []
+            parsed.each_with_index do |subschema, index|
+              if ref_schema = subschema.parsed['$ref']&.ref_schema
+                next if skip_ref_once == ref_schema.absolute_keyword_location
+                ref_schema.parsed['discriminator']&.skip_ref_once = schema.absolute_keyword_location
+              end
+              nested << subschema.validate_instance(instance, instance_location, join_location(keyword_location, index.to_s), context)
+            end
+            result(instance, instance_location, keyword_location, nested.all?(&:valid), nested)
+          ensure
+            self.skip_ref_once = nil
+          end
+        end
+
+        class AnyOf < Draft202012::Vocab::Applicator::AnyOf
+          def validate(*)
+            schema.parsed.key?('discriminator') ? nil : super
+          end
+        end
+
+        class OneOf < Draft202012::Vocab::Applicator::OneOf
+          def validate(*)
+            schema.parsed.key?('discriminator') ? nil : super
+          end
+        end
+
+        class Discriminator < Keyword
+          include Format::JSONPointer
+
+          attr_accessor :skip_ref_once
+
+          def error(formatted_instance_location:, **)
+            "value at #{formatted_instance_location} does not match `discriminator` schema"
+          end
+
+          def validate(instance, instance_location, keyword_location, context)
+            property_name = value.fetch('propertyName')
+            mapping = value['mapping'] || {}
+
+            return result(instance, instance_location, keyword_location, true) unless instance.is_a?(Hash) && instance.key?(property_name)
+
+            property = instance.fetch(property_name)
+            ref = mapping.fetch(property, property)
+
+            ref_schema = nil
+            unless ref.start_with?('#') && valid_json_pointer?(ref.delete_prefix('#'))
+              ref_schema = begin
+                root.resolve_ref(URI.join(schema.base_uri, "#/components/schemas/#{ref}"))
+              rescue InvalidRefPointer
+                nil
+              end
+            end
+            ref_schema ||= root.resolve_ref(URI.join(schema.base_uri, ref))
+
+            return if skip_ref_once == ref_schema.absolute_keyword_location
+
+            nested = []
+
+            if schema.parsed.key?('anyOf') || schema.parsed.key?('oneOf')
+              subschemas = schema.parsed['anyOf']&.parsed || []
+              subschemas += schema.parsed['oneOf']&.parsed || []
+              subschemas.each do |subschema|
+                if subschema.parsed.fetch('$ref').ref_schema.absolute_keyword_location == ref_schema.absolute_keyword_location
+                  nested << subschema.validate_instance(instance, instance_location, keyword_location, context)
+                end
+              end
+            else
+              ref_schema.parsed['allOf']&.skip_ref_once = schema.absolute_keyword_location
+              nested << ref_schema.validate_instance(instance, instance_location, keyword_location, context)
+            end
+
+            result(instance, instance_location, keyword_location, (nested.any? && nested.all?(&:valid)), nested)
+          ensure
+            self.skip_ref_once = nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/json_schemer/openapi31/vocab.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+module JSONSchemer
+  module OpenAPI31
+    module Vocab
+      # https://spec.openapis.org/oas/latest.html#schema-object
+      BASE = {
+        # https://spec.openapis.org/oas/latest.html#discriminator-object
+        'discriminator' => Base::Discriminator,
+        'allOf' => Base::AllOf,
+        'anyOf' => Base::AnyOf,
+        'oneOf' => Base::OneOf
+        # 'xml' => Base::Xml,
+        # 'externalDocs' => Base::ExternalDocs,
+        # 'example' => Base::Example
+      }
+    end
+  end
+end

data/lib/json_schemer/output.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+module JSONSchemer
+  module Output
+    FRAGMENT_ENCODE_REGEX = /[^\w?\/:@\-.~!$&'()*+,;=]/
+
+    attr_reader :keyword, :schema
+
+  private
+
+    def result(instance, instance_location, keyword_location, valid, nested = nil, type: nil, annotation: nil, details: nil, ignore_nested: false)
+      if valid
+        Result.new(self, instance, instance_location, keyword_location, valid, nested, type, annotation, details, ignore_nested, 'annotations')
+      else
+        Result.new(self, instance, instance_location, keyword_location, valid, nested, type, annotation, details, ignore_nested, 'errors')
+      end
+    end
+
+    def escaped_keyword
+      @escaped_keyword ||= Location.escape_json_pointer_token(keyword)
+    end
+
+    def join_location(location, keyword)
+      Location.join(location, keyword)
+    end
+
+    def fragment_encode(location)
+      Format.percent_encode(location, FRAGMENT_ENCODE_REGEX)
+    end
+
+    # :nocov:
+    if Symbol.method_defined?(:name)
+      def stringify(key)
+        key.is_a?(Symbol) ? key.name : key.to_s
+      end
+    else
+      def stringify(key)
+        key.to_s
+      end
+    end
+    # :nocov:
+
+    def deep_stringify_keys(obj)
+      case obj
+      when Hash
+        obj.each_with_object({}) do |(key, value), out|
+          out[stringify(key)] = deep_stringify_keys(value)
+        end
+      when Array
+        obj.map { |item| deep_stringify_keys(item) }
+      else
+        obj
+      end
+    end
+  end
+end

data/lib/json_schemer/result.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+module JSONSchemer
+  Result = Struct.new(:source, :instance, :instance_location, :keyword_location, :valid, :nested, :type, :annotation, :details, :ignore_nested, :nested_key) do
+    CLASSIC_ERROR_TYPES = Hash.new do |hash, klass|
+      hash[klass] = klass.name.rpartition('::').last.sub(/\A[[:alpha:]]/, &:downcase)
+    end
+
+    def output(output_format)
+      case output_format
+      when 'classic'
+        classic
+      when 'flag'
+        flag
+      when 'basic'
+        basic
+      when 'detailed'
+        detailed
+      when 'verbose'
+        verbose
+      else
+        raise UnknownOutputFormat, output_format
+      end
+    end
+
+    def error
+      return @error if defined?(@error)
+      resolved_instance_location = Location.resolve(instance_location)
+      @error = source.error(
+        :formatted_instance_location => resolved_instance_location.empty? ? 'root' : "`#{resolved_instance_location}`",
+        :details => details
+      )
+    end
+
+    def to_output_unit
+      out = {
+        'valid' => valid,
+        'keywordLocation' => Location.resolve(keyword_location),
+        'absoluteKeywordLocation' => source.absolute_keyword_location,
+        'instanceLocation' => Location.resolve(instance_location)
+      }
+      out['error'] = error unless valid
+      out['annotation'] = annotation if valid && annotation
+      out
+    end
+
+    def to_classic
+      schema = source.schema
+      out = {
+        'data' => instance,
+        'data_pointer' => Location.resolve(instance_location),
+        'schema' => schema.value,
+        'schema_pointer' => schema.schema_pointer,
+        'root_schema' => schema.root.value,
+        'type' => type || CLASSIC_ERROR_TYPES[source.class]
+      }
+      out['error'] = error
+      out['details'] = details if details
+      out
+    end
+
+    def flag
+      { 'valid' => valid }
+    end
+
+    def basic
+      out = to_output_unit
+      if nested&.any?
+        out[nested_key] = Enumerator.new do |yielder|
+          results = [self]
+          while result = results.pop
+            if result.ignore_nested || !result.nested&.any?
+              yielder << result.to_output_unit
+            else
+              previous_results_size = results.size
+              result.nested.reverse_each do |nested_result|
+                results << nested_result if nested_result.valid == valid
+              end
+              yielder << result.to_output_unit unless (results.size - previous_results_size) == 1
+            end
+          end
+        end
+      end
+      out
+    end
+
+    def detailed
+      return to_output_unit if ignore_nested || !nested&.any?
+      matching_results = nested.select { |nested_result| nested_result.valid == valid }
+      if matching_results.size == 1
+        matching_results.first.detailed
+      else
+        out = to_output_unit
+        if matching_results.any?
+          out[nested_key] = Enumerator.new do |yielder|
+            matching_results.each { |nested_result| yielder << nested_result.detailed }
+          end
+        end
+        out
+      end
+    end
+
+    def verbose
+      out = to_output_unit
+      if nested&.any?
+        out[nested_key] = Enumerator.new do |yielder|
+          nested.each { |nested_result| yielder << nested_result.verbose }
+        end
+      end
+      out
+    end
+
+    def classic
+      Enumerator.new do |yielder|
+        unless valid
+          results = [self]
+          while result = results.pop
+            if result.ignore_nested || !result.nested&.any?
+              yielder << result.to_classic
+            else
+              previous_results_size = results.size
+              result.nested.reverse_each do |nested_result|
+                results << nested_result if nested_result.valid == valid
+              end
+              yielder << result.to_classic if (results.size - previous_results_size) == 0
+            end
+          end
+        end
+      end
+    end
+
+    def insert_property_defaults(context)
+      instance_locations = {}
+
+      results = [[self, true]]
+      while (result, valid = results.pop)
+        next if result.source.is_a?(Schema::NOT_KEYWORD_CLASS)
+
+        valid &&= result.valid
+        result.nested&.each { |nested_result| results << [nested_result, valid] }
+
+        if result.source.is_a?(Schema::PROPERTIES_KEYWORD_CLASS) && result.instance.is_a?(Hash)
+          result.source.parsed.each do |property, schema|
+            next if result.instance.key?(property) || !schema.parsed.key?('default')
+            default = schema.parsed.fetch('default')
+            instance_location = Location.join(result.instance_location, property)
+            keyword_location = Location.join(Location.join(result.keyword_location, property), default.keyword)
+            default_result = default.validate(nil, instance_location, keyword_location, nil)
+            instance_locations[result.instance_location] ||= {}
+            instance_locations[result.instance_location][property] ||= []
+            instance_locations[result.instance_location][property] << [default_result, valid]
+          end
+        end
+      end
+
+      inserted = false
+
+      instance_locations.each do |instance_location, properties|
+        original_instance = context.original_instance(instance_location)
+        properties.each do |property, results_with_tree_validity|
+          property_inserted = yield(original_instance, property, results_with_tree_validity)
+          inserted ||= (property_inserted != false)
+        end
+      end
+
+      inserted
+    end
+  end
+end