dry_open_api 0.1.0

data/lib/dry_open_api/o_auth_flows.rb

@@ -0,0 +1,27 @@
+require 'dry-initializer'
+
+module DryOpenApi
+  # https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.1.md#oauth-flows-object
+  class OAuthFlows
+    prepend EquatableAsContent
+    extend Dry::Initializer
+
+    attr_accessor :implicit, :password, :client_credentials, :authorization_code
+
+    option :implicit, proc(&:to_s), default: proc { nil }
+    option :password, proc(&:to_s), default: proc { nil }
+    option :client_credentials, proc(&:to_s), default: proc { nil }
+    option :authorization_code, proc(&:to_s), default: proc { nil }
+
+    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/dry_open_api/operation.rb

@@ -0,0 +1,60 @@
+require 'dry-initializer'
+
+module DryOpenApi
+  # no corresponding thing in the spec
+  class Operation
+    prepend EquatableAsContent
+    extend Dry::Initializer
+
+    option :responses
+    option :description, default: proc { nil }
+    option :summary, default: proc { nil }
+    option :operation_id, default: proc { nil }
+    option :tags, default: proc { nil }
+    option :external_docs, default: proc { nil }
+    option :parameters, default: proc { nil }
+    option :request_body, default: proc { nil }
+    option :callbacks, default: proc { nil }
+    option :deprecated, default: proc { nil }
+    option :security, default: proc { nil }
+    option :servers, default: proc { nil }
+
+    # rubocop:disable Metrics/MethodLength
+    def serializable_hash
+      {
+        'description' => description,
+        'responses' => responses.serializable_hash,
+        'tags' => tags&.map(&:to_s),
+        'summary' => summary,
+        'externalDocs' => external_docs&.serializable_hash,
+        'operationId' => operation_id,
+        'parameters' => parameters&.map(&:serializable_hash),
+        'requestBody' => request_body&.serializable_hash,
+        'callbacks' => callbacks&.map { |k, v| [k.to_s, v.serializable_hash] }&.to_h,
+        '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'],
+        description: hash['description'],
+        external_docs: ExternalDocumentation.load(hash['externalDocs']),
+        operation_id: hash['operationId'],
+        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
+    # rubocop:enable Metrics/MethodLength
+  end
+end

data/lib/dry_open_api/parameter.rb

@@ -0,0 +1,66 @@
+module DryOpenApi
+  # 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
+
+    # rubocop:disable Metrics/MethodLength, Metrics/ParameterLists
+    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
+    # rubocop:enable Metrics/MethodLength, Metrics/ParameterLists
+
+    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
+
+    def serializable_hash
+      {
+        'name' => name.to_s,
+        'in' => self.in.to_s,
+        'required' => required,
+        'deprecated' => deprecated,
+        'allow_empty_value' => allow_empty_value
+      }.merge(
+        other_fields_hash.map { |k, v| [k.to_s, v.serializable_hash] }.to_h
+      ).compact
+    end
+
+    private
+
+    attr_accessor :other_fields_hash
+  end
+end

data/lib/dry_open_api/path_item.rb

@@ -0,0 +1,42 @@
+module DryOpenApi
+  # 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 = %i[get put post delete options head patch trace].freeze
+
+    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.map { |k, v| [k.to_s.underscore, v] }.to_h.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.underscore, 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/dry_open_api/paths.rb

@@ -0,0 +1,26 @@
+module DryOpenApi
+  # 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_delegators :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/dry_open_api/reference.rb

@@ -0,0 +1,21 @@
+require 'dry-initializer'
+
+module DryOpenApi
+  # https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.1.md#referenceObject
+  class Reference
+    prepend EquatableAsContent
+    extend Dry::Initializer
+
+    option :ref, proc(&:to_s)
+
+    def serializable_hash
+      { '$ref' => ref }
+    end
+
+    def self.load(hash)
+      return unless hash && hash['$ref']
+
+      new(ref: hash['$ref'])
+    end
+  end
+end

data/lib/dry_open_api/request_body.rb

@@ -0,0 +1,22 @@
+require 'dry-initializer'
+
+module DryOpenApi
+  class RequestBody
+    prepend EquatableAsContent
+    extend Dry::Initializer
+
+    option :content
+    option :description, proc(&:to_s), default: proc { nil }
+    option :required, default: proc { false }
+
+    def self.load(hash)
+      return unless hash
+
+      new(
+        description: hash['description'],
+        content: hash['content'].map { |k, v| [k, MediaType.load(v)] }.to_h,
+        required: hash['required'].present?
+      )
+    end
+  end
+end

data/lib/dry_open_api/response.rb

