openapi_kit-codegen 0.1.0.pre.1

data/lib/openapi_kit/codegen/model/document.rb

@@ -0,0 +1,302 @@
+# typed: strict
+# frozen_string_literal: true
+
+module OpenAPIKit
+  module Codegen
+    module Model
+      class HttpMethod < T::Enum
+        enums do
+          Get     = new("get")
+          Put     = new("put")
+          Post    = new("post")
+          Delete  = new("delete")
+          Options = new("options")
+          Head    = new("head")
+          Patch   = new("patch")
+          Trace   = new("trace")
+        end
+      end
+
+      class PathStyle < T::Enum
+        enums do
+          Simple = new("simple")
+          Label  = new("label")
+          Matrix = new("matrix")
+        end
+      end
+
+      class QueryStyle < T::Enum
+        enums do
+          Form           = new("form")
+          SpaceDelimited = new("spaceDelimited")
+          PipeDelimited  = new("pipeDelimited")
+          DeepObject     = new("deepObject")
+        end
+      end
+
+      class ParameterInfo < T::Struct
+        const :name, String
+        const :identifier, Symbol
+        const :schema, Schema
+        const :description, T.nilable(String), default: nil
+        const :deprecated, T::Boolean, default: false
+      end
+
+      module Parameter
+        extend T::Sig
+        extend T::Helpers
+        include Kernel
+        sealed!
+
+        sig { params(parameter: Parameter).returns(ParameterInfo) }
+        def self.info(parameter)
+          case parameter
+          when PathParameter, QueryParameter, HeaderParameter, CookieParameter then parameter.info
+          else T.absurd(parameter)
+          end
+        end
+
+        sig { params(parameter: Parameter).returns(T::Boolean) }
+        def self.required?(parameter)
+          case parameter
+          when PathParameter then true
+          when QueryParameter, HeaderParameter, CookieParameter then parameter.required
+          else T.absurd(parameter)
+          end
+        end
+      end
+
+      class PathParameter < T::Struct
+        include Parameter
+        const :info, ParameterInfo
+        const :style, PathStyle, default: PathStyle::Simple
+        const :explode, T::Boolean, default: false
+      end
+
+      class QueryParameter < T::Struct
+        include Parameter
+        const :info, ParameterInfo
+        const :required, T::Boolean, default: false
+        const :style, QueryStyle, default: QueryStyle::Form
+        const :explode, T::Boolean, default: true
+        const :allow_reserved, T::Boolean, default: false
+      end
+
+      class HeaderParameter < T::Struct
+        include Parameter
+        const :info, ParameterInfo
+        const :required, T::Boolean, default: false
+        const :explode, T::Boolean, default: false
+      end
+
+      class CookieParameter < T::Struct
+        include Parameter
+        const :info, ParameterInfo
+        const :required, T::Boolean, default: false
+        const :explode, T::Boolean, default: true
+      end
+
+      class Content < T::Struct
+        extend T::Sig
+
+        const :media_type, String
+        const :schema, T.nilable(Schema), default: nil
+
+        sig { params(media_type: String).returns(T::Boolean) }
+        def self.multipart?(media_type)
+          T.must(media_type.split(";").first).strip.downcase == "multipart/form-data"
+        end
+
+        sig { returns(T::Boolean) }
+        def multipart? = Content.multipart?(media_type)
+      end
+
+      class RequestBody < T::Struct
+        const :contents, T::Array[Content]
+        const :required, T::Boolean, default: false
+        const :description, T.nilable(String), default: nil
+      end
+
+      class Header < T::Struct
+        const :name, String
+        const :identifier, Symbol
+        const :schema, Schema
+        const :required, T::Boolean, default: false
+        const :description, T.nilable(String), default: nil
+      end
+
+      module Status
+        extend T::Sig
+        extend T::Helpers
+        include Kernel
+        sealed!
+
+        NAMES = T.let(
+          {
+            200 => "Ok", 201 => "Created", 202 => "Accepted", 203 => "NonAuthoritativeInformation",
+            204 => "NoContent", 205 => "ResetContent", 206 => "PartialContent",
+            301 => "MovedPermanently", 302 => "Found", 303 => "SeeOther", 304 => "NotModified",
+            307 => "TemporaryRedirect", 308 => "PermanentRedirect",
+            400 => "BadRequest", 401 => "Unauthorized", 402 => "PaymentRequired", 403 => "Forbidden",
+            404 => "NotFound", 405 => "MethodNotAllowed", 406 => "NotAcceptable", 409 => "Conflict",
+            410 => "Gone", 412 => "PreconditionFailed", 413 => "ContentTooLarge",
+            415 => "UnsupportedMediaType", 418 => "ImATeapot", 422 => "UnprocessableContent",
+            425 => "TooEarly", 428 => "PreconditionRequired", 429 => "TooManyRequests",
+            500 => "InternalServerError", 501 => "NotImplemented", 502 => "BadGateway",
+            503 => "ServiceUnavailable", 504 => "GatewayTimeout"
+          }.freeze,
+          T::Hash[Integer, String]
+        )
+
+        sig { params(status: Status).returns(String) }
+        def self.constant(status)
+          case status
+          when StatusCode then NAMES[status.code] || "Status#{status.code}"
+          when StatusRange then "Status#{status.hundreds}xx"
+          when DefaultStatus then "Default"
+          else T.absurd(status)
+          end
+        end
+
+        sig { params(raw: String).returns(Status) }
+        def self.parse(raw)
+          return DefaultStatus.new if raw == "default"
+          return StatusRange.new(hundreds: T.must(raw[0]).to_i) if raw.match?(/\A[1-5]XX\z/i)
+          return StatusCode.new(code: raw.to_i) if raw.match?(/\A[1-5]\d\d\z/)
+
+          raise SchemaError,
+                "#{raw.inspect} is not a valid response status. Use a three-digit code " \
+                "(200), a range (4XX) or `default`."
+        end
+      end
+
+      module SecurityScheme
+        extend T::Sig
+        extend T::Helpers
+        include Kernel
+        sealed!
+
+        sig { params(scheme: SecurityScheme).returns(String) }
+        def self.name_of(scheme)
+          case scheme
+          when ApiKeyScheme, HttpScheme, OAuth2Scheme, OpenIDConnectScheme then scheme.name
+          else T.absurd(scheme)
+          end
+        end
+
+        sig { params(scheme: SecurityScheme).returns(T::Hash[String, T.untyped]) }
+        def self.extensions_of(scheme)
+          case scheme
+          when ApiKeyScheme, HttpScheme, OAuth2Scheme, OpenIDConnectScheme then scheme.extensions
+          else T.absurd(scheme)
+          end
+        end
+      end
+
+      class StatusCode < T::Struct
+        include Status
+        const :code, Integer
+      end
+
+      class StatusRange < T::Struct
+        include Status
+        const :hundreds, Integer
+      end
+
+      class DefaultStatus < T::Struct
+        include Status
+      end
+
+      class Response < T::Struct
+        const :status, Status
+        const :contents, T::Array[Content]
+        const :headers, T::Array[Header], default: []
+        const :description, T.nilable(String), default: nil
+      end
+
+      class SecurityRequirement < T::Struct
+        extend T::Sig
+        const :schemes, T::Hash[String, T::Array[String]]
+
+        sig { returns(T::Boolean) }
+        def anonymous? = schemes.empty?
+      end
+
+      class ApiKeyLocation < T::Enum
+        enums do
+          Query  = new("query")
+          Header = new("header")
+          Cookie = new("cookie")
+        end
+      end
+
+      class ApiKeyScheme < T::Struct
+        include SecurityScheme
+        const :name, String
+        const :location, ApiKeyLocation
+        const :parameter_name, String
+        const :description, T.nilable(String), default: nil
+        const :extensions, T::Hash[String, T.untyped], default: {}
+      end
+
+      class HttpScheme < T::Struct
+        include SecurityScheme
+        const :name, String
+        const :scheme, String
+        const :bearer_format, T.nilable(String), default: nil
+        const :description, T.nilable(String), default: nil
+        const :extensions, T::Hash[String, T.untyped], default: {}
+      end
+
+      class OAuth2Scheme < T::Struct
+        include SecurityScheme
+        const :name, String
+        const :scopes, T::Hash[String, String], default: {}
+        const :description, T.nilable(String), default: nil
+        const :extensions, T::Hash[String, T.untyped], default: {}
+      end
+
+      class OpenIDConnectScheme < T::Struct
+        include SecurityScheme
+        const :name, String
+        const :url, String
+        const :description, T.nilable(String), default: nil
+        const :extensions, T::Hash[String, T.untyped], default: {}
+      end
+
+      class Operation < T::Struct
+        extend T::Sig
+        const :id, String
+        const :http_method, HttpMethod
+        const :path, String
+        const :tag, String
+        const :parameters, T::Array[Parameter], default: []
+        const :request_body, T.nilable(RequestBody), default: nil
+        const :responses, T::Array[Response], default: []
+        const :security, T.nilable(T::Array[SecurityRequirement]), default: nil
+        const :summary, T.nilable(String), default: nil
+        const :description, T.nilable(String), default: nil
+        const :deprecated, T::Boolean, default: false
+        const :extensions, T::Hash[String, T.untyped], default: {}
+      end
+
+      class Document < T::Struct
+        extend T::Sig
+        const :title, String
+        const :version, String
+        const :types, T::Array[TypeDef], default: []
+        const :operations, T::Array[Operation], default: []
+        const :security_schemes, T::Array[SecurityScheme], default: []
+        const :security, T::Array[SecurityRequirement], default: []
+
+        # An operation that declares no security inherits the document's.
+        sig { params(operation: Operation).returns(T::Array[SecurityRequirement]) }
+        def security_for(operation) = operation.security || security
+        const :raw, T::Hash[String, T.untyped], default: {}
+
+        sig { returns(T::Array[String]) }
+        def tags = operations.map(&:tag).uniq
+      end
+    end
+  end
+end

