clean up

Author: hauner

openapi-processor-core-parser-openapi4j/src/main/kotlin/io/openapiprocessor/core/parser/openapi4j/MediaType.kt

@@ -6,13 +6,13 @@
 package io.openapiprocessor.core.parser.openapi4j
 
 import io.openapiprocessor.core.openapi.Encoding
-import io.openapiprocessor.core.openapi.MediaType as ParserMediaType
+import io.openapiprocessor.core.openapi.MediaType as OpenApiMediaType
 import org.openapi4j.parser.model.v3.MediaType as O4jMediaType
 
 /**
  * openapi4j MediaType abstraction.
  */
-class MediaType(val mediaType: O4jMediaType): ParserMediaType {
+class MediaType(val mediaType: O4jMediaType): OpenApiMediaType {
     override fun getSchema() = Schema(mediaType.schema)
 
     override val encodings: Map<String, Encoding>

openapi-processor-core-parser-openapi4j/src/main/kotlin/io/openapiprocessor/core/parser/openapi4j/OpenApi.kt

@@ -6,31 +6,31 @@
 package io.openapiprocessor.core.parser.openapi4j
 
 import io.openapiprocessor.core.openapi.Schema
-import io.openapiprocessor.core.openapi.Server
-import io.openapiprocessor.core.openapi.OpenApi as ParserOpenApi
-import io.openapiprocessor.core.openapi.Path as ParserPath
-import io.openapiprocessor.core.openapi.Schema as ParserSchema
-import io.openapiprocessor.core.openapi.RefResolver as ParserRefResolver
 import org.openapi4j.core.validation.ValidationResults
+import org.slf4j.Logger
+import org.slf4j.LoggerFactory
+import io.openapiprocessor.core.openapi.OpenApi as OpenApiOpenApi
+import io.openapiprocessor.core.openapi.Path as OpenApiPath
+import io.openapiprocessor.core.openapi.RefResolver as OpenApiRefResolver
+import io.openapiprocessor.core.openapi.Schema as OpenApiSchema
+import io.openapiprocessor.core.openapi.Server as OpenApiServer
 import org.openapi4j.parser.model.v3.OpenApi3 as O4jOpenApi
 import org.openapi4j.parser.model.v3.Path as O4jPath
 import org.openapi4j.parser.model.v3.Schema as O4jSchema
-import org.slf4j.Logger
-import org.slf4j.LoggerFactory
 
 /**
  * openapi4j parser result.
  */
 class OpenApi(
     private val api: O4jOpenApi,
     private val validations: ValidationResults,
-): ParserOpenApi {
+): OpenApiOpenApi {
     private val log: Logger = LoggerFactory.getLogger(this.javaClass.name)
 
     private val refResolver: RefResolverNative = RefResolverNative(api)
 
-    override fun getServers(): List<Server> {
-        val servers = mutableListOf<Server>()
+    override fun getServers(): List<OpenApiServer> {
+        val servers = mutableListOf<OpenApiServer>()
 
         api.servers.forEach { server ->
             servers.add(Server(server))
@@ -39,8 +39,8 @@ class OpenApi(
         return servers
     }
 
-    override fun getPaths(): Map<String, ParserPath> {
-        val paths = linkedMapOf<String, ParserPath>()
+    override fun getPaths(): Map<String, OpenApiPath> {
+        val paths = linkedMapOf<String, OpenApiPath>()
 
         api.paths.forEach { (name: String, value: O4jPath) ->
             var path = value
@@ -55,7 +55,7 @@ class OpenApi(
     }
 
     override fun getSchemas(): Map<String, Schema> {
-        val schemas = linkedMapOf<String, ParserSchema>()
+        val schemas = linkedMapOf<String, OpenApiSchema>()
 
         api.components?.schemas?.forEach { (name: String, schema: O4jSchema) ->
             schemas[name] = Schema(schema)
@@ -64,7 +64,7 @@ class OpenApi(
         return schemas
     }
 
-    override fun getRefResolver(): ParserRefResolver = RefResolver (api)
+    override fun getRefResolver(): OpenApiRefResolver = RefResolver (api)
 
     override fun printWarnings() {
         validations.items()

openapi-processor-core-parser-openapi4j/src/main/kotlin/io/openapiprocessor/core/parser/openapi4j/Operation.kt

@@ -5,11 +5,11 @@
 
 package io.openapiprocessor.core.parser.openapi4j
 
-import io.openapiprocessor.core.openapi.HttpMethod
-import io.openapiprocessor.core.openapi.Operation as ParserOperation
-import io.openapiprocessor.core.openapi.Parameter as ParserParameter
-import io.openapiprocessor.core.openapi.RequestBody as ParserRequestBody
-import io.openapiprocessor.core.openapi.Response as ParserResponse
+import io.openapiprocessor.core.openapi.HttpMethod as OpenApiHttpMethod
+import io.openapiprocessor.core.openapi.Operation as OpenApiOperation
+import io.openapiprocessor.core.openapi.Parameter as OpenApiParameter
+import io.openapiprocessor.core.openapi.RequestBody as OpenApiRequestBody
+import io.openapiprocessor.core.openapi.Response as OpenApiResponse
 import org.openapi4j.parser.model.v3.Operation as O4jOperation
 import org.openapi4j.parser.model.v3.Parameter as O4jParameter
 import org.openapi4j.parser.model.v3.Path as O4jPath
@@ -20,20 +20,20 @@ import java.net.URI
  * openapi4j Operation abstraction.
  */
 class Operation(
-    private val method: HttpMethod,
+    private val method: OpenApiHttpMethod,
     private val operation: O4jOperation,
     private val path: O4jPath,
     private val refResolver: RefResolverNative
-): ParserOperation {
+): OpenApiOperation {
 
-    override fun getMethod(): HttpMethod = method
+    override fun getMethod(): OpenApiHttpMethod = method
 
     override fun getOperationId(): String? {
         return operation.operationId
     }
 
-    override fun getParameters(): List<ParserParameter> {
-        val parameters = mutableListOf<ParserParameter>()
+    override fun getParameters(): List<OpenApiParameter> {
+        val parameters = mutableListOf<OpenApiParameter>()
 
         path.parameters?.map { p: O4jParameter ->
             var param = p
@@ -56,7 +56,7 @@ class Operation(
         return parameters
     }
 
-    override fun getRequestBody(): ParserRequestBody? {
+    override fun getRequestBody(): OpenApiRequestBody? {
         var requestBody = operation.requestBody
         if (requestBody == null) {
             return null
@@ -68,8 +68,8 @@ class Operation(
         return RequestBody (requestBody)
     }
 
-    override fun getResponses(): Map<String, ParserResponse> {
-        val content = linkedMapOf<String, ParserResponse>()
+    override fun getResponses(): Map<String, OpenApiResponse> {
+        val content = linkedMapOf<String, OpenApiResponse>()
 
         operation.responses.forEach { (key: String, value: O4jResponse) ->
             content[key] = Response(value, refResolver)

openapi-processor-core-parser-openapi4j/src/main/kotlin/io/openapiprocessor/core/parser/openapi4j/Parameter.kt

@@ -5,20 +5,20 @@
 
 package io.openapiprocessor.core.parser.openapi4j
 
-import io.openapiprocessor.core.openapi.Parameter as ParserParameter
-import io.openapiprocessor.core.openapi.Schema as ParserSchema
+import io.openapiprocessor.core.openapi.Parameter as OpenApiParameter
+import io.openapiprocessor.core.openapi.Schema as OpenApiSchema
 import org.openapi4j.parser.model.v3.Parameter as O4jParameter
 
 /**
  * openapi4j Parameter abstraction.
  */
-class Parameter(private val parameter: O4jParameter): ParserParameter {
+class Parameter(private val parameter: O4jParameter): OpenApiParameter {
 
     override fun getIn(): String = parameter.`in`
 
     override fun getName(): String = parameter.name
 
-    override fun getSchema(): ParserSchema = Schema (parameter.schema)
+    override fun getSchema(): OpenApiSchema = Schema (parameter.schema)
 
     override fun isRequired(): Boolean = if(parameter.required != null) {
         parameter.required

openapi-processor-core-parser-openapi4j/src/main/kotlin/io/openapiprocessor/core/parser/openapi4j/Parser.kt

@@ -6,22 +6,22 @@
 package io.openapiprocessor.core.parser.openapi4j
 
 import io.openapiprocessor.core.parser.ParserException
-import io.openapiprocessor.core.parser.Parser as ApiParser
-import io.openapiprocessor.core.openapi.OpenApi as ApiOpenApi
 import org.openapi4j.core.exception.ResolutionException
 import org.openapi4j.core.validation.ValidationException
 import org.openapi4j.parser.OpenApi3Parser
 import org.openapi4j.parser.validation.v3.OpenApi3Validator
 import org.slf4j.Logger
 import org.slf4j.LoggerFactory
+import io.openapiprocessor.core.openapi.OpenApi as OpenApiOpenApi
+import io.openapiprocessor.core.parser.Parser as ParserParser
 
 /**
  * openapi4j parser.
  */
-open class Parser : ApiParser {
+open class Parser : ParserParser {
     private val log: Logger = LoggerFactory.getLogger(this.javaClass.name)
 
-    override fun parse(apiPath: String): ApiOpenApi {
+    override fun parse(apiPath: String): OpenApiOpenApi {
         try {
             return run(apiPath)
         } catch (ex: ResolutionException) {
@@ -35,7 +35,7 @@ open class Parser : ApiParser {
         }
     }
 
-    private fun run(apiPath: String): ApiOpenApi {
+    private fun run(apiPath: String): OpenApiOpenApi {
         val api = OpenApi3Parser()
             .parse(toURL(apiPath), true)
 

openapi-processor-core-parser-openapi4j/src/main/kotlin/io/openapiprocessor/core/parser/openapi4j/Path.kt

@@ -5,9 +5,9 @@
 
 package io.openapiprocessor.core.parser.openapi4j
 
-import io.openapiprocessor.core.openapi.Path as ParserPath
-import io.openapiprocessor.core.openapi.HttpMethod
-import io.openapiprocessor.core.openapi.Operation as ParserOperation
+import io.openapiprocessor.core.openapi.Path as OpenApiPath
+import io.openapiprocessor.core.openapi.HttpMethod as OpenApiHttpMethod
+import io.openapiprocessor.core.openapi.Operation as OpenApiOperation
 import org.openapi4j.parser.model.v3.Path as Oa4jPath
 
 /**
@@ -17,13 +17,13 @@ class Path(
     private val path: String,
     private val info: Oa4jPath,
     private val refResolver: RefResolverNative
-): ParserPath {
+): OpenApiPath {
 
     override fun getPath(): String = path
 
-    override fun getOperations(): List<ParserOperation> {
+    override fun getOperations(): List<OpenApiOperation> {
         return info
             .operations
-            .map { Operation(HttpMethod.valueOf(it.key.uppercase()), it.value, info, refResolver) }
+            .map { Operation(OpenApiHttpMethod.valueOf(it.key.uppercase()), it.value, info, refResolver) }
     }
 }

openapi-processor-core-parser-openapi4j/src/main/kotlin/io/openapiprocessor/core/parser/openapi4j/RefResolver.kt

@@ -7,17 +7,17 @@ package io.openapiprocessor.core.parser.openapi4j
 
 import io.openapiprocessor.core.openapi.NamedSchema
 import io.openapiprocessor.core.openapi.getRefName
-import io.openapiprocessor.core.openapi.RefResolver as ParserRefResolver
-import io.openapiprocessor.core.openapi.Schema as ParserSchema
+import io.openapiprocessor.core.openapi.RefResolver as OpenApiRefResolver
+import io.openapiprocessor.core.openapi.Schema as OpenApiSchema
 import org.openapi4j.parser.model.v3.OpenApi3 as O4jOpenApi
 import org.openapi4j.parser.model.v3.Schema as O4jSchema
 
 /**
  * openapi4j $ref resolver.
  */
-class RefResolver(private val api: O4jOpenApi): ParserRefResolver {
+class RefResolver(private val api: O4jOpenApi): OpenApiRefResolver {
 
-    override fun resolve(ref: ParserSchema): NamedSchema {
+    override fun resolve(ref: OpenApiSchema): NamedSchema {
         val resolved: O4jSchema
 
         val refName = getRefName(ref.getRef()!!)

openapi-processor-core-parser-openapi4j/src/main/kotlin/io/openapiprocessor/core/parser/openapi4j/RequestBody.kt

@@ -16,8 +16,8 @@
 
 package io.openapiprocessor.core.parser.openapi4j
 
-import io.openapiprocessor.core.openapi.MediaType as ParserMediaType
-import io.openapiprocessor.core.openapi.RequestBody as ParserRequestBody
+import io.openapiprocessor.core.openapi.MediaType as OpenApiMediaType
+import io.openapiprocessor.core.openapi.RequestBody as OpenApiRequestBody
 import org.openapi4j.parser.model.v3.MediaType as O4jMediaType
 import org.openapi4j.parser.model.v3.RequestBody as O4jRequestBody
 
@@ -26,14 +26,14 @@ import org.openapi4j.parser.model.v3.RequestBody as O4jRequestBody
  *
  * @author Martin Hauner
  */
-class RequestBody(private val requestBody: O4jRequestBody): ParserRequestBody {
+class RequestBody(private val requestBody: O4jRequestBody): OpenApiRequestBody {
 
     override fun getRequired(): Boolean {
         return requestBody.required ?: false
     }
 
-    override fun getContent(): Map<String, ParserMediaType> {
-        val content = linkedMapOf<String, ParserMediaType>()
+    override fun getContent(): Map<String, OpenApiMediaType> {
+        val content = linkedMapOf<String, OpenApiMediaType>()
         requestBody.contentMediaTypes.forEach { (key: String, entry: O4jMediaType) ->
             content[key] = MediaType(entry)
         }

openapi-processor-core-parser-openapi4j/src/main/kotlin/io/openapiprocessor/core/parser/openapi4j/Response.kt

@@ -5,23 +5,23 @@
 
 package io.openapiprocessor.core.parser.openapi4j
 
-import io.openapiprocessor.core.openapi.MediaType as ParserMediaType
-import io.openapiprocessor.core.openapi.Response as ParserResponse
+import io.openapiprocessor.core.openapi.MediaType as OpenApiMediaType
+import io.openapiprocessor.core.openapi.Response as OpenApiResponse
 import org.openapi4j.parser.model.v3.MediaType as O4jMediaType
 import org.openapi4j.parser.model.v3.Response as O4jResponse
 
 /**
  * openapi4j Response abstraction.
  */
-class Response(private val response: O4jResponse, private val refResolver: RefResolverNative): ParserResponse {
+class Response(private val response: O4jResponse, private val refResolver: RefResolverNative): OpenApiResponse {
 
-    override fun getContent(): Map<String, ParserMediaType> {
+    override fun getContent(): Map<String, OpenApiMediaType> {
         var resp = response
         if(resp.isRef) {
             resp = refResolver.resolve(resp)
         }
 
-        val content = linkedMapOf<String, ParserMediaType>()
+        val content = linkedMapOf<String, OpenApiMediaType>()
         resp.contentMediaTypes?.forEach { (key: String, entry: O4jMediaType) ->
             content[key] = MediaType(entry)
         }

openapi-processor-core-parser-openapi4j/src/main/kotlin/io/openapiprocessor/core/parser/openapi4j/Schema.kt

@@ -6,13 +6,13 @@
 package io.openapiprocessor.core.parser.openapi4j
 
 import java.net.URI
-import io.openapiprocessor.core.openapi.Schema as ParserSchema
+import io.openapiprocessor.core.openapi.Schema as OpenApiSchema
 import org.openapi4j.parser.model.v3.Schema as O4jSchema
 
 /**
  * openapi4j Schema abstraction.
  */
-class Schema(val schema: O4jSchema) : ParserSchema {
+class Schema(val schema: O4jSchema) : OpenApiSchema {
 
     override fun getType(): String? {
         if (itemsOf () != null) {
@@ -32,10 +32,10 @@ class Schema(val schema: O4jSchema) : ParserSchema {
         return schema.enums
     }
 
-    override fun getItem(): ParserSchema = Schema(schema.itemsSchema)
+    override fun getItem(): OpenApiSchema = Schema(schema.itemsSchema)
 
-    override fun getProperties(): Map<String, ParserSchema> {
-        val props = LinkedHashMap<String, ParserSchema> ()
+    override fun getProperties(): Map<String, OpenApiSchema> {
+        val props = LinkedHashMap<String, OpenApiSchema> ()
 
         schema.properties?.forEach { (key: String, entry: O4jSchema) ->
             props[key] = Schema (entry)
@@ -55,8 +55,8 @@ class Schema(val schema: O4jSchema) : ParserSchema {
         return null;
     }
 
-    override fun getItems(): List<ParserSchema> {
-        val result: MutableList<ParserSchema> = mutableListOf()
+    override fun getItems(): List<OpenApiSchema> {
+        val result: MutableList<OpenApiSchema> = mutableListOf()
 
         schema.allOfSchemas?.forEach {
             result.add(Schema(it))