open_api 0.1.0

data/lib/open_api/o_auth_flow.rb

@@ -0,0 +1,26 @@
+module OpenApi
+  # https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.1.md#oauthFlowObject
+  class OAuthFlow
+    prepend EquatableAsContent
+
+    attr_accessor :authorization_url, :token_url, :refresh_url ,:scopes
+
+    def initialize(authorization_url:, token_url:, refresh_url: nil, scopes:)
+      self.authorization_url = authorization_url
+      self.token_url = token_url
+      self.refresh_url = refresh_url
+      self.scopes = scopes.with_indifferent_access
+    end
+
+    def self.load(hash)
+      return unless hash
+
+      new(
+        authorization_url: hash["authorizationUrl"],
+        token_url: hash["tokenUrl"],
+        refresh_url: hash["refreshUrl"],
+        scopes: hash["scopes"],
+      )
+    end
+  end
+end

data/lib/open_api/o_auth_flows.rb

@@ -0,0 +1,26 @@
+module OpenApi
+  # https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.1.md#oauth-flows-object
+  class OAuthFlows
+    prepend EquatableAsContent
+
+    attr_accessor :implicit, :password, :client_credentials, :authorization_code
+
+    def initialize(implicit: nil, password: nil, client_credentials: nil, authorization_code: nil)
+      self.implicit = implicit
+      self.password = password
+      self.client_credentials = client_credentials
+      self.authorization_code = authorization_code
+    end
+
+    def self.load(hash)
+      return unless hash
+
+      new(
+        implicit: OAuthFlow.load(hash["implicit"]),
+        password: OAuthFlow.load(hash["password"]),
+        client_credentials: OAuthFlow.load(hash["clientCredentials"]),
+        authorization_code: OAuthFlow.load(hash["authorizationCode"]),
+      )
+    end
+  end
+end

data/lib/open_api/operation.rb

@@ -0,0 +1,58 @@
+module OpenApi
+  class Operation
+    prepend EquatableAsContent
+
+    attr_accessor :tags, :summary, :description, :external_docs, :operation_id, :parameters, :request_body, :responses, :callbacks, :deprecated, :security, :servers
+
+    def initialize(responses:, tags: nil, summary: nil, description: nil, external_docs: nil, operation_id: nil, parameters: nil, request_body: nil, callbacks: nil, deprecated: nil, security: nil, servers: nil)
+      self.responses = responses
+      self.tags = tags
+      self.summary = summary
+      self.description = description
+      self.external_docs = external_docs
+      self.operation_id = operation_id
+      self.parameters = parameters
+      self.request_body = request_body
+      self.callbacks = callbacks
+      self.deprecated = deprecated
+      self.security = security
+      self.servers = servers
+    end
+
+    def serializable_hash
+      {
+        "description" => description&.to_s,
+        "responses" => responses.serializable_hash,
+        "tags" => tags&.map(&:to_s),
+        "summary" => summary&.to_s,
+        "externalDocs" => external_docs&.serializable_hash,
+        "operationId" => operation_id&.to_s,
+        "parameters" => parameters&.map(&:serializable_hash),
+        "requestBody" => request_body&.serializable_hash,
+        "callbacks" => callbacks&.map { |k, v| [k.to_s, v.serializable_hash] }&.to_hash,
+        "deprecated" => deprecated,
+        "security" => security&.map(&:serializable_hash),
+        "servers" => servers&.map(&:server),
+      }.compact
+    end
+
+    def self.load(hash)
+      return unless hash
+
+      new(
+        responses: Responses.load(hash["responses"]),
+        tags: hash["tags"],
+        summary: hash["summary"]&.to_s,
+        description: hash["description"]&.to_s,
+        external_docs: ExternalDocumentation.load(hash["externalDocs"]),
+        operation_id: hash["operationId"]&.to_s,
+        parameters: hash["parameters"]&.map { |h| Reference.load(h) || Parameter.load(h) },
+        request_body: Reference.load(hash["requestBody"]) || RequestBody.load(hash["requestBody"]),
+        callbacks: hash["callbacks"]&.map { |k, v| [k, Reference.load(v) || Callback.load(v)] }&.to_h,
+        deprecated: hash["deprecated"],
+        security: hash["security"]&.map { |h| SecurityRequirement.load(h) },
+        servers: hash["servers"]&.map { |h| Server.load(h) },
+      )
+    end
+  end
+end