data/lib/openapi_kit/codegen/model/schema.rb

@@ -0,0 +1,110 @@
+# typed: strict
+# frozen_string_literal: true
+
+module OpenAPIKit
+  module Codegen
+    module Model
+      class Default < T::Struct
+        const :value, T.untyped
+      end
+
+      class Meta < T::Struct
+        const :description, T.nilable(String), default: nil
+        const :nullable, T::Boolean, default: false
+        const :deprecated, T::Boolean, default: false
+        const :default, T.nilable(Default), default: nil
+        const :read_only, T::Boolean, default: false
+        const :write_only, T::Boolean, default: false
+        const :extensions, T::Hash[String, T.untyped], default: {}
+        const :ruby_type, T.nilable(RubyType), default: nil
+      end
+
+      module Schema
+        extend T::Sig
+        extend T::Helpers
+        include Kernel
+        sealed!
+
+        sig { params(schema: Schema).returns(Meta) }
+        def self.meta(schema)
+          case schema
+          when Ref, StringSchema, IntegerSchema, NumberSchema, BooleanSchema, List, Freeform, Untyped
+            schema.meta
+          else T.absurd(schema)
+          end
+        end
+
+        sig { params(schema: Schema).returns(T::Boolean) }
+        def self.file?(schema)
+          return false unless schema.is_a?(StringSchema) && schema.format == "binary"
+
+          meta(schema).ruby_type.nil?
+        end
+      end
+
+      class Ref < T::Struct
+        include Schema
+        const :name, String
+        const :meta, Meta, factory: -> { Meta.new }
+      end
+
+      class StringSchema < T::Struct
+        include Schema
+        const :format, T.nilable(String), default: nil
+        const :min_length, T.nilable(Integer), default: nil
+        const :max_length, T.nilable(Integer), default: nil
+        const :pattern, T.nilable(String), default: nil
+        const :meta, Meta, factory: -> { Meta.new }
+      end
+
+      class IntegerSchema < T::Struct
+        include Schema
+        const :format, T.nilable(String), default: nil
+        const :minimum, T.nilable(Integer), default: nil
+        const :maximum, T.nilable(Integer), default: nil
+        const :exclusive_minimum, T::Boolean, default: false
+        const :exclusive_maximum, T::Boolean, default: false
+        const :multiple_of, T.nilable(Numeric), default: nil
+        const :meta, Meta, factory: -> { Meta.new }
+      end
+
+      class NumberSchema < T::Struct
+        include Schema
+        const :format, T.nilable(String), default: nil
+        const :minimum, T.nilable(Numeric), default: nil
+        const :maximum, T.nilable(Numeric), default: nil
+        const :exclusive_minimum, T::Boolean, default: false
+        const :exclusive_maximum, T::Boolean, default: false
+        const :multiple_of, T.nilable(Numeric), default: nil
+        const :meta, Meta, factory: -> { Meta.new }
+      end
+
+      class BooleanSchema < T::Struct
+        include Schema
+        const :meta, Meta, factory: -> { Meta.new }
+      end
+
+      class List < T::Struct
+        include Schema
+        const :items, Schema
+        const :min_items, T.nilable(Integer), default: nil
+        const :max_items, T.nilable(Integer), default: nil
+        const :unique_items, T::Boolean, default: false
+        const :meta, Meta, factory: -> { Meta.new }
+      end
+
+      class Freeform < T::Struct
+        include Schema
+        const :values, T.nilable(Schema), default: nil
+        const :min_properties, T.nilable(Integer), default: nil
+        const :max_properties, T.nilable(Integer), default: nil
+        const :meta, Meta, factory: -> { Meta.new }
+      end
+
+      class Untyped < T::Struct
+        include Schema
+        const :meta, Meta, factory: -> { Meta.new }
+      end
+    end
+  end
+end

