oas_parser_reborn 0.25.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 00fed3bd57371f47346c380e218c0907517658ad06e66bc61973d5f4d24c9d14
+  data.tar.gz: fb27996947cf7a831de3d319e252b6073b07117d11d49b532586c4e90f88e005
+SHA512:
+  metadata.gz: b6c8eb9e53ddef35aa9f1b9156099de649406dacc72a61933344489e244ffa4956c9a5c3042a3ed1d47cbdb20d75bf765d5cedaee2f4b8d6035dd0de2628c180
+  data.tar.gz: 4f7ae5c53b96a559a4eee90225d3c7403836a92c3e7793041727e4fc7d857cba317f97cea6ca34949018c3d4dd35d2bfa2b0c580433219d83f461f0466309296

data/CHANGELOG.md

@@ -0,0 +1,4 @@
+## 0.25.5
+
+- Only add token from nested_doc if key exists on nested_doc
+

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in oas_parser_reborn.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Adam Butler
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,114 @@
+
+[![Gem Version](https://badge.fury.io/rb/oas_parser_reborn.svg)](https://rubygems.org/gems/oas_parser_reborn)
+[![Build Status](https://travis-ci.com/MarioRuiz/oas_parser_reborn.svg?branch=master)](https://github.com/MarioRuiz/oas_parser_reborn)
+[![Coverage Status](https://coveralls.io/repos/github/MarioRuiz/oas_parser_reborn/badge.svg?branch=master)](https://coveralls.io/github/MarioRuiz/oas_parser_reborn?branch=master)
+![Gem](https://img.shields.io/gem/dt/oas_parser_reborn)
+![GitHub commit activity](https://img.shields.io/github/commit-activity/y/MarioRuiz/oas_parser_reborn)
+![GitHub last commit](https://img.shields.io/github/last-commit/MarioRuiz/oas_parser_reborn)
+![GitHub code size in bytes](https://img.shields.io/github/languages/code-size/MarioRuiz/oas_parser_reborn)  
+This repository is a fork of [nexmo/oas_parser](nexmo/oas_parser) that is no longer maintained. So in case you want to contribute do it here.
+
+---
+
+# Open API Definition Parser
+
+A Ruby parser for Open API Spec 3.0+ definitions.
+
+### Install
+
+Install the gem:
+
+```
+$ gem install oas_parser_reborn
+```
+
+Or add it to your Gemfile:
+
+```ruby
+gem 'oas_parser_reborn'
+```
+
+### Usage
+
+Here is a basic example of how you can traverse through an Open API Spec 3 Definition:
+
+```ruby
+require 'oas_parser_reborn'
+
+definition = OasParser::Definition.resolve('petstore.yml')
+# => #<OasParser::Definition>
+
+# Get a specific path
+path = definition.path_by_path('/pets')
+# => #<OasParser::Path>
+
+# Get all paths.
+definition.paths
+# => [#<OasParser::Path>, ...]
+
+# Get a specific endpoint by method
+endpoint = path.endpoint_by_method('get')
+# => #<OasParser::Endpoint>
+
+# Get all endpoints
+path.endpoints
+# => [#<OasParser::Endpoint>, ...]
+
+# Get endpoint description
+endpoint.description
+# => "Returns all pets from the system that the user has access to"
+```
+
+Checkout the tests and `lib` directory for more classes and methods.
+
+### Development
+
+Run tests:
+
+```
+$ rspec
+```
+
+### Publishing
+
+Clone the repo and navigate to its directory:
+
+```
+$ cd oas_parser_reborn
+```
+
+Bump the latest version in `oas_parser_reborn/lib/oas_parser_reborn/version.rb`:
+
+```
+//old
+module OasParser
+  VERSION = '1.0.0'.freeze
+end
+
+//new
+module OasParser
+  VERSION = '1.1.0'.freeze
+end
+```
+
+Build the gem:
+
+```
+$ gem build oas_parser_reborn.gemspec
+```
+
+_This will create a `oas_parser_reborn-1.1.0.gem` file._
+
+Push the gem to rubygems.org:
+
+```
+$ gem push oas_parser_reborn-1.1.0.gem
+```
+
+Verify the change was made by checking for the [new version on rubygems.org](https://rubygems.org/gems/oas_parser_reborn)
+
+
+
+## Contributing
+
+Contributions are welcome, please follow [GitHub Flow](https://guides.github.com/introduction/flow/index.html)

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/lib/oas_parser_reborn/abstract_attribute.rb

@@ -0,0 +1,89 @@
+module OasParser
+  class AbstractAttribute
+    include OasParser::RawAccessor
+
+    def initialize(name)
+      @name = name
+    end
+
+    def name(format = nil)
+      default = @name || raw['name']
+      return default unless format
+      case format
+      when 'text/xml'
+        has_xml_name? ? xml_name : default
+      else default
+      end
+    end
+
+    def enum
+      raw['enum'] || (schema ? schema['enum'] : nil)
+    end
+
+    def allOf?
+      raw['allOf'] ? true : false
+    end
+
+    def oneOf?
+      raw['oneOf'] ? true : false
+    end
+
+    def array?
+      type == 'array'
+    end
+
+    def object?
+      type == 'object'
+    end
+
+    def collection?
+      array? || object?
+    end
+
+    def empty?
+      raise 'Called empty? on non collection type' unless collection?
+      return true if object? && raw['properties'].blank?
+      return true if array? && items.blank?
+      false
+    end
+
+    def properties
+      return convert_property_schema_to_properties(raw) if (oneOf? || allOf?)
+      return nil unless collection?
+      return [] if empty?
+      return convert_property_schema_to_properties(raw['properties']) if object?
+      return convert_property_schema_to_properties(items) if array?
+      nil
+    end
+
+    def has_xml_options?
+      raw['xml'].present?
+    end
+
+    def is_xml_attribute?
+      return false unless has_xml_options?
+      raw['xml']['attribute'] || false
+    end
+
+    def is_xml_text?
+      # See: https://github.com/OAI/OpenAPI-Specification/issues/630#issuecomment-350680346
+      return false unless has_xml_options?
+      return true if raw['xml']['text'] || false
+      raw['xml']['x-text'] || false
+    end
+
+    def has_xml_name?
+      return false unless has_xml_options?
+      xml_name || false
+    end
+
+    def xml_name
+      raw['xml']['name']
+    end
+
+    def subproperties_are_one_of_many?
+      return false unless array?
+      items['oneOf'].present?
+    end
+  end
+end

data/lib/oas_parser_reborn/callback.rb

@@ -0,0 +1,20 @@
+module OasParser
+  class Callback < Payload
+    include OasParser::RawAccessor
+    raw_keys :description, :content
+
+    attr_accessor :endpoint, :name, :raw
+
+    def initialize(endpoint, name, raw)
+      @endpoint = endpoint
+      @name = name
+      @raw = raw
+    end
+
+    def paths
+      raw.map do |path, definition|
+        OasParser::Path.new(self, path, definition)
+      end
+    end
+  end
+end

data/lib/oas_parser_reborn/definition.rb

@@ -0,0 +1,61 @@
+require 'mustermann/template'
+
+module OasParser
+  class Definition
+    include OasParser::RawAccessor
+    raw_keys :info, :servers, :components, :openapi
+    attr_reader :path
+
+    attr_accessor :raw
+
+    def self.resolve(path)
+      raw = Parser.resolve(path)
+      Definition.new(raw, path)
+    end
+
+    def initialize(raw, path)
+      @raw = raw
+      @path = path
+    end
+
+    def format
+      File.extname(@path).sub('.', '')
+    end
+
+    def paths
+      raw['paths'].map do |path, definition|
+        OasParser::Path.new(self, path, definition)
+      end
+    end
+
+    def path_by_path(path)
+      definition = raw['paths'][path]
+      return OasParser::Path.new(self, path, definition) if definition
+      key = raw['paths'].keys.detect do |path_entry|
+        Mustermann::Template.new(path_entry).match(path)
+      end
+      definition = raw['paths'][key]
+      raise OasParser::PathNotFound.new("Path not found: '#{path}'") unless definition
+      OasParser::Path.new(self, key, definition)
+    end
+
+    def security
+      raw['security'] || []
+    end
+
+    def tags
+      raw['tags'] || []
+    end
+
+    def endpoints
+      paths.flat_map(&:endpoints)
+    end
+
+    def webhooks
+      return [] unless raw['webhooks']
+      raw['webhooks'].map do |name, definition|
+        OasParser::Webhook.new(self, name, definition)
+      end
+    end
+  end
+end

data/lib/oas_parser_reborn/endpoint.rb

@@ -0,0 +1,137 @@
+module OasParser
+  class Endpoint
+    include OasParser::RawAccessor
+    raw_keys :summary, :description, :operationId, :tags, :required
+
+    attr_accessor :path, :method, :raw
+
+    def initialize(path, method, raw)
+      @path = path
+      @method = method
+      @raw = raw
+    end
+
+    def definition
+      path.definition
+    end
+
+    def operation_id
+      operationId
+    end
+
+    def parameters
+      security_schema_parameters + local_parameters + path.parameters
+    end
+
+    def path_parameters
+      parameters.select { |parameter| parameter.in == 'path' }
+    end
+
+    def query_parameters
+      parameters.select { |parameter| parameter.in == 'query' }
+    end
+
+    def security_schema_parameters
+      raw_security_schema_parameters = security_schemes.select do |security_schema|
+        security_schema['in'].present? && security_schema['in'].present?
+      end
+
+      security_schema_parameter_defaults = {
+        'type' => 'string',
+        'example' => 'abc123',
+        'default' => false,
+      }
+
+      raw_security_schema_parameters.map do |definition|
+        definition = security_schema_parameter_defaults.merge(definition)
+        OasParser::Parameter.new(self, definition)
+      end
+    end
+
+    def parameter_by_name(name)
+      parameters.each do |parameter|
+        return parameter if parameter.name == name
+      end
+
+      raise OasParser::ParameterNotFound.new("Parameter not found: '#{name}'")
+    end
+
+    def request_body
+      return false unless raw['requestBody']
+      OasParser::RequestBody.new(self, raw['requestBody'])
+    end
+
+    def responses
+      raw['responses'].map do |code, definition|
+        OasParser::Response.new(self, code, definition)
+      end
+    end
+
+    def response_by_code(code, use_default: false)
+      definition = raw['responses'][code]
+      definition ||= raw['responses']['default'] if use_default
+      raise OasParser::ResponseCodeNotFound.new("Response code not found: '#{code}'") unless definition
+      OasParser::Response.new(self, code, definition)
+    end
+
+    def security
+      raw['security'] || []
+    end
+
+    def callbacks
+      return [] unless raw['callbacks']
+      raw['callbacks'].map do |name, definition|
+        OasParser::Callback.new(self, name, definition)
+      end
+    end
+
+    def callback_by_name(name)
+      definition = raw['callbacks'][name]
+      raise OasParser::CallbackNotFound.new("Callback not found: '#{name}'") unless definition
+      OasParser::Callback.new(self, name, definition)
+    end
+
+    def jwt?
+      return false unless security
+
+      security_schemes.each do |security_schema|
+        return true if security_schema['bearerFormat'] == 'JWT'
+      end
+
+      false
+    end
+
+    def basic_auth?
+      return false unless security
+
+      security_schemes.each do |security_schema|
+        return true if security_schema['type'] == 'http' && security_schema['scheme'] == 'basic'
+      end
+
+      false
+    end
+
+    def security_schemes
+      security_schemes = security.flat_map(&:keys)
+
+      if definition
+        security_schemes = security_schemes + definition.security.flat_map(&:keys)
+      end
+
+      security_schemes = security_schemes.uniq
+
+      security_schemes.map do |security_scheme_name|
+        definition.components['securitySchemes'][security_scheme_name]
+      end
+    end
+
+    private
+
+    def local_parameters
+      return [] unless raw['parameters']
+      raw['parameters'].map do |definition|
+        OasParser::Parameter.new(self, definition)
+      end
+    end
+  end
+end

data/lib/oas_parser_reborn/errors.rb

@@ -0,0 +1,8 @@
+module OasParser
+  class Error < StandardError; end
+  class CallbackNotFound < Error; end
+  class MethodNotFound < Error; end
+  class ParameterNotFound < Error; end
+  class PathNotFound < Error; end
+  class ResponseCodeNotFound < Error; end
+end

data/lib/oas_parser_reborn/parameter.rb

@@ -0,0 +1,44 @@
+module OasParser
+  class Parameter < AbstractAttribute
+    raw_keys :in, :description, :style, :schema,
+             :minimum, :maximum, :required, :nullable
+
+    attr_accessor :owner, :raw
+
+    def initialize(owner, raw)
+      super(raw['name'])
+      @owner = owner
+      @raw = raw
+    end
+
+    def type
+      raw['type'] || (schema ? schema['type'] : nil)
+    end
+
+    def format
+      raw['format'] || (schema ? schema['format'] : nil)
+    end
+
+    def items
+      schema['items']
+    end
+
+    def example
+      raw['example'] || (schema ? schema['example'] : nil)
+    end
+
+    def default
+      raw['default'] || (schema ? schema['default'] : nil)
+    end
+
+    def nullable?
+      raw['nullable'] || (schema ? schema['nullable'] : nil )
+    end
+
+    def convert_property_schema_to_properties(schema)
+      schema.map do |name, definition|
+        OasParser::Property.new(self, raw, name, definition)
+      end
+    end
+  end
+end

data/lib/oas_parser_reborn/parser.rb

@@ -0,0 +1,77 @@
+module OasParser
+  class Parser
+    def self.resolve(path)
+      content = YAML.load_file(path)
+      Parser.new(path, content).resolve
+    end
+
+    def initialize(path, content)
+      @path = path
+      @content = content
+    end
+
+    def resolve
+      deeply_expand_refs(@content, nil)
+    end
+
+    private
+
+    def deeply_expand_refs(fragment, path)
+      fragment, current_path = expand_refs(fragment, path)
+
+      if fragment.is_a?(Hash)
+        fragment.reduce({}) do |hash, (k, v)|
+          hash.merge(k => deeply_expand_refs(v, "#{current_path}/#{k}"))
+        end
+      elsif fragment.is_a?(Array)
+        fragment.map { |e| deeply_expand_refs(e, current_path) }
+      else
+        fragment
+      end
+    end
+
+    def expand_refs(fragment, current_path)
+      unless fragment.is_a?(Hash) && fragment.key?("$ref")
+        return [fragment, current_path]
+      end
+
+      ref = fragment["$ref"]
+
+      if ref =~ /^#/
+        expand_pointer(ref, current_path)
+      elsif ref =~ /^(http(s)?|\/\/)/
+        expand_url(ref)
+      else
+        expand_file(ref)
+      end
+    end
+
+    def expand_file(ref)
+      absolute_path = File.expand_path(File.join("..", ref), @path)
+      absolute_path, local_reference = absolute_path.split('#')
+      resolved_remote_reference = Parser.resolve(absolute_path)
+
+      if local_reference
+        pointer = OasParser::Pointer.new(local_reference)
+        return pointer.resolve(resolved_remote_reference)
+      end
+
+      resolved_remote_reference
+    end
+
+    def expand_pointer(ref, current_path)
+      pointer = OasParser::Pointer.new(ref)
+
+      if pointer.circular_reference?(current_path)
+        { "$ref" => ref }
+      else
+        fragment = pointer.resolve(@content)
+        expand_refs(fragment, current_path + pointer.escaped_pointer)
+      end
+    end
+
+    def expand_url(ref)
+      raise 'Expanding URL References is not supported'
+    end
+  end
+end

data/lib/oas_parser_reborn/path.rb

@@ -0,0 +1,45 @@
+module OasParser
+  class Path
+    attr_accessor :owner, :path, :raw
+
+    def initialize(owner, path, raw)
+      @owner = owner
+      @path = path
+      @raw = raw
+    end
+
+    def endpoints
+      a = raw.map do |method, definition|
+        next unless %w[get head post put patch delete trace options].include? method
+        OasParser::Endpoint.new(self, method, definition)
+      end
+
+      a.compact
+    end
+
+    def endpoint_by_method(method)
+      definition = raw[method]
+      raise OasParser::MethodNotFound.new("HTTP method not found: '#{method}'") unless definition
+      OasParser::Endpoint.new(self, method, definition)
+    end
+
+    def parameter_keys
+      path.scan(/{(.+?)}/).flatten
+    end
+
+    def parameters
+      return [] unless raw['parameters']
+      raw['parameters'].map do |definition|
+        OasParser::Parameter.new(self, definition)
+      end
+    end
+
+    def definition
+      owner if owner.class == OasParser::Definition
+    end
+
+    def callback
+      owner if owner.class == OasParser::Callback
+    end
+  end
+end

data/lib/oas_parser_reborn/payload.rb

@@ -0,0 +1,21 @@
+module OasParser
+  class Payload
+    def formats
+      return [] unless content
+      content.keys
+    end
+
+    def schema(format)
+      content[format]['schema']
+    end
+
+    def split_schemas(format)
+      content[format]['schema']['oneOf']
+    end
+
+    def exhibits_one_of_multiple_schemas?(format)
+      return false unless content
+      schema(format).keys.include?('oneOf')
+    end
+  end
+end