mountapi 0.11.1

data/vendor/bundle/ruby/2.7.0/gems/openapi3_parser-0.9.1/CHANGELOG.md

@@ -0,0 +1,95 @@
+# 0.9.1
+
+- Fix Schema#requires? incorrectly returning true for referenced properties -
+  https://github.com/kevindew/openapi3_parser/issues/20
+- Drop support for Ruby 2.5
+
+# 0.9.0
+
+- Fix unexpected fields error when using Example nodes inside a Parameter -
+  https://github.com/kevindew/openapi3_parser/pull/19
+- Drop support for Ruby 2.4
+
+# 0.8.2
+
+- Fix bug falling into recursive loop on Array/Map nodes -
+  https://github.com/kevindew/openapi3_parser/issues/13
+
+# 0.8.1
+
+- Fix incorrectly spelt method name on `Schema` s/disciminator/discriminator/g
+
+# 0.8.0
+
+- Resolve deprecation warnings for Ruby 2.7
+- Resolve deprecation warnings for Psych
+- Operation and Path Item objects use servers that have cascaded from parent
+  objects if they do not have their own servers defined.
+- Add `#relative_node` and `#parent_node` methods to `Node::Context`.
+- Default to a server of "/" when given an empty or null servers input for
+  OpenAPI node.
+- Set referenced data as input and source location for a PathItem with only
+  a $ref value.
+- Fix data being lost in PathItem reference merges.
+
+# 0.7.0
+
+- Add `#values` method to `Node::Object` and `Node#Map` to have a method that
+  pairs with `#keys`
+- Add `Node::Schema#requires?` method to simplify checking whether a property
+  is required by a particular schema.
+- Add `#==` methods to Node objects. This allows checking whether two nodes
+  are from the same source location even if they're referenced in different
+  places.
+- Add `Node::Schema#name` method that looks up the name of a Schema based
+  on it's contextual position in a document. Allows accessing the `Pet` value
+  from `#/components/schemas/Pet`.
+
+# 0.6.1
+
+- Fix bug where Node::Object and Node::Map iterated arrays rather than hashes
+  on #each and other Enumerable methods
+
+# 0.6.0
+
+- Drop support for Ruby 2.3
+- Re-use references for significantly faster initialisation and validation
+- Only error when accessing an invalid node rather than at root
+- Handle infinitely recursive references that never resolve
+
+# 0.5.2
+
+- Fix outputting warnings for cyclic dependencies and undefined variables -
+  fixes: https://github.com/kevindew/openapi3_parser/issues/6
+- Add Date and Time to YAML safe classes so library doesn't crash on an
+  unquoted timestamp - fixes: https://github.com/kevindew/openapi3_parser/issues/7
+
+# 0.5.1
+
+- Bugfix for allowing maps to have extension like field names
+
+# 0.5.0
+
+- Support for recursive references - fixes: https://github.com/kevindew/openapi3_parser/issues/4
+- `node_at` method on nodes and document to allow looking up nodes by string
+  paths
+- Refactor of the node factory classes to use simpler inheritance rather than
+  the mixins in mixins approach.
+
+# 0.4.0
+
+- Determine the OpenAPI specification version and store it in document.
+- Support commonmark rendering, add description_html methods to nodes which
+  allow description to be rendered as HTML.
+- Fix bug with CGI constant unresolved
+
+# 0.3.0
+
+- Allow opening files by URL
+- Support references in different files
+
+# 0.2.0
+
+- Allow defaulting to empty arrays and maps
+- Configure rubydoc
+- Types returned documented for the nodes

data/vendor/bundle/ruby/2.7.0/gems/openapi3_parser-0.9.1/Gemfile

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+gemspec

data/vendor/bundle/ruby/2.7.0/gems/openapi3_parser-0.9.1/LICENCE

@@ -0,0 +1,19 @@
+Copyright (c) 2017 Kevin Dew
+
+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/vendor/bundle/ruby/2.7.0/gems/openapi3_parser-0.9.1/README.md