data/lib/openapi_kit/codegen/model/type_def.rb

@@ -0,0 +1,89 @@
+# typed: strict
+# frozen_string_literal: true
+
+module OpenAPIKit
+  module Codegen
+    module Model
+      class Property < T::Struct
+        const :name, String
+        const :identifier, Symbol
+        const :schema, Schema
+        const :required, T::Boolean, default: false
+      end
+
+      module UnionTag
+        extend T::Helpers
+        include Kernel
+        sealed!
+      end
+
+      class Tagged < T::Struct
+        include UnionTag
+        const :property_name, String
+        const :mapping, T::Hash[String, String]
+      end
+
+      class Untagged < T::Struct
+        include UnionTag
+      end
+
+      module TypeDef
+        extend T::Sig
+        extend T::Helpers
+        include Kernel
+        sealed!
+
+        sig { params(type_def: TypeDef).returns(String) }
+        def self.name_of(type_def)
+          case type_def
+          when ObjectDef, FormDef, EnumDef, UnionDef, AliasDef then type_def.name
+          else T.absurd(type_def)
+          end
+        end
+      end
+
+      class ObjectDef < T::Struct
+        include TypeDef
+        const :name, String
+        const :properties, T::Array[Property]
+        const :additional_properties, T.nilable(Schema), default: nil
+        const :meta, Meta, factory: -> { Meta.new }
+      end
+
+      class FormDef < T::Struct
+        include TypeDef
+        const :name, String
+        const :properties, T::Array[Property]
+        const :additional_properties, T.nilable(Schema), default: nil
+        const :meta, Meta, factory: -> { Meta.new }
+      end
+
+      class EnumMember < T::Struct
+        const :constant, String
+        const :value, T.any(String, Integer)
+      end
+
+      class EnumDef < T::Struct
+        include TypeDef
+        const :name, String
+        const :members, T::Array[EnumMember]
+        const :meta, Meta, factory: -> { Meta.new }
+      end
+
+      class UnionDef < T::Struct
+        include TypeDef
+        const :name, String
+        const :members, T::Array[Schema]
+        const :tag, UnionTag
+        const :meta, Meta, factory: -> { Meta.new }
+      end
+
+      class AliasDef < T::Struct
+        include TypeDef
+        const :name, String
+        const :target, Schema
+        const :meta, Meta, factory: -> { Meta.new }
+      end
+    end
+  end
+end

