json_schemer 0.2.18 → 2.2.1

data/lib/json_schemer/openapi31/meta.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+module JSONSchemer
+  module OpenAPI31
+    BASE_URI = URI('https://spec.openapis.org/oas/3.1/dialect/base')
+    # https://spec.openapis.org/oas/v3.1.0#data-types
+    FORMATS = {
+      'int32' => proc { |instance, _format| instance.is_a?(Integer) && instance.bit_length <= 32 },
+      'int64' => proc { |instance, _format| instance.is_a?(Integer) && instance.bit_length <= 64 },
+      'float' => proc { |instance, _format| instance.is_a?(Float) },
+      'double' => proc { |instance, _format| instance.is_a?(Float) },
+      'password' => proc { |_instance, _format| true }
+    }
+    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,127 @@
+# 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
+          # https://spec.openapis.org/oas/v3.1.0#components-object
+          FIXED_FIELD_REGEX = /\A[a-zA-Z0-9\.\-_]+$\z/
+
+          attr_accessor :skip_ref_once
+
+          def error(formatted_instance_location:, **)
+            "value at #{formatted_instance_location} does not match `discriminator` schema"
+          end
+
+          def mapping
+            @mapping ||= value['mapping'] || {}
+          end
+
+          def subschemas_by_property_value
+            @subschemas_by_property_value ||= if schema.parsed.key?('anyOf') || schema.parsed.key?('oneOf')
+              subschemas = schema.parsed['anyOf']&.parsed || []
+              subschemas += schema.parsed['oneOf']&.parsed || []
+
+              subschemas_by_ref = {}
+              subschemas_by_schema_name = {}
+
+              subschemas.each do |subschema|
+                subschema_ref = subschema.parsed.fetch('$ref').parsed
+                subschemas_by_ref[subschema_ref] = subschema
+
+                if subschema_ref.start_with?('#/components/schemas/')
+                  schema_name = subschema_ref.delete_prefix('#/components/schemas/')
+                  subschemas_by_schema_name[schema_name] = subschema if FIXED_FIELD_REGEX.match?(schema_name)
+                end
+              end
+
+              explicit_mapping = mapping.transform_values do |schema_name_or_ref|
+                subschemas_by_schema_name.fetch(schema_name_or_ref) { subschemas_by_ref.fetch(schema_name_or_ref) }
+              end
+
+              implicit_mapping = subschemas_by_schema_name.reject do |_schema_name, subschema|
+                explicit_mapping.value?(subschema)
+              end
+
+              implicit_mapping.merge(explicit_mapping)
+            else
+              Hash.new do |hash, property_value|
+                schema_name_or_ref = mapping.fetch(property_value, property_value)
+
+                subschema = nil
+
+                if FIXED_FIELD_REGEX.match?(schema_name_or_ref)
+                  subschema = begin
+                    schema.ref("#/components/schemas/#{schema_name_or_ref}")
+                  rescue InvalidRefPointer
+                    nil
+                  end
+                end
+
+                subschema ||= begin
+                  schema.ref(schema_name_or_ref)
+                rescue InvalidRefResolution, UnknownRef
+                  nil
+                end
+
+                hash[property_value] = subschema
+              end
+            end
+          end
+
+          def validate(instance, instance_location, keyword_location, context)
+            return result(instance, instance_location, keyword_location, true) unless instance.is_a?(Hash)
+
+            property_name = value.fetch('propertyName')
+
+            return result(instance, instance_location, keyword_location, false) unless instance.key?(property_name)
+
+            property_value = instance.fetch(property_name)
+            subschema = subschemas_by_property_value[property_value]
+
+            return result(instance, instance_location, keyword_location, false) unless subschema
+
+            return if skip_ref_once == subschema.absolute_keyword_location
+            subschema.parsed['allOf']&.skip_ref_once = schema.absolute_keyword_location
+
+            subschema_result = subschema.validate_instance(instance, instance_location, keyword_location, context)
+
+            result(instance, instance_location, keyword_location, subschema_result.valid, subschema_result.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,56 @@
+# frozen_string_literal: true
+module JSONSchemer
+  module Output
+    FRAGMENT_ENCODE_REGEX = /[^\w?\/:@\-.~!$&'()*+,;=]/
+
+    attr_reader :keyword, :schema
+
+    def x_error
+      return @x_error if defined?(@x_error)
+      @x_error = schema.parsed['x-error']&.message(error_key)
+    end
+
+  private
+
+    def result(instance, instance_location, keyword_location, valid, nested = nil, type: nil, annotation: nil, details: nil, ignore_nested: false)
+      Result.new(self, instance, instance_location, keyword_location, valid, nested, type, annotation, details, ignore_nested, valid ? 'annotations' : 'errors')
+    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,242 @@
+# frozen_string_literal: true
+module JSONSchemer
+  CATCHALL = '*'
+  I18N_SEPARATOR = "\x1F" # unit separator
+  I18N_SCOPE = 'json_schemer'
+  I18N_ERRORS_SCOPE = "#{I18N_SCOPE}#{I18N_SEPARATOR}errors"
+  X_ERROR_REGEX = /%\{(instance|instanceLocation|keywordLocation|absoluteKeywordLocation)\}/
+  CLASSIC_ERROR_TYPES = Hash.new do |hash, klass|
+    hash[klass] = klass.name.rpartition('::').last.sub(/\A[[:alpha:]]/, &:downcase)
+  end
+
+  Result = Struct.new(:source, :instance, :instance_location, :keyword_location, :valid, :nested, :type, :annotation, :details, :ignore_nested, :nested_key) do
+    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)
+      if source.x_error
+        # not using sprintf because it warns: "too many arguments for format string"
+        @error = source.x_error.gsub(
+          X_ERROR_REGEX,
+          '%{instance}' => instance,
+          '%{instanceLocation}' => Location.resolve(instance_location),
+          '%{keywordLocation}' => Location.resolve(keyword_location),
+          '%{absoluteKeywordLocation}' => source.absolute_keyword_location
+        )
+        @x_error = true
+      else
+        resolved_instance_location = Location.resolve(instance_location)
+        formatted_instance_location = resolved_instance_location.empty? ? 'root' : "`#{resolved_instance_location}`"
+        @error = source.error(:formatted_instance_location => formatted_instance_location, :details => details)
+        if i18n?
+          begin
+            @error = i18n!
+            @i18n = true
+          rescue I18n::MissingTranslationData
+          end
+        end
+      end
+      @error
+    end
+
+    def i18n?
+      return @@i18n if defined?(@@i18n)
+      @@i18n = defined?(I18n) && I18n.exists?(I18N_SCOPE)
+    end
+
+    def i18n!
+      base_uri_str = source.schema.base_uri.to_s
+      meta_schema_base_uri_str = source.schema.meta_schema.base_uri.to_s
+      resolved_keyword_location = Location.resolve(keyword_location)
+      error_key = source.error_key
+      I18n.translate!(
+        source.absolute_keyword_location,
+        :default => [
+          "#{base_uri_str}#{I18N_SEPARATOR}##{resolved_keyword_location}",
+          "##{resolved_keyword_location}",
+          "#{base_uri_str}#{I18N_SEPARATOR}#{error_key}",
+          "#{base_uri_str}#{I18N_SEPARATOR}#{CATCHALL}",
+          "#{meta_schema_base_uri_str}#{I18N_SEPARATOR}#{error_key}",
+          "#{meta_schema_base_uri_str}#{I18N_SEPARATOR}#{CATCHALL}",
+          error_key,
+          CATCHALL
+        ].map!(&:to_sym),
+        :separator => I18N_SEPARATOR,
+        :scope => I18N_ERRORS_SCOPE,
+        :instance => instance,
+        :instanceLocation => Location.resolve(instance_location),
+        :keywordLocation => resolved_keyword_location,
+        :absoluteKeywordLocation => source.absolute_keyword_location
+      )
+    end
+
+    def to_output_unit
+      out = {
+        'valid' => valid,
+        'keywordLocation' => Location.resolve(keyword_location),
+        'absoluteKeywordLocation' => source.absolute_keyword_location,
+        'instanceLocation' => Location.resolve(instance_location)
+      }
+      if valid
+        out['annotation'] = annotation if annotation
+      else
+        out['error'] = error
+        out['x-error'] = true if @x_error
+        out['i18n'] = true if @i18n
+      end
+      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['x-error'] = true if @x_error
+      out['i18n'] = true if @i18n
+      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 = {}
+      instance_locations.compare_by_identity
+
+      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)
+            next unless default = default_keyword_instance(schema)
+            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
+
+  private
+
+    def default_keyword_instance(schema)
+      schema.parsed.fetch('default') do
+        schema.parsed.find do |_keyword, keyword_instance|
+          next unless keyword_instance.respond_to?(:ref_schema)
+          next unless default = default_keyword_instance(keyword_instance.ref_schema)
+          break default
+        end
+      end
+    end
+  end
+end