dry_open_api 0.1.0

data/lib/dry_open_api/components.rb

@@ -0,0 +1,54 @@
+require 'dry-initializer'
+
+module DryOpenApi
+  # https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.1.md#componentsObject
+  class Components
+    prepend EquatableAsContent
+    extend Dry::Initializer
+
+    option :schemas, default: proc { nil }
+    option :responses, default: proc { nil }
+    option :parameters, default: proc { nil }
+    option :examples, default: proc { nil }
+    option :request_bodies, default: proc { nil }
+    option :headers, default: proc { nil }
+    option :security_schemes, default: proc { nil }
+    option :links, default: proc { nil }
+    option :callbacks, default: proc { nil }
+
+    # rubocop:disable Metrics/MethodLength
+    def serializable_hash
+      {
+        'schemas' => schemas&.map { |k, v| [k.to_s, v.serializable_hash] }&.to_h,
+        'responses' => responses&.map { |k, v| [k.to_s, v.serializable_hash] }&.to_h,
+        'parameters' => parameters&.map { |k, v| [k.to_s, v.serializable_hash] }&.to_h,
+        'examples' => examples&.map { |k, v| [k.to_s, v.serializable_hash] }&.to_h,
+        'requestBodies' => request_bodies&.map { |k, v| [k.to_s, v.serializable_hash] }&.to_h,
+        'headers' => headers&.map { |k, v| [k.to_s, v.serializable_hash] }&.to_h,
+        'securitySchemes' => security_schemes&.map { |k, v| [k.to_s, v.serializable_hash] }&.to_h,
+        'links' => links&.map { |k, v| [k.to_s, v.serializable_hash] }&.to_h,
+        'callbacks' => callbacks&.map { |k, v| [k.to_s, v.serializable_hash] }&.to_h
+      }.compact
+    end
+
+    # rubocop:disable Metrics/PerceivedComplexity
+    def self.load(hash)
+      return unless hash
+
+      new(
+        schemas: hash['schemas']&.map { |k, v| [k, Reference.load(v) || Schema.load(v)] }&.to_h,
+        responses: hash['responses']&.map { |k, v| [k, Reference.load(v) || Response.load(v)] }&.to_h,
+        parameters: hash['parameters']&.map { |k, v| [k, Reference.load(v) || Parameter.load(v)] }&.to_h,
+        examples: hash['examples']&.map { |k, v| [k, Reference.load(v) || Example.load(v)] }&.to_h,
+        request_bodies: hash['requestBodies']&.map { |k, v| [k, Reference.load(v) || RequestBody.load(v)] }&.to_h,
+        headers: hash['headers']&.map { |k, v| [k, Reference.load(v) || Header.load(v)] }&.to_h,
+        security_schemes: hash['securitySchemes']&.map { |k, v|
+                                                         [k, Reference.load(v) || SecuritySchema.load(v)]
+                                                       }&.to_h,
+        links: hash['links']&.map { |k, v| [k, Reference.load(v) || Link.load(v)] }&.to_h,
+        callbacks: hash['callbacks']&.map { |k, v| [k, Reference.load(v) || Callback.load(v)] }&.to_h
+      )
+    end
+    # rubocop:enable Metrics/MethodLength, Metrics/PerceivedComplexity
+  end
+end

data/lib/dry_open_api/contact.rb

@@ -0,0 +1,23 @@
+require 'dry-initializer'
+
+module DryOpenApi
+  # https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.1.md#contactObject
+  class Contact
+    prepend EquatableAsContent
+    extend Dry::Initializer
+
+    option :name, proc(&:to_s), default: proc { nil }
+    option :url, proc(&:to_s), default: proc { nil }
+    option :email, proc(&:to_s), default: proc { nil }
+
+    def self.load(hash)
+      return unless hash
+
+      new(
+        name: hash['name'],
+        url: hash['url'],
+        email: hash['email']
+      )
+    end
+  end
+end

data/lib/dry_open_api/data_types.rb

@@ -0,0 +1,31 @@
+module DryOpenApi
+  DataType = Struct.new(:name, :type, :format)
+
+  # defines the DataTypes defined by the spec and adds some shortcuts
+  # https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.1.md#data-types
+  class DataTypes
+    @data = [
+      DataType.new(:integer, :integer, :int32),
+      DataType.new(:long, :integer, :int64),
+      DataType.new(:float, :number, :float),
+      DataType.new(:double, :number, :double),
+      DataType.new(:string, :string),
+      DataType.new(:byte, :string, :byte),
+      DataType.new(:binary, :string, :binary),
+      DataType.new(:uuid, :string, :uuid),
+      DataType.new(:email, :string, :email),
+      DataType.new(:boolean, :boolean),
+      DataType.new(:date, :string, :date),
+      DataType.new(:dateTime, :string, :"date-time"),
+      DataType.new(:password, :string, :password)
+    ]
+
+    def self.all
+      @data
+    end
+
+    def self.all_types
+      all.map(&:type).uniq
+    end
+  end
+end

data/lib/dry_open_api/discriminator.rb