data/lib/openapi_kit/codegen/naming.rb

@@ -0,0 +1,78 @@
+# typed: strict
+# frozen_string_literal: true
+
+module OpenAPIKit
+  module Codegen
+    module Naming
+      extend T::Sig
+
+      RESERVED = T.let(
+        %w[
+          BEGIN END alias and begin break case class def defined? do else elsif end ensure
+          false for if in module next nil not or redo rescue retry return self super then
+          true undef unless until when while yield __FILE__ __LINE__ __ENCODING__
+        ].freeze,
+        T::Array[String]
+      )
+
+      sig { params(string: String).returns(T::Array[String]) }
+      def self.words(string)
+        string
+          .to_s
+          .gsub(/([A-Z]+)([A-Z][a-z])/, '\1 \2') # HTTPSConnection -> HTTPS Connection
+          .gsub(/([a-z\d])([A-Z])/, '\1 \2')     # gameDomain      -> game Domain
+          .split(/[^a-zA-Z0-9]+/)
+          .reject(&:empty?)
+      end
+
+      sig { params(string: String).returns(String) }
+      def self.snake(string) = words(string).map(&:downcase).join("_")
+
+      sig { params(string: String).returns(String) }
+      def self.pascal(string) = words(string).map(&:capitalize).join
+
+      SHADOWED = T.let(
+        %w[
+          __id__ __send__ as_json class class_eval clone deep_dup define_singleton_method
+          deserialize display dup enum_for extend freeze gem hash inspect instance_eval
+          instance_exec instance_values instance_variable_get instance_variable_names
+          instance_variable_set instance_variables itself method methods object_id presence
+          presence_in pretty_inspect pretty_print pretty_print_cycle pretty_print_inspect
+          pretty_print_instance_variables private_methods protected_methods public_method
+          public_methods public_send remove_instance_variable send serialize singleton_class
+          singleton_method singleton_methods tap then to_enum to_json to_param to_query to_s
+          to_yaml try with with_options yield_self
+        ].to_set.freeze,
+        T::Set[String]
+      )
+
+      sig { params(string: String).returns(Symbol) }
+      def self.identifier(string)
+        name = snake(string)
+        name = "value" if name.empty?
+        name = "n#{name}" if name.match?(/\A\d/)
+        name = "#{name}_" if RESERVED.include?(name) || SHADOWED.include?(name)
+        name.to_sym
+      end
+
+      sig { params(string: String).returns(String) }
+      def self.constant(string)
+        name = pascal(string)
+        name = "Value" if name.empty?
+        name = "Value#{name}" if name.match?(/\A\d/)
+        name
+      end
+
+      sig { params(value: T.untyped).returns(String) }
+      def self.enum_member(value)
+        case value
+        when ::String  then constant(value)
+        when ::Integer then "Value#{value.negative? ? "Minus#{value.abs}" : value}"
+        when true      then "True"
+        when false     then "False"
+        else constant(value.to_s)
+        end
+      end
+    end
+  end
+end