@@ -0,0 +1,139 @@
+# OpenAPI 3 Parser
+
+[![Build Status](https://travis-ci.org/kevindew/openapi3_parser.svg?branch=main)](https://travis-ci.org/kevindew/openapi3_parser)
+
+This a Ruby based parser/validator for [OpenAPI 3][openapi-3]. It is used to
+convert an OpenAPI file (can be a local file, a URL, a string or even a Ruby
+hash) into an object graph with a simple API that follows the [OpenAPI
+specification][openapi-3-spec].
+
+Basic example:
+
+```ruby
+require "openapi3_parser"
+
+document = Openapi3Parser.load_url("https://raw.githubusercontent.com/OAI/OpenAPI-Specification/master/examples/v3.0/petstore.yaml")
+
+document.paths["/pets"].get.summary
+# => "List all pets"
+```
+
+It aims to support 100% of the OpenAPI 3.0 specification, with key features
+being:
+
+- Supports loading a specification by path to a file, URL, Ruby file objects,
+  and strings in YAML and JSON formats, it even supports loading via a Ruby hash;
+- Support for loading references from external files including URLs;
+- Handles recursive references;
+- All of OpenAPI specification mapped to Ruby objects, providing a natural
+  Ruby interface that maps clearly to the specification;
+- OpenAPI files validated with a simple API to quickly and simply see all
+  problems with a file
+- Built-in Markdown to HTML conversion;
+- Documentation for the API to navigate the OpenAPI nodes is available on
+  [rubydoc.info][docs].
+
+I've wrote a blog post reflecting on the decisions involved in building this
+parser in [How to write an OpenAPI 3 parser][blog].
+
+[openapi-3]: https://github.com/OAI/OpenAPI-Specification
+[openapi-3-spec]: https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.2.md#specification
+[docs]: http://www.rubydoc.info/github/kevindew/openapi3_parser/Openapi3Parser/Node/Openapi
+[blog]: https://kevindew.me/post/188611423231/how-to-write-an-openapi-3-parser
+
+## Usage
+
+### Loading a specification
+
+```ruby
+# by URL
+Openapi3Parser.load_url("https://raw.githubusercontent.com/kevindew/openapi3_parser/main/spec/support/examples/petstore-expanded.yaml")
+
+# by path to file
+Openapi3Parser.load_file("spec/support/examples/uber.yaml")
+
+# by File
+Openapi3Parser.load(File.open("spec/support/examples/uber.yaml"))
+
+# by String
+Openapi3Parser.load('{ "openapi": "3.0.0", "info": { "title": "API", "version": "1.0.0" }, "paths": {}  }')
+
+# by Hash
+Openapi3Parser.load(openapi: "3.0.0", info: { title: "API", version: "1.0.0" }, paths: {})
+
+```
+
+### Validating
+
+```ruby
+document = Openapi3Parser.load(openapi: "3.0.0", info: {}, paths: {})
+document.valid?
+# => false
+document.errors
+# => Openapi3Parser::Validation::ErrorCollection(errors: {"#/info"=>["Missing required fields: title and version"]})
+```
+
+### Traversing
+
+```ruby
+document = Openapi3Parser.load_url("https://raw.githubusercontent.com/kevindew/openapi3_parser/main/spec/support/examples/petstore-expanded.yaml")
+
+# by objects
+
+document.info.terms_of_service
+# => "http://swagger.io/terms/"
+
+document.paths.keys
+# => ["/pets", "/pets/{id}"]
+
+document.paths["/pets"].get.parameters.map(&:name)
+# => ["tags", "limit"]
+
+# by hash syntax
+
+document["info"]["termsOfService"]
+=> "http://swagger.io/terms/"
+
+document["paths"].keys
+# => ["/pets", "/pets/{id}"]
+
+document["paths"]["/pets"]["get"]["parameters"].map(&:name)
+# => ["tags", "limit"]
+
+# by a path to a node
+document.node_at("#/paths/%2Fpets/get/operationId")
+=> "findPets"
+
+document.node_at("#/components/schemas/Pet/allOf/0/required/0")
+=> "name"
+
+# or combining
+
+document.components.schemas["Pet"].node_at("#../NewPet")
+=> Openapi3Parser::Node::Schema(#/components/schemas/NewPet)
+```
+
+You can learn more about the API on [rubydoc.info][docs]
+
+## Installation
+
+You can install this gem into your bundler application by adding this line to
+your Gemfile:
+
+```
+gem "openapi3_parser", "~> 0.9.0"
+```
+
+and then running `$ bundle install`
+
+Or install the gem onto your machine via `$ gem install openapi3_parser`
+
+## Status
+
+This is currently a work in progress and will remain so until it reaches 1.0.
+
+See [TODO](TODO.md) for details of the features still to implement.
+
+## Licence
+
+[MIT License](LICENCE)

data/vendor/bundle/ruby/2.7.0/gems/openapi3_parser-0.9.1/Rakefile

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+require "rubocop/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+RuboCop::RakeTask.new
+
+task default: %I[rubocop spec]

data/vendor/bundle/ruby/2.7.0/gems/openapi3_parser-0.9.1/TODO.md

@@ -0,0 +1,41 @@
+# Todo
+
+These are the steps defined to reach 1.0. Assistance is very welcome.
+
+- [x] Handle mutually exclusive fields
+- [x] Refactor the various NodeFactory modules to be a less confusing
+      hierachical structure. Consider having factories subclass instead of use
+      mixin
+- [x] Decouple Document class for the source file. Consider a source file class
+      instead
+- [x] Validate that a reference creates the type of node that is expected in
+      a context
+- [x] Allow opening of references from additional files
+- [x] Allow opening of openapi documents by URL
+- [x] Support references by URL
+- [ ] Consider option to limit open by URL/path behaviour
+- [x] Support converting CommonMark to HTML
+- [ ] Reach parity with OpenAPI specification for validation
+- [ ] Consider a lenient mode for a document to only have to comply with type
+      based validation
+- [x] Improve test coverage
+- [ ] Publish documentation of the interface through the structure
+- [x] Consider a resolved context class for representing context with a node
+      that can handle scenarios where a node is represented by both a reference
+      and resolved context
+- [x] Create error classes for various scenarios
+- [ ] Associate/resolve operation id / operation references
+- [ ] Do something to model expressions
+- [x] Improve the modelling of namespace
+- [x] Set up nicer string representations of key classes to help them be
+      debugged
+- [x] Ensure Array and Map nodes return empty ones by default rather than nil
+- [ ] Make JSON pointer public access to be consistent accepting string, array
+      or (potentially) a pointer class
+- [x] Support creating a default Server object on servers property of OpenAPI
+      Node
+- [ ] Support relative URLs being able to be relative the first server object
+      see: https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.1.md#relative-references-in-urls
+- [ ] Support validating a Server URL based on default values
+- [ ] Validate paths to check path parameters within them appear in paths
+      see: https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.1.md#fixed-fields-10

data/vendor/bundle/ruby/2.7.0/gems/openapi3_parser-0.9.1/lib/openapi3_parser/array_sentence.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Openapi3Parser
+  module ArraySentence
+    refine ::Array do
+      def sentence_join
+        return join if count < 2
+
+        "#{self[0..-2].join(', ')} and #{self[-1]}"
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/openapi3_parser-0.9.1/lib/openapi3_parser/cautious_dig.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Openapi3Parser
+  class CautiousDig
+    private_class_method :new
+
+    def self.call(*args)
+      new.call(*args)
+    end
+
+    def call(collection, *segments)
+      segments.inject(collection) do |next_depth, segment|
+        break unless next_depth
+
+        if next_depth.respond_to?(:keys)
+          hash_like(next_depth, segment)
+        elsif next_depth.respond_to?(:[])
+          array_like(next_depth, segment)
+        end
+      end
+    end
+
+    private
+
+    def hash_like(item, segment)
+      key = item.keys.find { |k| segment == k || segment.to_s == k.to_s }
+      item[key]
+    end
+
+    def array_like(item, segment)
+      index = if segment.is_a?(String) && segment =~ /\A\d+\z/
+                segment.to_i
+              else
+                segment
+              end
+      index.is_a?(Integer) ? item[index] : nil
+    end
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/openapi3_parser-0.9.1/lib/openapi3_parser/document/reference_registry.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Openapi3Parser
+  class Document
+    class ReferenceRegistry
+      attr_reader :sources
+
+      def initialize
+        @sources = []
+        @factories_by_type = {}
+      end
+
+      def freeze
+        sources.freeze
+        factories_by_type.freeze.each(&:freeze)
+        super
+      end
+
+      def factories
+        factories_by_type.values.flatten
+      end
+
+      def register(unbuilt_factory, source_location, reference_factory_context)
+        register_source(source_location.source)
+        object_type = unbuilt_factory.object_type
+        existing_factory = factory(object_type, source_location)
+
+        return existing_factory if existing_factory
+
+        build_factory(
+          unbuilt_factory,
+          source_location,
+          reference_factory_context
+        ).tap { |f| register_factory(object_type, f) }
+      end
+
+      def factory(object_type, source_location)
+        factories_by_type[object_type]&.find do |f|
+          f.context.source_location == source_location
+        end
+      end
+
+      private
+
+      attr_reader :factories_by_type
+
+      def register_source(source)
+        sources << source unless sources.include?(source)
+      end
+
+      def register_factory(object_type, factory)
+        factories_by_type[object_type] ||= []
+        factories_by_type[object_type] << factory
+      end
+
+      def build_factory(unbuilt_factory,
+                        source_location,
+                        reference_factory_context)
+        next_context = NodeFactory::Context.resolved_reference(
+          reference_factory_context,
+          source_location: source_location
+        )
+
+        if unbuilt_factory.is_a?(Class)
+          unbuilt_factory.new(next_context)
+        else
+          unbuilt_factory.call(next_context)
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/openapi3_parser-0.9.1/lib/openapi3_parser/document.rb

@@ -0,0 +1,217 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+module Openapi3Parser
+  # Document is the root construct of a created OpenAPI Document and can be
+  # used to navigate the contents of a document or to check it's validity.
+  #
+  # @attr_reader  [String]        openapi_version
+  # @attr_reader  [Source]        root_source
+  # @attr_reader  [Array<String>] warnings
+  class Document
+    extend Forwardable
+    include Enumerable
+
+    attr_reader :openapi_version, :root_source, :warnings
+
+    # A collection of the openapi versions that are supported
+    SUPPORTED_OPENAPI_VERSIONS = %w[3.0].freeze
+
+    # The version of OpenAPI that will be used by default for
+    # validation/construction
+    DEFAULT_OPENAPI_VERSION = "3.0"
+
+    # @!method valid?
+    #   Whether this OpenAPI document has any validation issues or not. See
+    #   #errors to access the errors
+    #
+    #   @return [Boolean]
+    def_delegator :factory, :valid?
+
+    # @!method openapi
+    #   The value of the openapi version field for this document
+    #   @see Node::Openapi#openapi
+    #   @return [String]
+    # @!method info
+    #   The value of the info field on the OpenAPI document
+    #   @see Node::Openapi#info
+    #   @return [Node::Info]
+    # @!method servers
+    #   The value of the servers field on the OpenAPI document
+    #   @see Node::Openapi#servers
+    #   @return [Node::Array<Node::Server>]
+    # @!method paths
+    #   The value of the paths field on the OpenAPI document
+    #   @see Node::Openapi#paths
+    #   @return [Node::Paths]
+    # @!method components
+    #   The value of the components field on the OpenAPI document
+    #   @see Node::Openapi#components
+    #   @return [Node::Components]
+    # @!method security
+    #   The value of the security field on the OpenAPI document
+    #   @see Node::Openapi#security
+    #   @return [Node::Array<Node::SecurityRequirement>]
+    # @!method tags
+    #   The value of the tags field on the OpenAPI document
+    #   @see Node::Openapi#tags
+    #   @return [Node::Array<Node::Tag>]
+    # @!method external_docs
+    #   The value of the external_docs field on the OpenAPI document
+    #   @see Node::Openapi#external_docs
+    #   @return [Node::ExternalDocumentation, nil]
+    # @!method extension
+    #   Look up an extension field provided for the root object of the document
+    #   @see Node::Object#extension
+    #   @return [Hash, Array, Numeric, String, true, false, nil]
+    # @!method []
+    #   Look up an attribute on the root of the OpenAPI document by String
+    #   or Symbol
+    #   @see Node::Object#[]
+    #   @return Object
+    # @!method each
+    #   Iterate through the attributes of the root object
+    # @!method keys
+    #   Access keys of the root object
+    def_delegators :root, :openapi, :info, :servers, :paths, :components,
+                   :security, :tags, :external_docs, :extension, :[], :each,
+                   :keys
+
+    # @param [SourceInput] source_input
+    def initialize(source_input)
+      @reference_registry = ReferenceRegistry.new
+      @root_source = Source.new(source_input, self, reference_registry)
+      @warnings = []
+      @openapi_version = determine_openapi_version(root_source.data["openapi"])
+      @build_in_progress = false
+      @built = false
+    end
+
+    # @return [Node::Openapi]
+    def root
+      @root ||= factory.node(Node::Context.root(factory.context))
+    end
+
+    # All the additional sources that have been referenced as part of loading
+    # the OpenAPI document
+    #
+    # @return [Array<Source>]
+    def reference_sources
+      build unless built
+      reference_registry.sources.reject(&:root?)
+    end
+
+    # All of the sources involved in this OpenAPI document
+    #
+    # @return [Array<Source>]
+    def sources
+      [root_source] + reference_sources
+    end
+
+    # Any validation errors that are present on the OpenAPI document
+    #
+    # @return [Validation::ErrorCollection]
+    def errors
+      reference_factories.inject(factory.errors) do |memo, f|
+        Validation::ErrorCollection.combine(memo, f.errors)
+      end
+    end
+
+    # Look up whether an instance of SourceInput is already a known source
+    # for this document.
+    #
+    # @param [SourceInput] source_input
+    # @return [Source, nil]
+    def source_for_source_input(source_input)
+      sources.find { |source| source.source_input == source_input }
+    end
+
+    # Look up the resolved input for an address in the OpenAPI document,
+    # resolved_input refers to the input with references resolevd and all
+    # optional fields existing
+    #
+    # @param [Source::Pointer, String, Array]      pointer
+    # @param [Source::Pointer, String, Array, nil] relative_to
+    # @return anything
+    def resolved_input_at(pointer, relative_to = nil)
+      look_up_pointer(pointer, relative_to, factory.resolved_input)
+    end
+
+    # Look up a node at a particular location in the OpenAPI document
+    #
+    # Examples:
+    #
+    # document.node_at("#/components/schemas")
+    # document.node_at(%w[components schemas])
+    #
+    # @param [Source::Pointer, String, Array]      pointer
+    # @param [Source::Pointer, String, Array, nil] relative_to
+    # @return anything
+    def node_at(pointer, relative_to = nil)
+      look_up_pointer(pointer, relative_to, root)
+    end
+
+    # @return [String]
+    def inspect
+      %{#{self.class.name}(openapi_version: #{openapi_version}, } +
+        %{root_source: #{root_source.inspect})}
+    end
+
+    private
+
+    attr_reader :reference_registry, :built, :build_in_progress
+
+    def look_up_pointer(pointer, relative_pointer, subject)
+      merged_pointer = Source::Pointer.merge_pointers(relative_pointer,
+                                                      pointer)
+      CautiousDig.call(subject, *merged_pointer.segments)
+    end
+
+    def add_warning(text)
+      @warnings << text
+    end
+
+    def build
+      return if build_in_progress || built
+
+      @build_in_progress = true
+      context = NodeFactory::Context.root(root_source.data, root_source)
+      @factory = NodeFactory::Openapi.new(context)
+      reference_registry.freeze
+      @warnings.freeze
+      @build_in_progress = false
+      @built = true
+    end
+
+    def determine_openapi_version(version)
+      minor_version = (version || "").split(".").first(2).join(".")
+
+      if SUPPORTED_OPENAPI_VERSIONS.include?(minor_version)
+        minor_version
+      elsif version
+        add_warning(
+          "Unsupported OpenAPI version (#{version}), treating as a " \
+          "#{DEFAULT_OPENAPI_VERSION} document"
+        )
+        DEFAULT_OPENAPI_VERSION
+      else
+        add_warning(
+          "Unspecified OpenAPI version, treating as a " \
+          "#{DEFAULT_OPENAPI_VERSION} document"
+        )
+        DEFAULT_OPENAPI_VERSION
+      end
+    end
+
+    def factory
+      build unless built
+      @factory
+    end
+
+    def reference_factories
+      build unless built
+      reference_registry.factories.reject { |f| f.context.source.root? }
+    end
+  end
+end