@@ -0,0 +1,40 @@
+module DryOpenApi
+  # https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.1.md#discriminatorObject
+  class Discriminator
+    prepend EquatableAsContent
+
+    attr_accessor :property_name, :mapping
+
+    def initialize(property_name: nil, mapping: {}, **other_fields_hash)
+      self.property_name = property_name
+      self.mapping = mapping.with_indifferent_access
+      self.other_fields_hash = other_fields_hash
+
+      other_fields_hash.keys.each do |field_name|
+        define_singleton_method(field_name) do
+          other_fields_hash[field_name]
+        end
+        define_singleton_method("#{field_name}=") do |value|
+          other_fields_hash[field_name] = value
+        end
+      end
+    end
+
+    def self.load(hash)
+      return unless hash
+
+      fixed_field_names = %w[propertyName mapping]
+      other_fields_hash = hash.reject { |key| key.to_s.in?(fixed_field_names) }
+
+      new(
+        property_name: hash['propertyName'].to_s,
+        mapping: hash['mapping'],
+        **other_fields_hash.symbolize_keys,
+      )
+    end
+
+    private
+
+    attr_accessor :other_fields_hash
+  end
+end

data/lib/dry_open_api/encoding.rb

@@ -0,0 +1,25 @@
+require 'dry-initializer'
+
+module DryOpenApi
+  # https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.1.md#encodingObject
+  class Encoding
+    prepend EquatableAsContent
+    extend Dry::Initializer
+
+    option :content_type, proc(&:to_s), default: proc { nil }
+    option :headers, default: proc { nil }
+    option :style, proc(&:to_s), default: proc { nil }
+    option :explode, default: proc { nil }
+    option :allow_reserved, default: proc { false }
+
+    def self.load(hash)
+      new(
+        content_type: hash['contentType'],
+        headers: hash['headers']&.map { |k, v| [k, Reference.load(v) || Header.load(v)] }.to_h,
+        style: hash['style'],
+        explode: hash['explode'],
+        allow_reserved: hash['allowReserved'].present?
+      )
+    end
+  end
+end

data/lib/dry_open_api/equatable_as_content.rb

@@ -0,0 +1,13 @@
+module DryOpenApi
+  module EquatableAsContent
+    def ==(other)
+      all_instance_variables == other.all_instance_variables
+    end
+
+    protected
+
+    def all_instance_variables
+      instance_variables.map { |name| instance_variable_get(name) }
+    end
+  end
+end

data/lib/dry_open_api/example.rb

@@ -0,0 +1,24 @@
+require 'dry-initializer'
+
+module DryOpenApi
+  # https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.1.md#exampleObject
+  class Example
+    extend Dry::Initializer
+
+    option :value, default: proc { nil }
+    option :summary, proc(&:to_s), default: proc { nil }
+    option :description, proc(&:to_s), default: proc { nil }
+    option :external_value, proc(&:to_s), default: proc { nil }
+
+    def self.load(hash)
+      return unless hash
+
+      new(
+        summary: hash['summary'],
+        description: hash['description'],
+        value: hash['value'],
+        external_value: hash['externalValue']
+      )
+    end
+  end
+end

data/lib/dry_open_api/external_documentation.rb

@@ -0,0 +1,20 @@
+require 'dry-initializer'
+
+module DryOpenApi
+  # https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.1.md#externalDocumentationObject
+  class ExternalDocumentation
+    extend Dry::Initializer
+
+    option :url, proc(&:to_s)
+    option :description, proc(&:to_s), default: proc { nil }
+
+    def self.load(hash)
+      return unless hash
+
+      new(
+        description: hash['description'],
+        url: hash['url']
+      )
+    end
+  end
+end

data/lib/dry_open_api/header.rb

@@ -0,0 +1,42 @@
+module DryOpenApi
+  # https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.1.md#header-object
+  class Header
+    prepend EquatableAsContent
+
+    attr_accessor :description, :required, :deprecated, :allow_empty_value
+
+    def initialize(description: nil, required: false, deprecated: nil, allow_empty_value: false, **other_fields_hash)
+      self.description = description
+      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 |field_name|
+        define_singleton_method(field_name) do
+          other_fields_hash[field_name]
+        end
+        define_singleton_method("#{field_name}=") do |value|
+          other_fields_hash[field_name] = value
+        end
+      end
+    end
+
+    def self.load(hash)
+      fixed_field_names = %i[description required deprecated allowEmptyValue]
+      other_fields_hash = hash.reject { |key| key.to_sym.in?(fixed_field_names) }
+
+      new(
+        description: hash['description'],
+        required: hash['required'].nil? ? false : hash['required'],
+        deprecated: hash['deprecated'].nil? ? false : hash['deprecated'],
+        allow_empty_value: hash['allowEmptyValue'].nil? ? false : hash['allowEmptyValue'],
+        **other_fields_hash.symbolize_keys
+      )
+    end
+
+    private
+
+    attr_accessor :other_fields_hash
+  end
+end

data/lib/dry_open_api/info.rb

