open_api-loader 0.0.1

data/lib/open_api/loader/denormalizer/security.rb

@@ -0,0 +1,35 @@
+class OpenAPI::Loader::Denormalizer
+  #
+  # Denormalizes all the 'security' definitions
+  # by moving them from the root OpenAPI object
+  # right into the corresponding operation objects.
+  #
+  # @private
+  #
+  class Security < SimpleDelegator
+    def call
+      default = delete "security"
+      operations.each do |operation|
+        operation["security"] ||= default if default
+      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
+      Enumerator.new do |yielder|
+        paths.each do |path|
+          path.each_value { |item| yielder << item if item.is_a? Hash }
+        end
+      end
+    end
+  end
+end

data/lib/open_api/loader/denormalizer/servers.rb

@@ -0,0 +1,36 @@
+class OpenAPI::Loader::Denormalizer
+  #
+  # Denormalizes all the 'servers' definitions
+  # by moving them from the root OpenAPI object and path objects
+  # right into the corresponding operation objects.
+  #
+  # @private
+  #
+  class Servers < SimpleDelegator
+    def call
+      root_default = delete "servers"
+      paths.each do |path|
+        default = path.delete("servers") || root_default
+        operations(path).each do |operation|
+          operation["servers"] ||= default if default
+        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
+  end
+end

data/lib/open_api/loader/denormalizer/variables.rb

@@ -0,0 +1,54 @@
+class OpenAPI::Loader::Denormalizer
+  #
+  # Inserts server variables into server urls in all operations
+  #
+  # @private
+  #
+  class Variables < SimpleDelegator
+    def call
+      operations.each { |operation| convert(operation) }
+    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 convert(operation)
+      servers = operation.delete("servers")
+      return unless servers.is_a? Array
+      operation["servers"] = servers.flat_map { |server| substitute(server) }
+    end
+
+    def substitute(server)
+      url, variables = server.values_at "url", "variables"
+      combinations(url, variables).map { |url| { "url" => url } }
+    end
+
+    def combinations(url, variables)
+      return [url] unless variables.is_a? Hash
+
+      variables.inject([url]) do |urls, (key, var)|
+        enum = var["enum"]
+        if enum.is_a?(Array) && enum.any?
+          urls.flat_map { |url| enum.map { |val| url.gsub("{#{key}}", val) } }
+        else
+          urls
+        end
+      end
+    end
+  end
+end

data/lib/open_api/loader/reader.rb

@@ -0,0 +1,47 @@
+module OpenAPI::Loader
+  #
+  # Loads data from [#source] file and strinfies all its keys
+  # @private
+  #
+  class Reader
+    extend Dry::Initializer
+    extend ConstructorShortcut[:call] # class-level .call
+
+    param :source
+
+    def call
+      stringify_keys(try_json || try_yaml)
+    end
+
+    private
+
+    def raw
+      @raw ||= begin
+        uri  = URI source
+        path = Pathname source
+        uri.absolute? ? Net::HTTP.get(uri) : File.read(path)
+      end
+    end
+
+    def stringify_keys(data)
+      case data
+      when Hash
+        data.each_with_object({}) { |(k, v), o| o[k.to_s] = stringify_keys(v) }
+      when Array then data.map { |item| stringify_keys(item) }
+      else data
+      end
+    end
+
+    def try_json
+      JSON.load raw
+    rescue JSON::ParserError
+      nil
+    end
+
+    def try_yaml
+      YAML.load raw
+    rescue Psych::SyntaxError
+      nil
+    end
+  end
+end

data/lib/open_api/loader/ref.rb