@@ -0,0 +1,55 @@
+require 'dry-initializer'
+
+module DryOpenApi
+  # represents a single response object
+  # https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.2.md#responsesObject
+  class Response
+    prepend EquatableAsContent
+    extend Dry::Initializer
+
+    option :description, proc(&:to_s)
+
+    # rubocop:disable Style/Lambda
+    option :headers, ->(headers_param) {
+      return if headers_param.nil?
+
+      headers_param.to_h.with_indifferent_access
+    }, default: proc { nil }
+
+    option :content, ->(content_param) {
+      return if content_param.nil?
+
+      content_param.to_h.with_indifferent_access
+    }, default: proc { nil }
+
+    option :links, ->(links_param) {
+      return if links_param.nil?
+
+      links_param.to_h.with_indifferent_access
+    }, default: proc { nil }
+
+    # rubocop:enable Style/Lambda
+
+    def serializable_hash
+      {
+        'description' => description,
+        '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
+
+      indi_hash = hash.with_indifferent_access
+
+      new(
+        description: indi_hash['description'],
+        headers: indi_hash['headers']&.map { |k, v| [k, Header.load(v)] }&.to_h,
+        content: indi_hash['content']&.map { |k, v| [k, MediaType.load(v)] }&.to_h,
+        links: indi_hash['links']&.map { |k, v| [k, Reference.load(v) || Link.load(v)] }&.to_h
+      )
+    end
+  end
+end

data/lib/dry_open_api/responses.rb

@@ -0,0 +1,37 @@
+require 'dry-initializer'
+
+module DryOpenApi
+  class Responses
+    prepend EquatableAsContent
+    extend Forwardable
+    extend Dry::Initializer
+
+    attr_accessor :default
+
+    def initialize(default: nil, **responses_hash)
+      self.default = default
+      self.responses_hash = responses_hash.with_indifferent_access
+    end
+
+    def_delegators :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/dry_open_api/schema.rb

@@ -0,0 +1,107 @@
+module DryOpenApi
+  class Schema
+    prepend EquatableAsContent
+
+    attr_accessor :nullable, :discriminator, :read_only, :write_only, :xml, :external_docs, :example, :deprecated
+
+    def initialize(nullable: false, discriminator: nil, read_only: false, write_only: false, xml: nil, external_docs: nil, example: nil, deprecated: false, **other_fields_hash)
+      self.nullable = nullable
+      self.discriminator = discriminator
+      self.read_only = read_only
+      self.write_only = write_only
+      self.xml = xml
+      self.external_docs = external_docs
+      self.example = example
+      self.deprecated = deprecated
+      self.other_fields_hash = other_fields_hash
+
+      other_fields_hash.keys.each { |name| new_field(name) }
+    end
+
+    def method_missing(mid, *args)
+      len = args.length
+      if (mname = mid[/.*(?==\z)/m])
+        raise ArgumentError, "wrong number of arguments (#{len} for 1)", caller(1) if len != 1
+
+        new_field(mname)
+        other_fields_hash[mname.to_sym] = args[0]
+      elsif len.zero?
+        if other_fields_hash.key?(mname.to_s)
+          new_field(mname)
+          other_fields_hash[mname]
+        end
+      else
+        begin
+          super
+        rescue NoMethodError => e
+          e.backtrace.shift
+          raise
+        end
+      end
+    end
+
+    def new_field(name)
+      name = name.to_sym
+      define_singleton_method(name) { other_fields_hash[name] }
+      define_singleton_method("#{name}=") { |value| other_fields_hash[name] = value }
+    end
+
+    def serializable_hash
+      converted_other_fields_hash = other_fields_hash.map { |k, v|
+        value =
+          case k.to_sym
+          when :items then v.serializable_hash
+          when :properties then v.map { |key, prop_value| [key.to_s, prop_value.serializable_hash] }.to_h
+          else
+            v.is_a?(Array) ? v.map { |else_value| else_value.try(:serializable_hash) || else_value&.to_s } : v&.to_s
+          end
+        [k.to_s, value]
+      }.to_h
+
+      {
+        'nullable' => nullable == false ? nil : nullable,
+        'discriminator' => discriminator&.serializable_hash,
+        'readOnly' => read_only == false ? nil : read_only,
+        'writeOnly' => write_only == false ? nil : write_only,
+        'xml' => xml&.serializable_hash,
+        'externalDocs' => external_docs&.serializable_hash,
+        'example' => example,
+        'deprecated' => deprecated == false ? nil : deprecated
+      }
+        .merge(converted_other_fields_hash)
+        .compact
+    end
+
+    def self.load(hash)
+      other_fields_hash = hash.reject { |key|
+        key.to_sym.in?(%i[nullable discriminator readOnly writeOnly xml externalDocs example deprecated])
+      }.map { |k, v|
+        loaded_value =
+          case k.to_sym
+          when :items then Reference.load(v)
+          when :properties then v.map { |key, value| [key, Reference.new(value) || Schema.new(value)] }.to_h
+          else
+            v
+          end
+
+        [k, loaded_value]
+      }.to_h
+
+      new(
+        nullable: hash['nullable'].nil? ? false : hash['nullable'],
+        discriminator: hash['discriminator'],
+        read_only: hash['readOnly'].nil? ? false : hash['readOnly'],
+        write_only: hash['writeOnly'].nil? ? false : hash['writeOnly'],
+        xml: Xml.load(hash['xml']),
+        external_docs: ExternalDocumentation.load(hash['externalDocs']),
+        example: Example.load(hash['example']),
+        deprecated: hash['deprecated'].nil? ? false : hash['deprecated'],
+        **other_fields_hash.symbolize_keys
+      )
+    end
+
+    private
+
+    attr_accessor :other_fields_hash
+  end
+end