openapi_parser 0.9.0 → 0.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e01493b04243073a1fec0acaa56db780076e3c30f3a64534da419bd745408b87
-  data.tar.gz: 1e57cd341560e800018fa82bbc4801910bbdfdf4a580ccbdaaa63fa0fe442d4a
+  metadata.gz: 77010f8eb5e5b8dd1dadd5e365fb13cf11619215f19c38bcd8d6b46bb3927c80
+  data.tar.gz: f2b4a9f19eddc1fba4eefb6d74e6c5f0cd285712aa70b7b3970c5b6121701beb
 SHA512:
-  metadata.gz: 28182a2367a7ff7314f0c8b35c51d321ce7ce6e9238cd72c83bd57e3cb1970bc9000e19b6a725a47b14ed6262befff61dd325106f9a1389bd72ffa7de7230fe2
-  data.tar.gz: 0c5560de5b4579933d135d0046a3ae4aaa3e701d83779ff8efd0713023ad5f6d6f37b485f41fa9eb3c3ac5b26c1118afe724d2b9787440e1bfd229c6f0d823a9
+  metadata.gz: 90d397850737878d78fd697ab6a60ec004b47496bad48a246226cce54c1835c7c8ee1725c02f09fe581827c76a16bd8af62d1b0310d8cefaca67b3ff480ab863
+  data.tar.gz: 4d227f8b4497cb297fcf73515914c15ecc05060f3e30d275bf5e493124e4b6bd23b47e5f6f95a80a519ba74d7da5f51612820fe52867d1da58c4a92cfc7283ff

data/.gitignore

@@ -7,6 +7,9 @@
 /spec/reports/
 /tmp/
 
+# RubyMine
+.idea
+
 # rspec failure tracking
 .rspec_status
-Gemfile.lock
+Gemfile.lock

data/.travis.yml

@@ -6,9 +6,10 @@ language: ruby
 
 rvm:
   - 2.3.8
-  - 2.4.6
-  - 2.5.5
-  - 2.6.3
+  - 2.4.10
+  - 2.5.8
+  - 2.6.6
+  - 2.7.1
   - ruby-head
 
 cache: bundler

data/CHANGELOG.md

@@ -1,5 +1,24 @@
 ## Unreleased
 
+* Find path by extracted params than path length #84
+* Unescape ref URI before lookup in OpenAPIParser::Findable #85
+* Improved path parameter matching code to allow file extensions, multiple parameters inside one path element, etc #90
+
+## 0.11.2 (2020-05-23)
+* Allow date and time content in YAML #81
+
+## 0.11.1 (2020-05-09)
+* fix too many warning
+
+## 0.11.0 (2020-05-09)
+* Add committee friendly interface to use remote references. #74
+* Prevent SystemStackError on recursive schema reference #76
+* support newest ruby versions #78
+
+## 0.10.0 (2020-04-01)
+* Support $ref to objects in other OpenAPI yaml files #66
+* Allow $ref for path item objects #71
+
 ## 0.9.0 (2020-03-22)
 * Added support for validating UUID formatted strings #67
 

data/lib/openapi_parser.rb

@@ -1,4 +1,9 @@
+require 'uri'
 require 'time'
+require 'json'
+require 'psych'
+require 'pathname'
+require 'open-uri'
 
 require 'openapi_parser/version'
 require 'openapi_parser/config'
@@ -13,14 +18,82 @@ require 'openapi_parser/reference_expander'
 
 module OpenAPIParser
   class << self
+    # Load schema hash object. Uri is not set for returned schema.
     # @return [OpenAPIParser::Schemas::OpenAPI]
     def parse(schema, config = {})