@@ -0,0 +1,85 @@
+module OpenAPI::Loader
+  #
+  # Describes json pointer used in "$ref"-erences
+  # @see RFC-6901 https://tools.ietf.org/html/rfc6901
+  #
+  # @private
+  #
+  class Ref < String
+    #
+    # Builds the pointer from a path
+    #
+    # @param  [Array<#to_s>, #to_s] path
+    # @return [OpenAPI::Ref]
+    #
+    def self.[](*path)
+      path.flatten.compact.each_with_object("#") do |key, obj|
+        obj << "/#{key.to_s.gsub('~', '~0').gsub('/', '~1')}"
+      end
+    end
+
+    #
+    # The URI to the remote document
+    # @return [URI, nil]
+    #
+    def uri
+      URI split("#").first unless start_with? "#"
+    end
+
+    #
+    # The local pointer to the json
+    # @return [Array<String>]
+    #
+    def path
+      return [] if end_with? "#"
+      split(%r{#/?}).last.to_s.split("/").map do |item|
+        PARSER.unescape(item).gsub("~1", "/").gsub("~0", "~")
+      end
+    end
+
+    #
+    # Extracs referred value from given source by local path (after #)
+    #
+    # @param  [Hash]
+    # @return [Object]
+    #
+    def fetch_from(data)
+      read(data, [], *path)
+    end
+
+    private
+
+    PARSER = URI::Parser.new.freeze
+
+    def initialize(source)
+      source = "#{source}#" if source.count("#").zero?
+      super(source)
+      return if count("#") == 1 && (end_with?("#") || self["#/"])
+      raise ArgumentError, "Invalid reference '#{source}'"
+    end
+
+    def read(data, head, key = nil, *rest)
+      return data unless key
+      case data
+      when Array then read_array(data, head, key, rest)
+      when Hash  then read_hash(data, head, key, rest)
+      else raise_error(*head, key)
+      end
+    end
+
+    def read_array(data, head, key, rest)
+      int = key.to_i
+      raise_error(*head, key) unless int.to_s == key.to_s && data.count > int
+      read(data[int], [*head, key], *rest)
+    end
+
+    def read_hash(data, head, key, rest)
+      raise_error(*head, key) unless data.key? key
+      read(data[key], [*head, key], *rest)
+    end
+
+    def raise_error(*path)
+      raise KeyError, "Cannot find value by reference '#{self.class[*path]}'"
+    end
+  end
+end

data/lib/open_api/loader/translator.rb

@@ -0,0 +1,50 @@
+module OpenAPI::Loader
+  #
+  # Translates OAS2 to OAS3 specification
+  # @private
+  #
+  class Translator
+    extend Dry::Initializer
+    extend ConstructorShortcut[:call] # class-level .call
+
+    param :source
+
+    def call
+      return source unless oas2?
+      WRAPPERS.each { |wrapper| wrapper.new(source).call }
+      source
+    end
+
+    private
+
+    def oas2?
+      source.is_a?(Hash) && source["swagger"].to_s.start_with?("2")
+    end
+
+    require_relative "translator/clean_definitions"
+    require_relative "translator/convert_bodies"
+    require_relative "translator/convert_forms"
+    require_relative "translator/convert_parameters"
+    require_relative "translator/convert_responses"
+    require_relative "translator/convert_security_schemes"
+    require_relative "translator/convert_servers"
+    require_relative "translator/convert_version"
+    require_relative "translator/denormalize_consumes"
+    require_relative "translator/denormalize_parameters"
+    require_relative "translator/denormalize_produces"
+
+    WRAPPERS = [
+      CleanDefinitions,
+      DenormalizeParameters,
+      DenormalizeConsumes,
+      DenormalizeProduces,
+      ConvertForms,
+      ConvertBodies,
+      ConvertParameters,
+      ConvertResponses,
+      ConvertServers,
+      ConvertSecuritySchemes,
+      ConvertVersion
+    ].freeze
+  end
+end

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

@@ -0,0 +1,16 @@
+class OpenAPI::Loader::Translator
+  #
+  # Cleans definitions that aren't in use any more, because all references
+  # to them were expanded by [OpenAPI::Loader::Collector].
+  #
+  # @private
+  #
+  class CleanDefinitions < SimpleDelegator
+    def call
+      KEYS.each { |key| delete(key) }
+    end
+
+    # Keys to be dropped
+    KEYS = %w[definitions parameters responses].freeze
+  end
+end

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

@@ -0,0 +1,77 @@
+class OpenAPI::Loader::Translator
+  #
+  # Builds 'requestBody' from 'consumes' and 'body' parameters
+  #
+  # @private
+  #
+  class ConvertBodies < SimpleDelegator
+    def call
+      operations.each { |item| update_body(item) }
+    end
+
+    private
+
+    FORMS = %w[application/x-www-form-urlencoded multipart/form-data].freeze
+
+    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 update_body(operation)
+      data, body = body_data(operation)
+      return unless data
+
+      body_encodings(operation).each do |encoding|
+        schema = encoding["/xml"] ? data : drop_xml(data)
+        operation["requestBody"] ||= Hash(body)
+        operation["requestBody"]["content"] ||= {}
+        operation["requestBody"]["content"][encoding] = { "schema" => schema }
+      end
+    end
+
+    def body_encodings(operation)
+      encodings = Array operation.delete("consumes")
+      forms, others = encodings.partition { |item| FORMS.include? item }
+      operation["consumes"] = forms if forms.any?
+      others
+    end
+
+    def body_data(operation)
+      param = body_params(operation).first
+      return unless param.is_a?(Hash)
+      schema  = param.delete("schema")
+      content = param.select { |key, _| %w[description required].include? key }
+      [schema, content]
+    end
+
+    def body_params(operation)
+      params = Array operation.delete("parameters")
+      bodies, others = params.partition { |item| item["in"] == "body" }
+      operation["parameters"] = others if others.any?
+      bodies
+    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_forms.rb

@@ -0,0 +1,71 @@
+class OpenAPI::Loader::Translator
+  #
+  # Builds 'requestBody' from 'consumes' and 'formData' parameters
+  #
+  # @private
+  #
+  class ConvertForms < SimpleDelegator
+    def call
+      operations.each { |item| update_body(item) }
+    end
+
+    private
+
+    FORMS = %w[application/x-www-form-urlencoded multipart/form-data].freeze
+
+    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 update_body(operation)
+      schema = form_schema(operation)
+      form_encodings(operation).each do |encoding|
+        operation["requestBody"] ||= {}
+        operation["requestBody"]["content"] ||= {}
+        operation["requestBody"]["content"][encoding] = { "schema" => schema }
+      end
+    end
+
+    def form_encodings(operation)
+      encodings = Array operation.delete("consumes")
+      forms, others = encodings.partition { |item| FORMS.include? item }
+      operation["consumes"] = others if others.any?
+      forms
+    end
+
+    def form_schema(operation)
+      properties = form_properties(operation)
+      schema = { "type" => "object" }
+      schema["properties"] = properties if properties.any?
+      schema
+    end
+
+    def form_properties(operation)
+      form_params(operation).each_with_object({}) do |item, obj|
+        name = item["name"]
+        data = item.reject { |key| %w[in name].include? key }
+        data["type"] = "string" if data["type"] == "file"
+        obj[name] = data
+      end
+    end
+
+    def form_params(operation)
+      params = Array operation.delete("parameters")
+      forms, others = params.partition { |item| item["in"] == "formData" }
+      operation["parameters"] = others if others.any?
+      forms
+    end
+  end
+end