data/lib/open_api/parameter.rb

@@ -0,0 +1,52 @@
+module OpenApi
+  # https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.1.md#parameterObject
+  class Parameter
+    prepend EquatableAsContent
+
+    attr_accessor :name, :in, :description, :required, :deprecated, :allow_empty_value
+
+    def initialize(name:, in:, description: nil, required: nil, deprecated: nil, allow_empty_value: nil, **other_fields_hash)
+      self.name = name
+      self.in = binding.local_variable_get(:in) # `in` is reserved keyword
+      self.required = required
+      self.deprecated = deprecated
+      self.allow_empty_value = allow_empty_value
+      self.other_fields_hash = other_fields_hash.with_indifferent_access
+
+      other_fields_hash.keys.each do |key|
+        define_singleton_method(key) do
+          other_fields_hash[key]
+        end
+        define_singleton_method("#{key}=") do |value|
+          other_fields_hash[key] = value
+        end
+      end
+    end
+
+    def self.load(hash)
+      other_fields_hash = hash.reject { |key|
+        key.to_sym.in?([:name, :in, :description, :required, :deprecated, :allow_empty_value])
+      }.symbolize_keys.map { |k, v|
+        value =
+          case k
+          when :schema then Schema.load(v)
+          end
+        [k, value]
+      }.to_h
+
+      new(
+        name: hash["name"].to_s,
+        in: hash["in"].to_s,
+        description: hash["description"]&.to_s,
+        required: hash["required"],
+        deprecated: hash["deprecated"],
+        allow_empty_value: hash["allowEmptyValue"],
+        **other_fields_hash,
+      )
+    end
+
+    private
+
+    attr_accessor :other_fields_hash
+  end
+end

data/lib/open_api/path_item.rb

@@ -0,0 +1,42 @@
+module OpenApi
+  # https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.1.md#path-item-object
+  class PathItem
+    prepend EquatableAsContent
+
+    attr_accessor :ref, :summary, :description, :servers, :parameters, :operations
+
+    OPERATION_NAMES = [:get, :put, :post, :delete, :options, :head, :patch, :trace]
+
+    def initialize(ref: nil, summary: nil, description: nil, servers: nil, parameters: nil, **operations)
+      self.ref = ref
+      self.summary = summary
+      self.description = description
+      self.servers = servers
+      self.parameters = parameters
+      self.operations = operations.with_indifferent_access
+    end
+
+    def serializable_hash
+      {
+        "ref" => ref&.to_s,
+        "summary" => summary&.to_s,
+        "description" => description&.to_s,
+        "servers" => servers&.map(&:serializable_hash),
+        "parameters" => parameters&.map(&:serializable_hash),
+      }.merge(operations.map { |k, v| [k.to_s, v.serializable_hash] }.to_h)
+       .compact
+    end
+
+    def self.load(hash)
+      operations = hash.select { |key| key.to_sym.in?(OPERATION_NAMES) }
+      new(
+        ref: hash["$ref"]&.to_s,
+        summary: hash["summary"]&.to_s,
+        description: hash["description"]&.to_s,
+        servers: hash["servers"]&.map { |server_hash| Server.load(server_hash) },
+        parameters: hash["parameters"]&.map { |h| Reference.load(h) || Parameter.load(h) },
+        **operations.map { |k ,v| [k.to_sym, Operation.load(v)] }.to_h,
+      )
+    end
+  end
+end

data/lib/open_api/paths.rb

@@ -0,0 +1,26 @@
+module OpenApi
+  # https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.1.md#pathsObject
+  class Paths
+    extend Forwardable
+    prepend EquatableAsContent
+
+    def initialize(**path_hash)
+      self.path_hash = path_hash.with_indifferent_access
+    end
+
+    def_delegator :path_hash, :[]
+
+    def self.load(hash)
+      hash = hash.map { |k, v| [k.to_sym, PathItem.load(v)] }.to_h
+      new(**hash)
+    end
+
+    def serializable_hash
+      path_hash.map { |k, v| [k.to_s, v.serializable_hash] }.to_h
+    end
+
+    private
+
+    attr_accessor :path_hash
+  end
+end