-      c = Config.new(config)
-      root = Schemas::OpenAPI.new(schema, c)
+      load_hash(schema, config: Config.new(config), uri: nil, schema_registry: {})
+    end
+
+    # @param filepath [String] Path of the file containing the passed schema.
+    #   Used for resolving remote $ref if provided.
+    #   If file path is relative, it is resolved using working directory.
+    # @return [OpenAPIParser::Schemas::OpenAPI]
+    def parse_with_filepath(schema, filepath, config = {})
+      load_hash(schema, config: Config.new(config), uri: filepath && file_uri(filepath), schema_registry: {})
+    end
 
-      OpenAPIParser::ReferenceExpander.expand(root) if c.expand_reference
+    # Load schema in specified filepath. If file path is relative, it is resolved using working directory.
+    # @return [OpenAPIParser::Schemas::OpenAPI]
+    def load(filepath, config = {})
+      load_uri(file_uri(filepath), config: Config.new(config), schema_registry: {})
+    end
+
+    # Load schema located by the passed uri. Uri must be absolute.
+    # @return [OpenAPIParser::Schemas::OpenAPI]
+    def load_uri(uri, config:, schema_registry:)
+      # 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)
+      end
 
-      root
+      extension = Pathname.new(uri.path).extname
+      load_hash(parse_file(content, extension), config: config, uri: uri, schema_registry: schema_registry)
     end
+
+    private
+
+      def file_uri(filepath)
+        path = Pathname.new(filepath)
+        path = Pathname.getwd + path if path.relative?
+        URI.join("file:///",  path.to_s)
+      end
+
+      def parse_file(content, extension)
+        case extension.downcase
+        when '.yaml', '.yml'
+          parse_yaml(content)
+        when '.json'
+          parse_json(content)
+        else
+          # When extension is something we don't know, try to parse as json first. If it fails, parse as yaml
+          begin
+            parse_json(content)
+          rescue JSON::ParserError
+            parse_yaml(content)
+          end
+        end
+      end
+
+      def parse_yaml(content)
+        # FIXME: when drop ruby 2.5, we should use permitted_classes
+        (Gem::Version.create(RUBY_VERSION) < Gem::Version.create("2.6.0")) ? 
+          Psych.safe_load(content, [Date, Time]) : 
+          Psych.safe_load(content, permitted_classes: [Date, Time])
+      end
+
+      def parse_json(content)
+        JSON.parse(content)
+      end
+
+      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
+
+        root
+      end
   end
 end

data/lib/openapi_parser/concerns/findable.rb

@@ -1,9 +1,14 @@
+require 'uri'
+
 module OpenAPIParser::Findable
   # @param [String] reference
   # @return [OpenAPIParser::Findable]
   def find_object(reference)
-    return nil unless reference.start_with?(object_reference)
+    reference = URI.unescape(reference)
     return self if object_reference == reference
+    remote_reference = !reference.start_with?('#')
+    return find_remote_object(reference) if remote_reference
+    return nil unless reference.start_with?(object_reference)
 
     @find_object_cache = {} unless defined? @find_object_cache
     if (obj = @find_object_cache[reference])
@@ -26,8 +31,22 @@ module OpenAPIParser::Findable
   end
 
   def purge_object_cache
+    @purged = false unless defined? @purged
+
+    return if @purged
+
     @find_object_cache = {}
+    @purged = true
 
     _openapi_all_child_objects.values.each(&:purge_object_cache)
   end
+
+  private
+
+    def find_remote_object(reference)
+      reference_uri = URI(reference)
+      fragment = reference_uri.fragment
+      reference_uri.fragment = nil
+      root.load_another_schema(reference_uri)&.find_object("##{fragment}")
+    end
 end

data/lib/openapi_parser/errors.rb

@@ -178,6 +178,17 @@ module OpenAPIParser
     end
   end
 
+  class InvalidUUIDFormat < OpenAPIError
+    def initialize(value, reference)
+      super(reference)
+      @value = value
+    end
+
+    def message
+      "#{@reference} Value: #{@value} is not conformant with UUID format"
+    end
+  end
+
   class NotExistStatusCodeDefinition < OpenAPIError
     def message
       "#{@reference} status code definition does not exist"

data/lib/openapi_parser/path_item_finder.rb

