open_api-loader 0.0.1

data/lib/open_api/loader/translator/convert_parameters.rb

@@ -0,0 +1,135 @@
+class OpenAPI::Loader::Translator
+  #
+  # Adds 'schema', 'style' and 'explode' to values of 'parameters'.
+  #
+  # @private
+  #
+  class ConvertParameters < SimpleDelegator
+    def call
+      parameters.each { |parameter| convert(parameter) }
+    end
+
+    private
+
+    def parameters
+      Enumerator.new do |yielder|
+        root_parameters.each { |item| yielder << item }
+        path_parameters.each { |item| yielder << item }
+        operation_parameters.each { |item| yielder << item }
+        headers.each { |item| yielder << item }
+      end
+    end
+
+    def convert(item)
+      place   = item["in"]
+      format  = item.delete "collectionFormat"
+      style   = style(place, format)
+      explode = explode(format)
+      schema  = schema(item)
+
+      item.update("schema" => schema).update(style).update(explode)
+    end
+
+    def params(item)
+      Array item.fetch("parameters", [])
+    end
+
+    def root_parameters
+      Enumerator.new do |yielder|
+        params(self).each { |item| yielder << item if item.is_a? Hash }
+      end
+    end
+
+    def path_parameters
+      Enumerator.new do |yielder|
+        paths.each do |path|
+          params(path).each { |item| yielder << item if item.is_a? Hash }
+        end
+      end
+    end
+
+    def operation_parameters
+      Enumerator.new do |yielder|
+        operations.each do |operation|
+          params(operation).each { |item| yielder << item if item.is_a? Hash }
+        end
+      end
+    end
+
+    def paths
+      Enumerator.new do |yielder|
+        fetch("paths", {}).each_value do |path|
+          yielder << path if path.is_a? Hash
+        end
+      end
+    end
+
+    def operations
+      Enumerator.new do |yielder|
+        paths.each do |path|
+          path.each_value { |item| yielder << item if item.is_a? Hash }
+        end
+      end
+    end
+
+    def responses
+      Enumerator.new do |yielder|
+        operations.each do |operation|
+          operation.fetch("responses", {}).each_value do |item|
+            yielder << item if item.is_a? Hash
+          end
+        end
+      end
+    end
+
+    def headers
+      Enumerator.new do |yielder|
+        responses.each do |response|
+          response.fetch("headers", {}).each_value do |item|
+            yielder << item if item.is_a? Hash
+          end
+        end
+      end
+    end
+
+    def style(place, format)
+      case format
+      when "csv"
+        { "style" => (%w[query cookie].include?(place) ? "form" : "simple") }
+      when "ssv"   then { "style" => "spaceDelimited" }
+      when "pipes" then { "style" => "pipeDelimited" }
+      when "multi" then { "style" => "form" }
+      else {}
+      end
+    end
+
+    def explode(format)
+      format == "multi" ? { "explode" => true } : {}
+    end
+
+    def schema(item)
+      SCHEMA_KEYS.each_with_object({}) do |key, obj|
+        obj[key] = item.delete(key) if item.key? key
+      end
+    end
+
+    SCHEMA_KEYS = %w[
+      default
+      enum
+      exclusiveMaximum
+      exclusiveMinimum
+      format
+      items
+      maxItems
+      maxLength
+      maximum
+      minItems
+      minLength
+      minimum
+      multipleOf
+      pattern
+      type
+      uniqueItems
+    ].freeze
+  end
+end

data/lib/open_api/loader/translator/convert_responses.rb