data/lib/open_api/reference.rb

@@ -0,0 +1,25 @@
+module OpenApi
+  # https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.1.md#referenceObject
+  class Reference
+    prepend EquatableAsContent
+
+    attr_accessor :ref
+
+    def initialize(ref:)
+      self.ref = ref
+    end
+
+    def serializable_hash
+      {
+        "$ref" => ref.to_s,
+      }
+    end
+
+    def self.load(hash)
+      return unless hash
+      return unless hash["$ref"]
+
+      new(ref: hash["$ref"])
+    end
+  end
+end

data/lib/open_api/request_body.rb

@@ -0,0 +1,23 @@
+module OpenApi
+  class RequestBody
+    prepend EquatableAsContent
+
+    attr_accessor :description, :content, :required
+
+    def initialize(description: nil, content:, required: false)
+      self.description = description
+      self.content = content.with_indifferent_access
+      self.required = required
+    end
+
+    def self.load(hash)
+      return unless hash
+
+      new(
+        description: hash["description"]&.to_s,
+        content: hash["content"].map { |k, v| [k, MediaType.load(v)] }.to_h,
+        required: hash["required"].nil? ? false : hash["required"]
+      )
+    end
+  end
+end

data/lib/open_api/response.rb

@@ -0,0 +1,34 @@
+module OpenApi
+  class Response
+    prepend EquatableAsContent
+
+    attr_accessor :description, :headers, :content, :links
+
+    def initialize(description:, headers: nil, content: nil, links: nil)
+      self.description = description
+      self.headers = headers&.with_indifferent_access
+      self.content = content&.with_indifferent_access
+      self.links = links&.with_indifferent_access
+    end
+
+    def serializable_hash
+      {
+        "description" => description.to_s,
+        "headers" => headers&.map { |k, v| [k.to_s, v.serializable_hash] }&.to_h,
+        "content" => content&.map { |k, v| [k.to_s, v.serializable_hash] }&.to_h,
+        "links" => links&.map { |k, v| [k.to_s, v.serializable_hash] }&.to_h,
+      }.compact
+    end
+
+    def self.load(hash)
+      return unless hash
+
+      new(
+        description: hash["description"].to_s,
+        headers: hash["headers"]&.map { |k, v| [k, Header.load(v)] }&.to_h,
+        content: hash["content"]&.map { |k, v| [k, MediaType.load(v)] }&.to_h,
+        links: hash["links"]&.map { |k, v| [k, Reference.load(v) || Link.load(v)] }&.to_h,
+      )
+    end
+  end
+end

data/lib/open_api/responses.rb

@@ -0,0 +1,34 @@
+module OpenApi
+  class Responses
+    extend Forwardable
+    prepend EquatableAsContent
+
+    attr_accessor :default
+
+    def initialize(default: nil, **responses_hash)
+      self.default = default
+      self.responses_hash = responses_hash.with_indifferent_access
+    end
+
+    def_delegator :responses_hash, :[]
+
+    def serializable_hash
+      {
+        "default" => default&.serializable_hash,
+      }
+        .merge(responses_hash.map { |k, v| [k.to_s, v.serializable_hash] }.to_h)
+        .compact
+    end
+
+    def self.load(hash)
+      return unless hash
+
+      hash = hash.map { |k, v| [k.to_s.to_sym, Response.load(v)] }.to_h
+      new(**hash)
+    end
+
+    private
+
+    attr_accessor :responses_hash
+  end
+end

data/lib/open_api/security_requirement.rb

@@ -0,0 +1,20 @@
+module OpenApi
+  # https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.1.md#security-requirement-object
+  class SecurityRequirement
+    extend Forwardable
+
+    def initialize(**hash)
+      self.hash = hash.with_indifferent_access
+    end
+
+    def_delegator :hash, :[]
+
+    def self.load(hash)
+      new(**hash.symbolize_keys)
+    end
+
+    private
+
+    attr_accessor :hash
+  end
+end

