openapi_parser 0.13.0 → 1.0.0.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9afe7e0164ddcad6c8a8fbb6d57e0514e32df10d014bc642b88fa3473f1f8d74
-  data.tar.gz: cefb18a632f4a16dd948fe2e82fadfc0236a159af2406fdcb52db50ef6dc980e
+  metadata.gz: e383e6ff9f0d2a6ac67fda1ac8663b82c249449a7c1cff616a72fb608344a816
+  data.tar.gz: 53c6a442a5f170f5190197aa17a805a707fd586d7b4d0fc4c259ed8af46dc2bd
 SHA512:
-  metadata.gz: fb0397b9251edac7e3bfb15e30041d5945a466c21b6671183eaec8491a372730e2f76101af71efbc7c07c66345353c260983acfb69d80f2b066c35c71207a076
-  data.tar.gz: 5a58f4b47946ca9c376dcce3c5be34de998a2bc3d59ee4321e2e7f0425c7cdf6b809ff9eb3a103fe099a849210def6c362431628610fdde137b3b79157a32849
+  metadata.gz: 3cd78f54ac0bb0bca68e9538f3f33968b7815b76d88c39908735da2f18936118ecc66ec57a97ac491f2b0fdc7fd4985e312b8b32a4051d22a2242ed8ea55608f
+  data.tar.gz: 22fcb549a4c134350274be73bc59114309d612f096b70dfd5633fe049b9b2111c176809575b2ce89fc30a2db3a8cda633c5ce18b82a58a418cd95d76ce23791a

data/.github/workflows/ci.yaml

@@ -0,0 +1,17 @@
+name: ci
+on: [push]
+jobs:
+  test:
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, macos-latest]
+        ruby: [2.6, 2.7, '3.0', head]
+    runs-on: ${{ matrix.os }}
+    steps:
+    - uses: actions/checkout@v2
+    - uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby }}
+        bundler-cache: true
+    - run: bundle exec rake

data/.ruby-version

@@ -0,0 +1 @@
+3.0.3

data/CHANGELOG.md

@@ -1,5 +1,27 @@
 ## Unreleased
 
+## 1.0.0.beta1 (2021-12-15)
+### Added
+* Add strict_reference_validation config and implementation to address/implement #29 #123
+
+## 0.15.0 (2021-09-27)
+### Added
+* support: relative file path escape. #117
+
+## 0.14.1 (2021-07-9)
+### Fixed
+* Fix bug for using path parameter and coerce option #115
+
+## 0.14.0 (2021-05-24)
+
+### Added
+* Add basic polymorphism handling #103
+* Support empty schema as any type #109
+* Add date format validation for string #102
+
+### Fixed
+* Fix anyOf coercion to float and integer when value is a non-string type #110
+
 ## 0.13.0 (2021-05-01)
 * Fix a problem with remote reference to path items which have path parameters #95
 * Support enum for booleans. #104

data/README.md

@@ -1,9 +1,7 @@
 # OpenAPI Parser