@@ -38,7 +38,41 @@ class OpenAPIParser::PathItemFinder
     end
   end
 
+  def parse_path_parameters(schema_path, request_path)
+    parameters = path_parameters(schema_path)
+    return nil if parameters.empty?
+
+    # If there are regex special characters in the path, the regex will
+    # be too permissive, so escape the non-parameter parts.
+    components = []
+    unprocessed = schema_path.dup
+    parameters.each do |parameter|
+      parts = unprocessed.partition(parameter)
+      components << Regexp.escape(parts[0]) unless parts[0] == ''
+      components << "(?<#{param_name(parameter)}>.+)"
+      unprocessed = parts[2]
+    end
+    components << Regexp.escape(unprocessed) unless unprocessed == ''
+
+    regex = components.join('')
+    matches = request_path.match(regex)
+    return nil unless matches
+
+    # Match up the captured names with the captured values as a hash
+    matches.names.zip(matches.captures).to_h
+  end
+
   private
+    def path_parameters(schema_path)
+      # OAS3 follows a RFC6570 subset for URL templates
+      # https://swagger.io/docs/specification/serialization/#uri-templates
+      # A URL template param can be preceded optionally by a "." or ";", and can be succeeded optionally by a "*";
+      # this regex returns a match of the full parameter name with all of these modifiers. Ex: {;id*}
+      parameters = schema_path.scan(/(\{[\.;]*[^\{\*\}]+\**\})/)
+      # The `String#scan` method returns an array of arrays; we want an array of strings
+      parameters.collect { |param| param[0] }
+    end
+
     # check if there is a identical path in the schema (without any param)
     def matches_directly?(request_path, http_method)
       @paths.path[request_path]&.operation(http_method)
@@ -70,8 +104,9 @@ class OpenAPIParser::PathItemFinder
       splitted_request_path.zip(splitted_schema_path).reduce({}) do |result, zip_item|
         request_path_item, schema_path_item = zip_item
 
-        if path_template?(schema_path_item)
-          result[param_name(schema_path_item)] = request_path_item
+        params = parse_path_parameters(schema_path_item, request_path_item)
+        if params
+          result.merge!(params)
         else
           return if schema_path_item != request_path_item
         end
@@ -80,7 +115,7 @@ class OpenAPIParser::PathItemFinder
       end
     end
 
-    # find all matching patchs with parameters extracted
+    # find all matching paths with parameters extracted
     # EXAMPLE:
     # [
     #    ['/user/{id}/edit', { 'id' => 1 }],
@@ -94,7 +129,7 @@ class OpenAPIParser::PathItemFinder
         splitted_schema_path = path.split('/')
 
         next result if different_depth_or_method?(splitted_schema_path, splitted_request_path, path_item, http_method)
-        
+
         extracted_params = extract_params(splitted_request_path, splitted_schema_path)
         result << [path, extracted_params] if extracted_params
         result
@@ -105,12 +140,12 @@ class OpenAPIParser::PathItemFinder
     # EXAMPLE: find_path_and_params('get', '/user/1') => ['/user/{id}', { 'id' => 1 }]
     def find_path_and_params(http_method, request_path)
       return [request_path, {}] if matches_directly?(request_path, http_method)
-      
+
       matching = matching_paths_with_params(request_path, http_method)
 
       # if there are many matching paths, return the one with the smallest number of params
       # (prefer /user/{id}/action over /user/{param_1}/{param_2} )
-      matching.min_by { |match| match[0].size } 
+      matching.min_by { |match| match[1].size }
     end
 
     def parse_request_path(http_method, request_path)

data/lib/openapi_parser/schema_validators/base.rb

@@ -34,7 +34,7 @@ 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})
     end
   end
 end

data/lib/openapi_parser/schema_validators/string_validator.rb

@@ -27,6 +27,9 @@ class OpenAPIParser::SchemaValidator
       value, err = validate_email_format(value, schema)
       return [nil, err] if err
 