data/lib/open_api/security_schema.rb

@@ -0,0 +1,34 @@
+module OpenApi
+  # https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.1.md#security-scheme-object
+  class SecuritySchema
+    prepend EquatableAsContent
+
+    attr_accessor :type, :description, :name, :in, :scheme, :bearer_format, :flows, :open_id_connect_url
+
+    def initialize(type:, description: nil, name:, in:, scheme:, bearer_format: nil, flows:, open_id_connect_url:)
+      self.type = type
+      self.description = description
+      self.name = name
+      self.in = binding.local_variable_get(:in)
+      self.scheme = scheme
+      self.bearer_format = bearer_format
+      self.flows = flows
+      self.open_id_connect_url = open_id_connect_url
+    end
+
+    def self.load(hash)
+      return unless hash
+
+      new(
+        type: hash["type"].to_s,
+        description: hash["description"]&.to_s,
+        name: hash["name"].to_s,
+        in: hash["in"].to_s,
+        scheme: hash["scheme"].to_s,
+        bearer_format: hash["bearerFormat"]&.to_s,
+        flows: OAuthFlows.load(hash["flows"]),
+        open_id_connect_url: hash["openIdConnectUrl"].to_s,
+      )
+    end
+  end
+end

data/lib/open_api/serializers/yaml_serializer.rb

@@ -0,0 +1,17 @@
+require 'yaml'
+
+module OpenApi
+  module Serializers
+    class YamlSerializer
+      def serialize(specification)
+        hash = specification.serializable_hash
+        YAML.dump(hash)
+      end
+
+      def deserialize(yaml_string)
+        hash = YAML.load(yaml_string)
+        Specification.load(hash)
+      end
+    end
+  end
+end

data/lib/open_api/serializers.rb

@@ -0,0 +1,6 @@
+require 'open_api/serializers/yaml_serializer'
+
+module OpenApi
+  module Serializers
+  end
+end

data/lib/open_api/server.rb

@@ -0,0 +1,22 @@
+module OpenApi
+  # https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.1.md#server-object
+  class Server
+    prepend EquatableAsContent
+
+    attr_accessor :url, :description, :variables
+
+    def initialize(url:, description: nil, variables: nil)
+      self.url = url
+      self.description = description
+      self.variables = variables
+    end
+
+    def self.load(hash)
+      new(
+        url: hash["url"].to_s,
+        description: hash["description"]&.to_s,
+        variables: hash["variables"]&.map { |h| ServerVariable.load(h) }
+      )
+    end
+  end
+end

data/lib/open_api/server_variable.rb

@@ -0,0 +1,22 @@
+module OpenApi
+  # https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.1.md#server-variable-object
+  class ServerVariable
+    prepend EquatableAsContent
+
+    attr_accessor :enum, :default, :description
+
+    def initialize(enum: nil, default:, description: nil)
+      self.enum = enum
+      self.default = default
+      self.description = description
+    end
+
+    def self.load(hash)
+      new(
+        enum: hash["enum"],
+        default: hash["default"],
+        description: hash["description"],
+      )
+    end
+  end
+end

data/lib/open_api/specification.rb

@@ -0,0 +1,44 @@
+module OpenApi
+  # https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.1.md#oasObject
+  class Specification
+    prepend EquatableAsContent
+
+    attr_accessor :openapi, :info, :servers, :paths, :components, :security, :tags, :external_docs
+
+    def initialize(openapi:, info:, servers: nil, paths:, components: nil, security: nil, tags: nil, external_docs: nil)
+      self.openapi = openapi
+      self.info = info
+      self.paths = paths
+      self.components = components
+      self.security = security
+      self.tags = tags
+      self.external_docs = external_docs
+    end
+
+    def serializable_hash
+      {
+        "openapi" => openapi.to_s,
+        "info" => info.serializable_hash,
+        "paths" => paths.serializable_hash,
+        "components" => components&.serializable_hash,
+        "security" => security&.map(&:serializable_hash),
+        "tags" => tags&.map(&:serializable_hash),
+        "externalDocs" => external_docs&.serializable_hash,
+      }.compact
+    end
+
+    def self.load(hash)
+      return unless hash
+
+      new(
+        openapi: hash["openapi"].to_s,
+        info: Info.load(hash["info"]),
+        paths: Paths.load(hash["paths"]),
+        components: Components.load(hash["components"]),
+        security: hash["security"]&.map { |requirement_hash| SecurityRequirement.load(requirement_hash) },
+        tags: hash["tags"]&.map { |tag_hash| Tag.load(tag_hash) },
+        external_docs: ExternalDocumentation.load(hash["externalDocs"]),
+      )
+    end
+  end
+end