-[![Build Status](https://travis-ci.org/ota42y/openapi_parser.svg?branch=master)](https://travis-ci.org/ota42y/openapi_parser)
+[![ci](https://github.com/ota42y/openapi_parser/actions/workflows/ci.yaml/badge.svg)](https://github.com/ota42y/openapi_parser/actions/workflows/ci.yaml)
 [![Gem Version](https://badge.fury.io/rb/openapi_parser.svg)](https://badge.fury.io/rb/openapi_parser)
 [![Yard Docs](https://img.shields.io/badge/yard-docs-blue.svg)](https://www.rubydoc.info/gems/openapi_parser)
-[![Maintainability](https://api.codeclimate.com/v1/badges/62bad4bcb3f691d46487/maintainability)](https://codeclimate.com/github/ota42y/openapi_parser/maintainability)
-[![Test Coverage](https://api.codeclimate.com/v1/badges/62bad4bcb3f691d46487/test_coverage)](https://codeclimate.com/github/ota42y/openapi_parser/test_coverage)
 [![Inch CI](https://inch-ci.org/github/ota42y/openapi_parser.svg?branch=master)](https://inch-ci.org/github/ota42y/openapi_parser)
 
 This is OpenAPI3 parser and validator. 
@@ -64,6 +62,33 @@ We support additional type validation.
 |---|---|---|
 |string|uuid|validate uuid string. But we don't check uuid layout|
 
+### Reference Validation on Schema Load
+Invalid references (missing definitions, typos, etc.) can cause validation to fail in runtime,
+and these errors can be difficult to debug (see: https://github.com/ota42y/openapi_parser/issues/29).
+
+Pass the `strict_reference_validation: true` option to detect invalid references.
+An `OpenAPIError::MissingReferenceError` exception will be raised when a reference cannot be resolved.
+
+If the `expand_reference` configuration is explicitly `false` (default is `true`), then
+this configuration has no effect.
+
+DEPRECATION NOTICE: To maintain compatibility with the previous behavior, this version sets `false` as a default.
+This behavior will be changed to `true` in a later version, so you should explicitly pass `strict_reference_validation: false`
+if you wish to keep the old behavior (and please let the maintainers know your use-case for this configuration!).
+
+```ruby
+yaml_file = YAML.load_file('open_api_3/schema_with_broken_references.yml')
+options = {
+  coerce_value: true,
+  datetime_coerce_class: DateTime,
+  # This defaults to false (for now) - passing `true` provides load-time validation of refs
+  strict_reference_validation: true
+}
+
+# Will raise with OpenAPIParser::MissingReferenceError
+OpenAPIParser.parse(yaml_file, options)
+```
+
 ## ToDo
 - correct schema checker
 - more detailed validator

data/Rakefile

@@ -3,4 +3,8 @@ require 'rspec/core/rake_task'
 
 RSpec::Core::RakeTask.new(:spec)
 
-task :default => :spec
+task :steep do
+sh 'steep check'
+end
+
+task :default => [:steep, :spec]

data/Steepfile

@@ -0,0 +1,11 @@
+target :lib do
+  signature "sig"
+  #check "lib"
+
+  check "lib/openapi_parser.rb"
+  check "lib/openapi_parser/config.rb"
+  check "lib/openapi_parser/schema_validators/options.rb"
+  check "lib/openapi_parser/schema_validators/base.rb"
+
+  library 'uri'
+end

data/lib/openapi_parser/concerns/expandable.rb

@@ -2,28 +2,28 @@ module OpenAPIParser::Expandable
   # expand refs
   # @param [OpenAPIParser::Schemas::Base] root
   # @return nil
-  def expand_reference(root)
-    expand_list_objects(root, self.class._openapi_attr_list_objects.keys)
-    expand_objects(root, self.class._openapi_attr_objects.keys)
-    expand_hash_objects(root, self.class._openapi_attr_hash_objects.keys)
-    expand_hash_objects(root, self.class._openapi_attr_hash_body_objects.keys)
+  def expand_reference(root, validate_references)
+    expand_list_objects(root, self.class._openapi_attr_list_objects.keys, validate_references)
+    expand_objects(root, self.class._openapi_attr_objects.keys, validate_references)
+    expand_hash_objects(root, self.class._openapi_attr_hash_objects.keys, validate_references)
+    expand_hash_objects(root, self.class._openapi_attr_hash_body_objects.keys, validate_references)
     nil
   end
 
   private
 
-    def expand_hash_objects(root, attribute_names)
+    def expand_hash_objects(root, attribute_names, validate_references)
       return unless attribute_names
 
-      attribute_names.each { |name| expand_hash_attribute(root, name) }
+      attribute_names.each { |name| expand_hash_attribute(root, name, validate_references) }
     end
 
-    def expand_hash_attribute(root, name)
+    def expand_hash_attribute(root, name, validate_references)
       h = send(name)
       return if h.nil?
 
       update_values = h.map do |k, v|
-        new_object = expand_object(root, v)
+        new_object = expand_object(root, v, validate_references)
         new_object.nil? ? nil : [k, new_object]
       end
 
@@ -33,14 +33,14 @@ module OpenAPIParser::Expandable
       end
     end
 
-    def expand_objects(root, attribute_names)
+    def expand_objects(root, attribute_names, validate_references)
       return unless attribute_names
 
       attribute_names.each do |name|
         v = send(name)
         next if v.nil?
 
-        new_object = expand_object(root, v)
+        new_object = expand_object(root, v, validate_references)
         next if new_object.nil?
 
         _update_child_object(v, new_object)
@@ -48,7 +48,7 @@ module OpenAPIParser::Expandable
       end
     end
 
-    def expand_list_objects(root, attribute_names)
+    def expand_list_objects(root, attribute_names, validate_references)
       return unless attribute_names
 
       attribute_names.each do |name|
@@ -56,7 +56,7 @@ module OpenAPIParser::Expandable
         next if l.nil?
 
         l.each_with_index do |v, idx|
-          new_object = expand_object(root, v)
+          new_object = expand_object(root, v, validate_references)
           next if new_object.nil?
 
           _update_child_object(v, new_object)
@@ -65,12 +65,15 @@ module OpenAPIParser::Expandable
       end
     end
 
-    def expand_object(root, object)
+    def expand_object(root, object, validate_references)
       if object.kind_of?(OpenAPIParser::Schemas::Reference)
-        return referenced_object(root, object)
+        ref_object = referenced_object(root, object)
+        raise OpenAPIParser::MissingReferenceError.new(object.ref) if ref_object.nil? && validate_references
+
+        return ref_object
       end
 
-      object.expand_reference(root) if object.kind_of?(OpenAPIParser::Expandable)
+      object.expand_reference(root, validate_references) if object.kind_of?(OpenAPIParser::Expandable)
       nil
     end
 

data/lib/openapi_parser/concerns/findable.rb

@@ -46,8 +46,8 @@ module OpenAPIParser::Findable
   private
 
     def find_remote_object(reference)
-      reference_uri = URI(reference)
-      fragment = reference_uri.fragment
+      uri, fragment = reference.split("#", 2)
+      reference_uri = URI(uri)
       reference_uri.fragment = nil
       root.load_another_schema(reference_uri)&.find_object("##{fragment}")
     end

data/lib/openapi_parser/concerns/parameter_validatable.rb

@@ -13,6 +13,12 @@ module OpenAPIParser::ParameterValidatable
     validate_query_parameter(params, object_reference, options)
   end
 
+  # @param [PathItem] path_item parent
+  def set_parent_path_item(path_item)
+    @merged_parameter = (parameters || []) + (path_item.parameters || [])
+    nil
+  end
+
   private
 
     # @param [Hash] params query parameter hash
@@ -44,7 +50,7 @@ module OpenAPIParser::ParameterValidatable
     # @return [Hash{String => Hash{String => Parameter}}] hash[in][name] => Parameter
     def divided_parameter_hash
       @divided_parameter_hash ||=
-        (parameters || []).
+        (@merged_parameter || []).
           group_by(&:in).
           map { |in_type, params| # rubocop:disable Style/BlockDelimiters
           [

data/lib/openapi_parser/config.rb

@@ -1,5 +1,13 @@
 class OpenAPIParser::Config
   def initialize(config)
+    # TODO: This deprecation warning can be removed after we set the default to `true`
+    # in a later (major?) version update.
+    unless config.key?(:strict_reference_validation)
+      msg = "[DEPRECATION] strict_reference_validation config is not set. It defaults to `false` now, " +
+          "but will be `true` in a future version. Please explicitly set to `false` " +
+          "if you want to skip reference validation on schema load."
+      warn(msg)
+    end
     @config = config
   end
 
@@ -16,9 +24,15 @@ class OpenAPIParser::Config
   end
 
   def strict_response_validation
+    # TODO: in a major version update, change this to default to `true`.
+    # https://github.com/ota42y/openapi_parser/pull/123/files#r767142217
     @config.fetch(:strict_response_validation, false)
   end
 
+  def strict_reference_validation
+    @config.fetch(:strict_reference_validation, false)
+  end
+
   def validate_header
     @config.fetch(:validate_header, true)
   end

data/lib/openapi_parser/errors.rb

@@ -5,6 +5,12 @@ module OpenAPIParser
     end
   end
 
+  class MissingReferenceError < OpenAPIError
+    def message
+      "'#{@reference}' was referenced but could not be found"
+    end
+  end
+
   class ValidateError < OpenAPIError
     def initialize(data, type, reference)
       super(reference)
@@ -189,6 +195,17 @@ module OpenAPIParser
     end
   end
 
+  class InvalidDateFormat < OpenAPIError
+    def initialize(value, reference)
+      super(reference)
+      @value = value
+    end
+
+    def message
+      "#{@reference} Value: #{@value.inspect} is not conformant with date format"
+    end
+  end
+
   class NotExistStatusCodeDefinition < OpenAPIError
     def message
       "#{@reference} status code definition does not exist"

data/lib/openapi_parser/reference_expander.rb

@@ -1,8 +1,8 @@
 class OpenAPIParser::ReferenceExpander
   class << self
     # @param [OpenAPIParser::Schemas::OpenAPI] openapi
-    def expand(openapi)
-      openapi.expand_reference(openapi)
+    def expand(openapi, validate_references)
+      openapi.expand_reference(openapi, validate_references)
       openapi.purge_object_cache
     end
   end

data/lib/openapi_parser/request_operation.rb

@@ -65,7 +65,6 @@ class OpenAPIParser::RequestOperation
   # @param [OpenAPIParser::SchemaValidator::Options] options request validator options
   def validate_request_parameter(params, headers, options = nil)
     options ||= config.request_validator_options
-    path_item&.validate_request_parameter(params, headers, options)
     operation_object&.validate_request_parameter(params, headers, options)
   end
 

data/lib/openapi_parser/schema_validator.rb

@@ -12,6 +12,7 @@ require_relative 'schema_validators/any_of_validator'
 require_relative 'schema_validators/all_of_validator'
 require_relative 'schema_validators/one_of_validator'
 require_relative 'schema_validators/nil_validator'
+require_relative 'schema_validators/unspecified_type_validator'
 
 class OpenAPIParser::SchemaValidator
   # validate value by schema
@@ -113,7 +114,7 @@ class OpenAPIParser::SchemaValidator
       when 'array'
         array_validator
       else
-        nil
+        unspecified_type_validator
       end
     end
 
@@ -156,4 +157,8 @@ class OpenAPIParser::SchemaValidator
     def nil_validator
       @nil_validator ||= OpenAPIParser::SchemaValidator::NilValidator.new(self, @coerce_value)
     end
+
+    def unspecified_type_validator
+      @unspecified_type_validator ||= OpenAPIParser::SchemaValidator::UnspecifiedTypeValidator.new(self, @coerce_value)
+    end
 end

data/lib/openapi_parser/schema_validators/all_of_validator.rb

@@ -4,13 +4,18 @@ class OpenAPIParser::SchemaValidator
     # coerce and validate value
     # @param [Object] value
     # @param [OpenAPIParser::Schemas::Schema] schema
-    def coerce_and_validate(value, schema, **_keyword_args)
+    def coerce_and_validate(value, schema, **keyword_args)
       # if any schema return error, it's not valida all of value
       remaining_keys               = value.kind_of?(Hash) ? value.keys : []
       nested_additional_properties = false
       schema.all_of.each do |s|
         # We need to store the reference to all of, so we can perform strict check on allowed properties
-        _coerced, err = validatable.validate_schema(value, s, :parent_all_of => true)
+        _coerced, err = validatable.validate_schema(
+          value,
+          s,
+          :parent_all_of => true,
+          parent_discriminator_schemas: keyword_args[:parent_discriminator_schemas]
+        )
 
         if s.type == "object"
           remaining_keys               -= (s.properties || {}).keys

data/lib/openapi_parser/schema_validators/base.rb

@@ -1,6 +1,5 @@
 class OpenAPIParser::SchemaValidator
   class Base
-    # @param [OpenAPIParser::SchemaValidator::Validatable] validatable
     def initialize(validatable, coerce_value)
       @validatable = validatable
       @coerce_value = coerce_value
@@ -8,21 +7,17 @@ class OpenAPIParser::SchemaValidator
 
     attr_reader :validatable
 
-    # @!attribute [r] validatable
-    #   @return [OpenAPIParser::SchemaValidator::Validatable]
-
     # need override
-    # @param [Array] _value
-    # @param [OpenAPIParser::Schemas::Schema] _schema
     def coerce_and_validate(_value, _schema, **_keyword_args)
       raise 'need implement'
     end
 
-    def validate_discriminator_schema(discriminator, value)
-      unless value.key?(discriminator.property_name)
+    def validate_discriminator_schema(discriminator, value, parent_discriminator_schemas: [])
+      property_name = discriminator.property_name
+      unless (property_name && value.key?(property_name))
         return [nil, OpenAPIParser::NotExistDiscriminatorPropertyName.new(discriminator.property_name, value, discriminator.object_reference)]
       end
-      mapping_key = value[discriminator.property_name]
+      mapping_key = value[property_name]
 
       # it's allowed to have discriminator without mapping, then we need to lookup discriminator.property_name
       # but the format is not the full path, just model name in the components
@@ -34,7 +29,11 @@ class OpenAPIParser::SchemaValidator
       unless resolved_schema
         return [nil, OpenAPIParser::NotExistDiscriminatorMappedSchema.new(mapping_target, discriminator.object_reference)]
       end
-      validatable.validate_schema(value, resolved_schema, **{discriminator_property_name: discriminator.property_name})
+      validatable.validate_schema(
+        value,
+        resolved_schema,
+        **{discriminator_property_name: discriminator.property_name, parent_discriminator_schemas: parent_discriminator_schemas}
+      )
     end
   end
 end

data/lib/openapi_parser/schema_validators/float_validator.rb

@@ -21,14 +21,14 @@ class OpenAPIParser::SchemaValidator
 
         value, err = check_enum_include(value, schema)
         return [nil, err] if err
-        
+
         check_minimum_maximum(value, schema)
       end
 
       def coerce(value)
         Float(value)
-      rescue ArgumentError => e
-        raise e unless e.message =~ /invalid value for Float/
+      rescue ArgumentError, TypeError
+        value
       end
   end
 end

data/lib/openapi_parser/schema_validators/integer_validator.rb

@@ -23,12 +23,10 @@ class OpenAPIParser::SchemaValidator
         return value if value.kind_of?(Integer)
 
         begin
-          return Integer(value)
-        rescue ArgumentError => e
-          raise e unless e.message =~ /invalid value for Integer/
+          Integer(value)
+        rescue ArgumentError, TypeError
+          value
         end
-
-        value
       end
   end
 end

data/lib/openapi_parser/schema_validators/object_validator.rb

@@ -4,7 +4,7 @@ class OpenAPIParser::SchemaValidator
     # @param [OpenAPIParser::Schemas::Schema] schema
     # @param [Boolean] parent_all_of true if component is nested under allOf
     # @param [String, nil] discriminator_property_name discriminator.property_name to ignore checking additional_properties
-    def coerce_and_validate(value, schema, parent_all_of: false, discriminator_property_name: nil)
+    def coerce_and_validate(value, schema, parent_all_of: false, parent_discriminator_schemas: [], discriminator_property_name: nil)
       return OpenAPIParser::ValidateError.build_error_result(value, schema) unless value.kind_of?(Hash)
 
       properties = schema.properties || {}
@@ -12,6 +12,16 @@ class OpenAPIParser::SchemaValidator
       required_set = schema.required ? schema.required.to_set : Set.new
       remaining_keys = value.keys
 
+      if schema.discriminator && !parent_discriminator_schemas.include?(schema)
+        return validate_discriminator_schema(
+          schema.discriminator,
+          value,
+          parent_discriminator_schemas: parent_discriminator_schemas + [schema]
+        )
+      else
+        remaining_keys.delete('discriminator')
+      end
+
       coerced_values = value.map do |name, v|
         s = properties[name]
         coerced, err = if s

data/lib/openapi_parser/schema_validators/string_validator.rb

@@ -30,6 +30,9 @@ class OpenAPIParser::SchemaValidator
       value, err = validate_uuid_format(value, schema)
       return [nil, err] if err
 
+      value, err = validate_date_format(value, schema)
+      return [nil, err] if err
+
       [value, nil]
     end
 
@@ -86,5 +89,17 @@ class OpenAPIParser::SchemaValidator
 
         return [nil, OpenAPIParser::InvalidUUIDFormat.new(value, schema.object_reference)]
       end
+
+      def validate_date_format(value, schema)
+        return [value, nil] unless schema.format == 'date'
+
+        begin
+          Date.strptime(value, "%Y-%m-%d")
+        rescue ArgumentError
+          return [nil, OpenAPIParser::InvalidDateFormat.new(value, schema.object_reference)]
+        end
+
+        return [value, nil]
+      end
   end
 end

data/lib/openapi_parser/schema_validators/unspecified_type_validator.rb

@@ -0,0 +1,8 @@
+class OpenAPIParser::SchemaValidator
+  class UnspecifiedTypeValidator < Base
+    # @param [Object] value
+    def coerce_and_validate(value, _schema, **_keyword_args)
+      value
+    end
+  end
+end

data/lib/openapi_parser/schemas/path_item.rb

@@ -3,8 +3,6 @@
 
 module OpenAPIParser::Schemas
   class PathItem < Base
-    include OpenAPIParser::ParameterValidatable
-
     openapi_attr_values :summary, :description
 
     openapi_attr_objects :get, :put, :post, :delete, :options, :head, :patch, :trace, Operation
@@ -16,5 +14,9 @@ module OpenAPIParser::Schemas
     rescue NoMethodError
       nil
     end
+
+    def set_path_item_to_operation
+      [:get, :put, :post, :delete, :options, :head, :patch, :trace].each{ |method| operation(method)&.set_parent_path_item(self)}
+    end
   end
 end

data/lib/openapi_parser/version.rb

@@ -1,3 +1,3 @@
 module OpenAPIParser
-  VERSION = '0.13.0'.freeze
+  VERSION = '1.0.0.beta1'.freeze
 end

data/lib/openapi_parser.rb

@@ -44,9 +44,9 @@ module OpenAPIParser
       # Open-uri doesn't open file scheme uri, so we try to open file path directly
       # File scheme uri which points to a remote file is not supported.
       content = if uri.scheme == 'file'
-        open(uri.path, &:read)
-      else
-        uri.open(&:read)
+        open(uri.path)&.read
+      elsif uri.is_a?(OpenURI::OpenRead)
+        uri.open()&.read
       end
 
       extension = Pathname.new(uri.path).extname
@@ -61,8 +61,8 @@ module OpenAPIParser
         URI.join("file:///",  path.to_s)
       end
 
-      def parse_file(content, extension)
-        case extension.downcase
+      def parse_file(content, ext)
+        case ext.downcase
         when '.yaml', '.yml'
           parse_yaml(content)
         when '.json'
@@ -91,7 +91,12 @@ module OpenAPIParser
       def load_hash(hash, config:, uri:, schema_registry:)
         root = Schemas::OpenAPI.new(hash, config, uri: uri, schema_registry: schema_registry)
 
-        OpenAPIParser::ReferenceExpander.expand(root) if config.expand_reference
+        OpenAPIParser::ReferenceExpander.expand(root, config.strict_reference_validation) if config.expand_reference
+
+        # TODO: use callbacks
+        root.paths&.path&.values&.each do | path_item |
+          path_item.set_path_item_to_operation
+        end
 
         root
       end

data/openapi_parser.gemspec

@@ -12,6 +12,7 @@ Gem::Specification.new do |spec|
   spec.description   = 'parser for OpenAPI 3.0 or later'
   spec.homepage      = 'https://github.com/ota42y/openapi_parser'
   spec.license       = 'MIT'
+  spec.required_ruby_version = ">= 2.6.0"
 
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
@@ -30,4 +31,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'rspec', '~> 3.0'
   spec.add_development_dependency 'rspec-parameterized'
   spec.add_development_dependency 'simplecov'
+  spec.add_development_dependency "steep"
 end

data/sig/openapi_parser/config.rbs

@@ -0,0 +1,17 @@
+# Classes
+module OpenAPIParser
+  class Config
+    @config: untyped
+    alias request_body_options request_validator_options
+    alias path_params_options request_validator_options
+
+    def initialize: (untyped config) -> untyped
+    def datetime_coerce_class: -> (singleton(Object) | nil)
+    def coerce_value: -> bool
+    def expand_reference: -> bool
+    def strict_response_validation: -> bool
+    def validate_header: -> bool
+    def request_validator_options: -> OpenAPIParser::SchemaValidator::Options
+    def response_validate_options: -> OpenAPIParser::SchemaValidator::ResponseValidateOptions
+  end
+end

data/sig/openapi_parser/schema_validator.rbs

@@ -0,0 +1,46 @@
+# Classes
+module OpenAPIParser
+  class SchemaValidator
+    include Validatable
+    @value: Hash[bot, bot]
+    @schema: OpenAPIParser::Schemas::Schema
+    @coerce_value: bool | nil
+    @datetime_coerce_class: singleton(Object) | nil
+    @string_validator: OpenAPIParser::SchemaValidator::StringValidator | nil
+    @integer_validator: OpenAPIParser::SchemaValidator::IntegerValidator | nil
+    @float_validator: OpenAPIParser::SchemaValidator::FloatValidator | nil
+    @boolean_validator: OpenAPIParser::SchemaValidator::BooleanValidator | nil
+    @object_validator: OpenAPIParser::SchemaValidator::ObjectValidator | nil
+    @array_validator: OpenAPIParser::SchemaValidator::ArrayValidator | nil
+    @any_of_validator: OpenAPIParser::SchemaValidator::AnyOfValidator | nil
+    @all_of_validator: OpenAPIParser::SchemaValidator::AllOfValidator | nil
+    @one_of_validator: OpenAPIParser::SchemaValidator::OneOfValidator | nil
+    @nil_validator: OpenAPIParser::SchemaValidator::NilValidator | nil
+    @unspecified_type_validator: OpenAPIParser::SchemaValidator::UnspecifiedTypeValidator | nil
+
+    def self.validate: (Hash[bot, bot] value, OpenAPIParser::Schemas::Schema schema, OpenAPIParser::SchemaValidator::Options options) -> Object
+    def initialize: (Hash[bot, bot] value, OpenAPIParser::Schemas::Schema schema, OpenAPIParser::SchemaValidator::Options options) -> untyped
+    def validate_data: -> Object
+    def validate_schema: (Object value, OpenAPIParser::Schemas::Schema schema, **bot) -> [Object, OpenAPIParser::validate_error]
+    def validate_integer: (Object value, OpenAPIParser::Schemas::Schema schema) -> [Object, OpenAPIParser::validate_error]
+
+    private
+    def validator: (Object value, OpenAPIParser::Schemas::Schema schema) -> [OpenAPIParser::SchemaValidator::Base, OpenAPIParser::validate_error]
+    def string_validator: -> OpenAPIParser::SchemaValidator::StringValidator
+    def integer_validator: -> OpenAPIParser::SchemaValidator::IntegerValidator
+    def float_validator: -> OpenAPIParser::SchemaValidator::FloatValidator
+    def boolean_validator: -> OpenAPIParser::SchemaValidator::BooleanValidator
+    def object_validator: -> OpenAPIParser::SchemaValidator::ObjectValidator
+    def array_validator: -> OpenAPIParser::SchemaValidator::ArrayValidator
+    def any_of_validator: -> OpenAPIParser::SchemaValidator::AnyOfValidator
+    def all_of_validator: -> OpenAPIParser::SchemaValidator::AllOfValidator
+    def one_of_validator: -> OpenAPIParser::SchemaValidator::OneOfValidator
+    def nil_validator: -> OpenAPIParser::SchemaValidator::NilValidator
+    def unspecified_type_validator: -> OpenAPIParser::SchemaValidator::UnspecifiedTypeValidator
+
+    module Validatable
+      def validate_schema: (Object value, OpenAPIParser::Schemas::Schema schema, **untyped) -> [Object, OpenAPIParser::validate_error]
+      def validate_integer: (Object _value, OpenAPIParser::Schemas::Schema _schema) -> [Object, OpenAPIParser::validate_error]
+    end
+  end
+end

data/sig/openapi_parser/schema_validators/base.rbs

@@ -0,0 +1,17 @@
+# Classes
+module OpenAPIParser
+  class SchemaValidator
+    class Base
+      @coerce_value: bool | nil
+
+      def initialize: (OpenAPIParser::SchemaValidator::Validatable validatable, (bool | nil) coerce_value) -> untyped
+      attr_reader validatable: OpenAPIParser::SchemaValidator::Validatable
+      def coerce_and_validate: (Object _value, OpenAPIParser::Schemas::Schema _schema, **untyped) -> bot
+      def validate_discriminator_schema: (
+        OpenAPIParser::Schemas::Discriminator discriminator, 
+        Hash[String, bot] value,
+        ?parent_discriminator_schemas: Array[OpenAPIParser::Schemas::Schema]
+      ) -> [Object | nil, OpenAPIParser::validate_error]
+    end
+  end
+end

data/sig/openapi_parser/schema_validators/options.rbs

@@ -0,0 +1,17 @@
+# Classes
+module OpenAPIParser
+  class SchemaValidator
+    class Options
+      attr_reader coerce_value: bool | nil
+      attr_reader datetime_coerce_class: singleton(Object) | nil
+      attr_reader validate_header: bool
+      def initialize: (?coerce_value: bool | nil, ?datetime_coerce_class: singleton(Object) | nil, ?validate_header: bool) -> untyped
+    end
+
+    class ResponseValidateOptions
+      attr_reader strict: bool
+      attr_reader validate_header: bool
+      def initialize: (?strict: bool, ?validate_header: bool) -> untyped
+    end
+  end
+end

data/sig/openapi_parser/schemas/base.rbs

@@ -0,0 +1,17 @@
+# Classes
+module OpenAPIParser
+  module Schemas
+    class Base
+      include OpenAPIParser::Expandable
+      include OpenAPIParser::Findable
+    
+      attr_reader parent: OpenAPIParser::Schemas::Base | nil
+      attr_reader raw_schema: Hash[String, bot]
+      attr_reader object_reference: String
+      attr_reader root: OpenAPIParser::Schemas::OpenAPI
+      def initialize: (String object_reference, OpenAPIParser::Schemas::Base | nil parent, OpenAPIParser::Schemas::OpenAPI root, Hash[String, bot] raw_schema) -> nil
+      def after_init: -> nil
+      def inspect: -> String
+    end
+  end
+end

data/sig/openapi_parser/version.rbs

@@ -0,0 +1,3 @@
+module OpenAPIParser
+  VERSION: String
+end

data/sig/openapi_parser.rbs

@@ -0,0 +1,19 @@
+module OpenAPIParser
+  def self.parse: (Hash[bot, bot] schema, ?Hash[bot, bot] config) -> OpenAPIParser::Schemas::OpenAPI
+  def self.parse_with_filepath: (Hash[bot, bot] schema, String filepath, ?Hash[bot, bot] config) -> OpenAPIParser::Schemas::OpenAPI
+  def self.load: (String filepath, ?Hash[bot, bot] config) -> OpenAPIParser::Schemas::OpenAPI
+  def self.load_uri: (OpenAPIParser::readable_uri uri, config: untyped, schema_registry: Hash[bot, bot]) -> OpenAPIParser::Schemas::OpenAPI
+  def self.file_uri: (String filepath) -> URI::Generic
+  def self.parse_file: (String? content, String ext) -> Hash[bot, bot]
+  def self.parse_yaml: (String? content) -> Hash[bot, bot]
+  def self.parse_json: (String? content) -> Hash[bot, bot]
+  def self.load_hash: (Hash[bot, bot] hash, config: untyped, uri: OpenAPIParser::readable_uri?, schema_registry: Hash[bot, bot]) -> OpenAPIParser::Schemas::OpenAPI
+end
+
+module OpenAPIParser
+  module Schemas
+    class OpenAPI
+      def initialize: (Hash[bot, bot] hash, untyped config, uri: OpenAPIParser::readable_uri?, schema_registry: Hash[bot, bot]) -> OpenAPIParser::Schemas::OpenAPI
+    end
+  end
+end

data/sig/types.rbs

@@ -0,0 +1,8 @@
+module OpenURI
+  module OpenRead
+    def open: () -> (IO | nil)
+    def path: () -> String
+    def scheme: () -> String
+  end
+end
+

data/sig/wip_types.rbs

@@ -0,0 +1,67 @@
+module OpenAPIParser
+  type readable_uri = URI::Generic | OpenURI::OpenRead
+  type validate_error = nil
+end
+                 
+module OpenAPIParser
+  module Schemas
+    class Schema
+    end
+  end
+end
+
+class OpenAPIParser::SchemaValidator::Base
+end
+
+class OpenAPIParser::SchemaValidator::StringValidator
+end
+
+class OpenAPIParser::SchemaValidator::IntegerValidator
+end
+
+class OpenAPIParser::SchemaValidator::FloatValidator
+end
+
+class OpenAPIParser::SchemaValidator::BooleanValidator
+end
+
+class OpenAPIParser::SchemaValidator::ObjectValidator
+end
+
+class OpenAPIParser::SchemaValidator::ArrayValidator
+end
+
+class OpenAPIParser::SchemaValidator::AnyOfValidator
+end
+
+class OpenAPIParser::SchemaValidator::AllOfValidator
+end
+
+class OpenAPIParser::SchemaValidator::OneOfValidator
+end
+
+class OpenAPIParser::SchemaValidator::NilValidator
+end
+
+class OpenAPIParser::SchemaValidator::UnspecifiedTypeValidator
+end
+
+class OpenAPIParser::Schemas::OpenAPI < OpenAPIParser::Schemas::Base 
+  attr_reader paths: untyped
+end
+
+module OpenAPIParser::Expandable
+  def expand_reference: (OpenAPIParser::Schemas::OpenAPI root) -> nil
+end
+
+module OpenAPIParser::Findable
+  def find_object: (String reference) -> ::OpenAPIParser::Schemas::Schema
+end
+
+class OpenAPIParser::Schemas::Discriminator < OpenAPIParser::Schemas::Base
+  attr_reader property_name: (String | nil)
+  attr_reader mapping: Hash[String, String] 
+end
+
+class OpenAPIParser::OpenAPIError
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: openapi_parser
 version: !ruby/object:Gem::Version
-  version: 0.13.0
+  version: 1.0.0.beta1
 platform: ruby
 authors:
 - ota42y
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-05-02 00:00:00.000000000 Z
+date: 2021-12-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -122,6 +122,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: steep
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: parser for OpenAPI 3.0 or later
 email:
 - ota42y@gmail.com
@@ -129,17 +143,19 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/ci.yaml"
 - ".gitignore"
 - ".rspec"
 - ".rubocop.yml"
 - ".rubocop_ignore.yml"
-- ".travis.yml"
+- ".ruby-version"
 - CHANGELOG.md
 - CODE_OF_CONDUCT.md
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
+- Steepfile
 - bin/console
 - bin/setup
 - lib/openapi_parser.rb
@@ -184,6 +200,7 @@ files:
 - lib/openapi_parser/schema_validators/one_of_validator.rb
 - lib/openapi_parser/schema_validators/options.rb
 - lib/openapi_parser/schema_validators/string_validator.rb
+- lib/openapi_parser/schema_validators/unspecified_type_validator.rb
 - lib/openapi_parser/schemas.rb
 - lib/openapi_parser/schemas/base.rb
 - lib/openapi_parser/schemas/classes.rb
@@ -203,6 +220,15 @@ files:
 - lib/openapi_parser/schemas/schema.rb
 - lib/openapi_parser/version.rb
 - openapi_parser.gemspec
+- sig/openapi_parser.rbs
+- sig/openapi_parser/config.rbs
+- sig/openapi_parser/schema_validator.rbs
+- sig/openapi_parser/schema_validators/base.rbs
+- sig/openapi_parser/schema_validators/options.rbs
+- sig/openapi_parser/schemas/base.rbs
+- sig/openapi_parser/version.rbs
+- sig/types.rbs
+- sig/wip_types.rbs
 homepage: https://github.com/ota42y/openapi_parser
 licenses:
 - MIT
@@ -215,14 +241,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.6.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
-rubygems_version: 3.2.3
+rubygems_version: 3.2.32
 signing_key:
 specification_version: 4
 summary: OpenAPI3 parser

data/.travis.yml

@@ -1,38 +0,0 @@
-env:
-  global:
-    - CC_TEST_REPORTER_ID=b49a1717b8ff0aef9eced41d0f87d350a88b46d55083ba2e3df8b6f441ae3fb7
-
-language: ruby
-
-rvm:
-  - 2.3.8
-  - 2.4.10
-  - 2.5.9
-  - 2.6.7
-  - 2.7.3
-  - 3.0.1
-  - ruby-head
-
-cache: bundler
-
-before_script:
-  - curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-latest-linux-amd64 > ./cc-test-reporter
-  - chmod +x ./cc-test-reporter
-  - ./cc-test-reporter before-build
-
-script: bundle exec rspec
-
-after_script:
-  - ./cc-test-reporter after-build --exit-code $TRAVIS_TEST_RESULT
-
-notifications:
-  email: false
-
-sudo: false
-
-git:
-  depth: 10
-
-matrix:
-  allow_failures:
-    - rvm: ruby-head