@@ -0,0 +1,63 @@
+class OpenAPI::Loader::Translator
+  #
+  # Builds 'response.content' from 'schema' and 'produces' parameters
+  #
+  # @private
+  #
+  class ConvertResponses < SimpleDelegator
+    def call
+      responses.each { |response| convert(response) }
+    end
+
+    private
+
+    def paths
+      Enumerator.new do |yielder|
+        fetch("paths", {}).each_value do |path|
+          yielder << path if path.is_a? Hash
+        end
+      end
+    end
+
+    def operations
+      Enumerator.new do |yielder|
+        paths.each do |path|
+          path.each_value { |item| yielder << item if item.is_a? Hash }
+        end
+      end
+    end
+
+    def responses
+      Enumerator.new do |yielder|
+        operations.each do |operation|
+          responses = operation["responses"]
+          next unless responses.is_a? Hash
+          responses.each_value { |item| yielder << item if item.is_a? Hash }
+        end
+      end
+    end
+
+    def convert(response)
+      content_types = Array response.delete("produces")
+      schema =        Hash  response.delete("schema")
+      return if content_types.empty?
+      response["content"] = {}
+      content_types.each do |type|
+        response["content"][type] = {
+          "schema" => type["/xml"] ? schema : drop_xml(schema)
+        }
+      end
+    end
+
+    def drop_xml(data)
+      case data
+      when Hash
+        data.each_with_object({}) do |(key, val), obj|
+          obj[key] = drop_xml(val) unless key == "xml"
+        end
+      when Array then data.map { |item| drop_xml(item) }
+      else data
+      end
+    end
+  end
+end

data/lib/open_api/loader/translator/convert_security_schemes.rb

@@ -0,0 +1,49 @@
+class OpenAPI::Loader::Translator
+  #
+  # Wraps the schema and moves its securityDefinitions
+  # to components.securitySchemes
+  #
+  # Translates every securityScheme for oauth2 into new format.
+  #
+  # @private
+  #
+  class ConvertSecuritySchemes < SimpleDelegator
+    def call
+      return unless schemes.is_a? Hash
+      convert_oauth_schemes
+      self["components"] = { "securitySchemes" => schemes }
+    end
+
+    private
+
+    def schemes
+      @schemes ||= delete("securityDefinitions")
+    end
+
+    def oauth_keys
+      @oauth_keys ||= schemes.select do |_, scheme|
+        scheme.is_a?(Hash) && scheme["type"] == "oauth2"
+      end.keys
+    end
+
+    def convert_oauth_schemes
+      oauth_keys.each { |key| convert_scheme(key) }
+    end
+
+    def convert_scheme(key)
+      scheme = schemes[key]
+      flow   = scheme["flow"]
+      flow   = FLOWS.fetch(flow, flow)
+      data   = scheme.select { |detail| DETAILS.include? detail }
+
+      schemes[key] = { "type" => "oauth2", "flows" => { flow => data } }
+    end
+
+    FLOWS = {
+      "application" => "clientCredentials",
+      "accessCode"  => "authorizationCode",
+    }.freeze
+
+    DETAILS = %w[authorizationUrl tokenUrl scopes]
+  end
+end

data/lib/open_api/loader/translator/convert_servers.rb

@@ -0,0 +1,46 @@
+class OpenAPI::Loader::Translator
+  #
+  # Translates OAS2 host, basePath and schemes to OAS3 servers
+  # Mutates the source
+  #
+  # @private
+  #
+  class ConvertServers < SimpleDelegator
+    def call
+      convert self
+      paths.each { |item| convert item }
+      operations.each { |item| convert item }
+    end
+
+    private
+
+    def paths
+      @paths ||= Enumerator.new do |yielder|
+        fetch("paths", {}).each_value do |path|
+          path.each_value { |item| yielder << item if item.is_a? Hash }
+        end
+      end
+    end
+
+    def operations
+      @operations ||= Enumerator.new do |yielder|
+        paths.each do |path|
+          path.each_value { |item| yielder << item if item.is_a? Hash }
+        end
+      end
+    end
+
+    def url
+      @url ||= File.join delete("host"), delete("basePath")
+    end
+
+    def convert(item)
+      enum = item.delete "schemes"
+      return unless enum
+      item["servers"] = [{
+        "url" => "{scheme}://#{url}",
+        "variables" => { "scheme" => { "enum" => Array(enum) } }
+      }]
+    end
+  end
+end

data/lib/open_api/loader/translator/convert_version.rb

@@ -0,0 +1,12 @@
+class OpenAPI::Loader::Translator
+  #
+  # Wraps the schema and changes version of the OAS
+  # @private
+  #
+  class ConvertVersion < SimpleDelegator
+    def call
+      delete "swagger"
+      self["openapi"] = "3.0.0"
+    end
+  end
+end

data/lib/open_api/loader/translator/denormalize_consumes.rb