data/lib/open_api/tag.rb

@@ -0,0 +1,24 @@
+module OpenApi
+  # https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.1.md#tagObject
+  class Tag
+    prepend EquatableAsContent
+
+    attr_accessor :name, :description, :external_docs
+
+    def initialize(name:, description: nil, external_docs: nil)
+      self.name = name
+      self.description = description
+      self.external_docs = external_docs
+    end
+
+    def self.load(hash)
+      return unless hash
+
+      new(
+        name: hash["name"].to_s,
+        description: hash["description"]&.to_s,
+        external_docs: ExternalDocumentation.load(hash["externalDocs"]),
+      )
+    end
+  end
+end

data/lib/open_api/version.rb

@@ -0,0 +1,3 @@
+module OpenApi
+  VERSION = "0.1.0"
+end

data/lib/open_api/xml.rb

@@ -0,0 +1,26 @@
+module OpenApi
+  # https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.1.md#xml-object
+  class Xml
+    attr_accessor :name, :namespace, :prefix, :attribute, :wrapped
+
+    def initialize(name: nil, namespace: nil, prefix: nil, attribute: false, wrapped: false)
+      self.name = name
+      self.namespace = namespace
+      self.prefix = prefix
+      self.attribute = attribute
+      self.wrapped = wrapped
+    end
+
+    def self.load(hash)
+      return unless hash
+
+      new(
+        name: hash["name"],
+        namespace: hash["namespace"],
+        prefix: hash["prefix"],
+        attribute: hash["attribute"],
+        wrapped: hash["wrapped"],
+      )
+    end
+  end
+end

data/lib/open_api.rb

@@ -0,0 +1,47 @@
+# Dependant libraries
+require "active_support"
+require "active_support/core_ext/hash"
+require "active_support/core_ext/string/inflections"
+require "active_support/core_ext/object/inclusion"
+
+# open_api/*
+require "open_api/equatable_as_content"
+require "open_api/version"
+
+# Models
+require "open_api/specification"
+require "open_api/info"
+require "open_api/contact"
+require "open_api/license"
+require "open_api/server"
+require "open_api/server_variable"
+require "open_api/components"
+require "open_api/paths"
+require "open_api/path_item"
+require "open_api/operation"
+require "open_api/external_documentation"
+require "open_api/parameter"
+require "open_api/request_body"
+require "open_api/media_type"
+require "open_api/encoding"
+require "open_api/responses"
+require "open_api/response"
+require "open_api/callback"
+require "open_api/example"
+require "open_api/link"
+require "open_api/header"
+require "open_api/tag"
+require "open_api/reference"
+require "open_api/schema"
+require "open_api/discriminator"
+require "open_api/xml"
+require "open_api/security_schema"
+require "open_api/o_auth_flows"
+require "open_api/o_auth_flow"
+require "open_api/security_requirement"
+
+# Serializer
+require "open_api/serializers"
+
+module OpenApi
+end

data/open_api.gemspec

@@ -0,0 +1,30 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "open_api/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "open_api"
+  spec.version       = OpenApi::VERSION
+  spec.authors       = ["Kent Nagata"]
+  spec.email         = ["ngtknt@me.com"]
+
+  spec.summary       = "Provide PORO of OpenAPI specification"
+  spec.description   = "It provides PORO of OpenAPI specification. It only support OpenAPI v3."
+  spec.homepage      = "https://github.com/ngtk/open_api"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "activesupport", "~> 5.0"
+  spec.add_development_dependency "bundler", "~> 1.16"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "simplecov"
+end