data/lib/openapi_kit/codegen/ruby_type.rb

@@ -0,0 +1,48 @@
+# typed: strict
+# frozen_string_literal: true
+
+module OpenAPIKit
+  module Codegen
+    class RubyType < T::Struct
+      extend T::Sig
+
+      CONSTANT_PATH = T.let(/\A(::)?[A-Z]\w*(::[A-Z]\w*)*\z/, Regexp)
+
+      const :type, String
+      const :codec, String
+
+      sig { params(where: String, value: T.untyped).returns(RubyType) }
+      def self.parse(where, value)
+        unless value.is_a?(Hash)
+          raise ConfigError,
+                "#{where} must be a mapping with `type` and `codec`, got #{value.inspect}.\n  " \
+                "#{where}:\n    type: \"::YourType\"\n    codec: \"YourApp::YourTypeCodec\""
+        end
+
+        unknown = value.keys.map(&:to_s) - %w[type codec]
+        unless unknown.empty?
+          raise ConfigError,
+                "#{where} has unknown key#{"s" if unknown.size > 1} #{unknown.sort.join(", ")}. " \
+                "Valid keys: type, codec."
+        end
+
+        missing = %w[type codec].reject { |key| value[key] }
+        unless missing.empty?
+          raise ConfigError,
+                "#{where} is missing #{missing.join(" and ")}. Both are required: `type` is what " \
+                "appears in signatures, `codec` is what converts it: a module extending, or an " \
+                "instance of a class including, OpenAPIKit::Codec."
+        end
+
+        codec = value.fetch("codec").to_s
+        unless codec.match?(CONSTANT_PATH)
+          raise ConfigError,
+                "#{where}.codec is #{codec.inspect}, which is not a Ruby constant path. " \
+                "It must name a constant holding a codec, e.g. \"YourApp::YourTypeCodec\"."
+        end
+
+        new(type: value.fetch("type").to_s, codec: codec)
+      end
+    end
+  end
+end