@@ -0,0 +1,38 @@
+require 'dry-initializer'
+
+module DryOpenApi
+  # https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.1.md#info-object
+  class Info
+    prepend EquatableAsContent
+    extend Dry::Initializer
+
+    option :title, proc(&:to_s)
+    option :version, proc(&:to_s)
+    option :description, default: proc { nil }
+    option :terms_of_service, default: proc { nil }
+    option :contact, default: proc { nil }
+    option :license, default: proc { nil }
+
+    def serializable_hash
+      {
+        'title' => title,
+        'description' => description,
+        'termsOfService' => terms_of_service,
+        'contact' => contact&.serializable_hash,
+        'license' => license&.serializable_hash,
+        'version' => version
+      }.compact
+    end
+
+    def self.load(hash)
+      new(
+        title: hash['title'],
+        description: hash['description'],
+        terms_of_service: hash['termsOfService'],
+        contact: Contact.load(hash['contact']),
+        license: License.load(hash['license']),
+        version: hash['version']
+      )
+    end
+  end
+end

data/lib/dry_open_api/license.rb

@@ -0,0 +1,20 @@
+require 'dry-initializer'
+
+module DryOpenApi
+  # https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.1.md#license-object
+  class License
+    extend Dry::Initializer
+
+    option :name, proc(&:to_s)
+    option :url, proc(&:to_s), default: proc { nil }
+
+    def self.load(hash)
+      return unless hash
+
+      new(
+        name: hash['name'],
+        url: hash['url']
+      )
+    end
+  end
+end

data/lib/dry_open_api/link.rb

@@ -0,0 +1,50 @@
+module DryOpenApi
+  # https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.1.md#link-object
+  class Link
+    prepend EquatableAsContent
+
+    attr_accessor :operation_ref, :operation_id, :parameters, :request_body, :description, :server
+
+    def initialize(operation_ref: nil, operation_id: nil, parameters: nil, request_body: nil, description: nil, server: nil, **other_fields_hash)
+      self.operation_ref = operation_ref
+      self.operation_id = operation_id
+      self.parameters = parameters
+      self.request_body = request_body
+      self.description = description
+      self.server = server
+      self.other_fields_hash = other_fields_hash.with_indifferent_access
+
+      other_fields_hash.keys.each do |field_name|
+        define_singleton_method(field_name) do
+          other_fields_hash[field_name]
+        end
+        define_singleton_method("#{field_name}=") do |value|
+          other_fields_hash[field_name] = value
+        end
+      end
+    end
+
+    def self.load(hash)
+      return unless hash
+
+      fixed_field_names = %i[operationRef operationId parameters requestBody description server]
+      other_fields_hash = hash.reject { |key|
+        key.to_sym.in?(fixed_field_names)
+      }.symbolize_keys
+
+      new(
+        operation_ref: hash['operationRef']&.to_s,
+        operation_id: hash['operationId']&.to_s,
+        parameters: hash['parameters'],
+        request_body: RequestBody.load(hash['requestBody']),
+        description: hash['description']&.to_s,
+        server: Server.load(hash['server']),
+        **other_fields_hash
+      )
+    end
+
+    private
+
+    attr_accessor :other_fields_hash
+  end
+end

data/lib/dry_open_api/media_type.rb

@@ -0,0 +1,35 @@
+require 'dry-initializer'
+
+module DryOpenApi
+  class MediaType
+    prepend EquatableAsContent
+    extend Dry::Initializer
+
+    option :schema, default: proc { nil }
+    option :example, default: proc { nil }
+    option :examples, default: proc { nil }
+    option :encoding, default: proc { nil }
+
+    def serializable_hash
+      {
+        'schema' => schema&.serializable_hash,
+        'example' => example,
+        'examples' => examples&.map { |k, v| [k.to_s, v.serializable_hash] }&.to_h,
+        'encoding' => encoding&.map { |k, v| [k.to_s, v.serializable_hash] }&.to_h
+      }.compact
+    end
+
+    def self.load(hash)
+      return unless hash
+
+      indi_hash = hash.with_indifferent_access
+
+      new(
+        schema: Reference.load(indi_hash['schema']) || Schema.load(indi_hash['schema']),
+        example: indi_hash['example'],
+        examples: indi_hash['examples']&.map { |k, v| [k, Reference.load(v) || Example.load(v)] }&.to_h,
+        encoding: indi_hash['encoding']&.map { |k, v| [k, Encoding.load(v)] }&.to_h
+      )
+    end
+  end
+end

data/lib/dry_open_api/o_auth_flow.rb

@@ -0,0 +1,25 @@
+require 'dry-initializer'
+
+module DryOpenApi
+  # https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.1.md#oauthFlowObject
+  class OAuthFlow
+    prepend EquatableAsContent
+    extend Dry::Initializer
+
+    option :authorization_url, proc(&:to_s)
+    option :scopes, proc(&:to_s)
+    option :token_url, proc(&:to_s)
+    option :refresh_url, proc(&:to_s), default: proc { nil }
+
+    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