@@ -0,0 +1,44 @@
+class OpenAPI::Loader::Translator
+  #
+  # Denormalizes 'consumes' setting for requestBody
+  #
+  # @private
+  #
+  class DenormalizeConsumes < SimpleDelegator
+    def call
+      paths.each do |path|
+        path_consumes = path.delete("consumes") || root_consumes
+        operations(path).each do |operation|
+          consumes = operation.delete("consumes") || path_consumes
+          operation["consumes"] = consumes if consumes?(operation)
+        end
+      end
+    end
+
+    private
+
+    def root_consumes
+      @root_consumes ||= delete("consumes")
+    end
+
+    def paths
+      Enumerator.new do |yielder|
+        fetch("paths", {}).each_value do |item|
+          yielder << item if item.is_a? Hash
+        end
+      end
+    end
+
+    def operations(path)
+      Enumerator.new do |yielder|
+        path.each_value { |item| yielder << item if item.is_a? Hash }
+      end
+    end
+
+    def consumes?(operation)
+      Array(operation["parameters"]).any? do |item|
+        item.is_a?(Hash) && %w[body formData].include?(item["in"])
+      end
+    end
+  end
+end

data/lib/open_api/loader/translator/denormalize_parameters.rb

@@ -0,0 +1,55 @@
+class OpenAPI::Loader::Translator
+  #
+  # Denormalizes 'parameters' of 'body' and 'formData' rigth into operations
+  # This is needed for building a 'requestBody' part of the schema
+  # from 'parameters' and 'consumes'.
+  #
+  # @private
+  #
+  class DenormalizeParameters < SimpleDelegator
+    def call
+      root_params = extract(self)
+      paths.each do |path|
+        path_params = merge root_params, extract(path)
+        operations(path).each do |operation|
+          parameters = merge path_params, params(operation)
+          operation["parameters"] = parameters if parameters.any?
+        end
+      end
+    end
+
+    private
+
+    def paths
+      Enumerator.new do |yielder|
+        fetch("paths", {}).each_value do |path|
+          yielder << path if path.is_a? Hash
+        end
+      end
+    end
+
+    def operations(path)
+      Enumerator.new do |yielder|
+        path.each_value { |item| yielder << item if item.is_a? Hash }
+      end
+    end
+
+    def params(data)
+      items = data.delete("parameters")
+      return [] unless items.is_a? Array
+      items.select { |item| item.is_a?(Hash) && item["in"] && item["name"] }
+    end
+
+    def extract(data)
+      body, non_body = \
+        params(data).partition { |item| %w[body formData].include? item["in"] }
+      data["parameters"] = non_body if non_body.any?
+      body
+    end
+
+    def merge(left, right)
+      names = right.map { |item| item["name"] }
+      left.reject { |item| names.include? item["name"] } + right
+    end
+  end
+end

data/lib/open_api/loader/translator/denormalize_produces.rb

@@ -0,0 +1,53 @@
+class OpenAPI::Loader::Translator
+  #
+  # Denormalizes 'consumes' and 'produces' setting
+  #
+  # @private
+  #
+  class DenormalizeProduces < SimpleDelegator
+    def call
+      paths.each do |path|
+        path_produces = path.delete("produces") || root_produces
+        operations(path).each do |operation|
+          produces = operation.delete("produces") || path_produces
+          responses(operation).each do |response|
+            response["produces"] = produces
+          end
+        end
+      end
+    end
+
+    private
+
+    def root_produces
+      @root_produces ||= delete("produces")
+    end
+
+    def paths
+      Enumerator.new do |yielder|
+        fetch("paths", {}).each_value do |item|
+          yielder << item if item.is_a? Hash
+        end
+      end
+    end
+
+    def operations(path)
+      Enumerator.new do |yielder|
+        path.each_value { |item| yielder << item if item.is_a? Hash }
+      end
+    end
+
+    def responses(operation)
+      data = operation["responses"]
+      if data.is_a? Hash
+        Enumerator.new do |yielder|
+          data.each_value do |response|
+            yielder << response if response.is_a?(Hash) && response["schema"]
+          end
+        end
+      else
+        []
+      end
+    end
+  end
+end