+      value, err = validate_uuid_format(value, schema)
+      return [nil, err] if err
+
       [value, nil]
     end
 
@@ -75,5 +78,13 @@ class OpenAPIParser::SchemaValidator
 
         return [nil, OpenAPIParser::InvalidEmailFormat.new(value, schema.object_reference)]
       end
+
+      def validate_uuid_format(value, schema)
+        return [value, nil] unless schema.format == 'uuid'
+
+        return [value, nil] if value.match(/[0-9a-fA-F]{8}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{12}/)
+
+        return [nil, OpenAPIParser::InvalidUUIDFormat.new(value, schema.object_reference)]
+      end
   end
 end

data/lib/openapi_parser/schemas/openapi.rb

@@ -5,11 +5,16 @@
 
 module OpenAPIParser::Schemas
   class OpenAPI < Base
-    def initialize(raw_schema, config)
+    def initialize(raw_schema, config, uri: nil, schema_registry: {})
       super('#', nil, self, raw_schema)
       @find_object_cache = {}
       @path_item_finder = OpenAPIParser::PathItemFinder.new(paths) if paths # invalid definition
       @config = config
+      @uri = uri
+      @schema_registry = schema_registry
+
+      # schema_registery is shared among schemas, and prevents a schema from being loaded multiple times
+      schema_registry[uri] = self if uri
     end
 
     # @!attribute [r] openapi
@@ -28,5 +33,27 @@ module OpenAPIParser::Schemas
     def request_operation(http_method, request_path)
       OpenAPIParser::RequestOperation.create(http_method, request_path, @path_item_finder, @config)
     end
+
+    # load another schema with shared config and schema_registry
+    # @return [OpenAPIParser::Schemas::OpenAPI]
+    def load_another_schema(uri)
+      resolved_uri = resolve_uri(uri)
+      return if resolved_uri.nil?
+
+      loaded = @schema_registry[resolved_uri]
+      return loaded if loaded
+
+      OpenAPIParser.load_uri(resolved_uri, config: @config, schema_registry: @schema_registry)
+    end
+
+    private
+
+      def resolve_uri(uri)
+        if uri.absolute?
+          uri
+        else
+          @uri&.merge(uri)
+        end
+      end
   end
 end

data/lib/openapi_parser/schemas/paths.rb

@@ -2,6 +2,6 @@ module OpenAPIParser::Schemas
   class Paths < Base
     # @!attribute [r] path
     #   @return [Hash{String => PathItem, Reference}, nil]
-    openapi_attr_hash_body_objects 'path', PathItem, reference: false, allow_data_type: false
+    openapi_attr_hash_body_objects 'path', PathItem, reference: true, allow_data_type: false
   end
 end

data/lib/openapi_parser/version.rb

@@ -1,3 +1,3 @@
 module OpenAPIParser
-  VERSION = '0.9.0'.freeze
+  VERSION = '0.12.0'.freeze
 end

data/openapi_parser.gemspec

@@ -24,9 +24,9 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency 'bundler', '>= 1.16'
   spec.add_development_dependency 'fincop'
-  spec.add_development_dependency 'pry'
+  spec.add_development_dependency 'pry', '~> 0.12.0'
   spec.add_development_dependency 'pry-byebug'
-  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rake', '>= 12.3.3'
   spec.add_development_dependency 'rspec', '~> 3.0'
   spec.add_development_dependency 'rspec-parameterized'
   spec.add_development_dependency 'simplecov'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: openapi_parser
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.12.0
 platform: ruby
 authors:
 - ota42y
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-03-22 00:00:00.000000000 Z
+date: 2020-08-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -42,16 +42,16 @@ dependencies:
   name: pry
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.12.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.12.0
 - !ruby/object:Gem::Dependency
   name: pry-byebug
   requirement: !ruby/object:Gem::Requirement
@@ -70,16 +70,16 @@ dependencies:
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: 12.3.3
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: 12.3.3
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement