update to api changes in core

Author: hauner

src/main/kotlin/io/openapiprocessor/micronaut/processor/MicronautProcessor.kt

@@ -14,7 +14,7 @@ import io.openapiprocessor.core.writer.SourceFormatter
 import io.openapiprocessor.core.writer.java.*
 import io.openapiprocessor.micronaut.Versions
 import io.openapiprocessor.micronaut.writer.java.BeanValidations
-import io.openapiprocessor.micronaut.writer.java.MappingAnnotationWriter
+import io.openapiprocessor.micronaut.writer.java.MappingAnnotationFactory
 import io.openapiprocessor.micronaut.writer.java.ParameterAnnotationWriter
 import io.openapiprocessor.micronaut.writer.java.StatusAnnotationWriter
 import io.openapiprocessor.test.api.OpenApiProcessorTest
@@ -55,7 +55,7 @@ class MicronautProcessor : OpenApiProcessorTest {
             val generatedWriter = GeneratedWriterImpl(generatedInfo, options)
             val validationWriter = ValidationWriter(options, generatedWriter)
             val beanValidations = BeanValidations(options)
-            val javaDocWriter = JavaDocWriter(identifier)
+            val javaDocWriter = JavaDocFactory(identifier)
             val formatter = getFormatter(options)
 
             val writer = ApiWriter(
@@ -69,7 +69,7 @@ class MicronautProcessor : OpenApiProcessorTest {
                         options,
                         identifier,
                         StatusAnnotationWriter(annotations),
-                        MappingAnnotationWriter(),
+                        MappingAnnotationFactory(annotations),
                         ParameterAnnotationWriter(annotations),
                         beanValidations,
                         javaDocWriter

…t/writer/java/MappingAnnotationWriter.kt …/writer/java/MappingAnnotationFactory.ktsrc/main/kotlin/io/openapiprocessor/micronaut/writer/java/MappingAnnotationWriter.kt renamed to src/main/kotlin/io/openapiprocessor/micronaut/writer/java/MappingAnnotationFactory.kt src/main/kotlin/io/openapiprocessor/micronaut/writer/java/MappingAnnotationWriter.kt renamed to src/main/kotlin/io/openapiprocessor/micronaut/writer/java/MappingAnnotationFactory.kt

@@ -1,27 +1,28 @@
 /*
- * Copyright © 2020 https://github.com/openapi-processor/openapi-processor-micronaut
+ * Copyright 2020 https://github.com/openapi-processor/openapi-processor-micronaut
  * PDX-License-Identifier: Apache-2.0
  */
 
 package io.openapiprocessor.micronaut.writer.java
 
-import io.openapiprocessor.core.writer.java.MappingAnnotationWriter as CoreMappingAnnotationWriter
 import io.openapiprocessor.core.model.Endpoint
 import io.openapiprocessor.core.model.EndpointResponse
-import io.openapiprocessor.core.support.capitalizeFirstChar
-import java.io.Writer
+import io.openapiprocessor.micronaut.processor.MicronautFrameworkAnnotations
+import io.openapiprocessor.core.writer.java.MappingAnnotationFactory as CoreMappingAnnotationFactory
 
 /**
- * micronaut mapping annotation writer
+ * micronaut mapping annotation factory
  */
-class MappingAnnotationWriter: CoreMappingAnnotationWriter {
+class MappingAnnotationFactory(private val annotations: MicronautFrameworkAnnotations): CoreMappingAnnotationFactory {
 
-    override fun write(target: Writer, endpoint: Endpoint, endpointResponse: EndpointResponse) {
-        target.write(createAnnotation(endpoint, endpointResponse))
+    override fun create(endpoint: Endpoint, endpointResponse: EndpointResponse): List<String> {
+        return listOf(createAnnotation(endpoint, endpointResponse))
     }
 
     private fun createAnnotation(endpoint: Endpoint, endpointResponse: EndpointResponse): String {
-        var mapping = getMappingAnnotation(endpoint)
+        val annotation = annotations.getAnnotation(endpoint.method)
+
+        var mapping = annotation.annotationName
         mapping += "("
         mapping += "uri = " + quote(endpoint.path)
 
@@ -51,13 +52,7 @@ class MappingAnnotationWriter: CoreMappingAnnotationWriter {
         return mapping
     }
 
-
-    private fun getMappingAnnotation(endpoint: Endpoint): String {
-        return "@${endpoint.method.method.capitalizeFirstChar()}"
-    }
-
     private fun quote(content: String): String {
         return '"' + content + '"'
     }
-
 }

…/java/MappingAnnotationWriterSpec.groovy …java/MappingAnnotationFactorySpec.groovysrc/test/groovy/io/openapiprocessor/micronaut/writer/java/MappingAnnotationWriterSpec.groovy renamed to src/test/groovy/io/openapiprocessor/micronaut/writer/java/MappingAnnotationFactorySpec.groovy src/test/groovy/io/openapiprocessor/micronaut/writer/java/MappingAnnotationWriterSpec.groovy renamed to src/test/groovy/io/openapiprocessor/micronaut/writer/java/MappingAnnotationFactorySpec.groovy

@@ -1,5 +1,5 @@
 /*
- * Copyright © 2020 https://github.com/openapi-processor/openapi-processor-micronaut
+ * Copyright 2020 https://github.com/openapi-processor/openapi-processor-micronaut
  * PDX-License-Identifier: Apache-2.0
  */
 
@@ -13,23 +13,22 @@ import io.openapiprocessor.core.model.RequestBody
 import io.openapiprocessor.core.model.Response
 import io.openapiprocessor.core.model.datatypes.StringDataType
 import io.openapiprocessor.core.model.parameters.MultipartParameter
-import spock.lang.Ignore
+import io.openapiprocessor.micronaut.processor.MicronautFrameworkAnnotations
 import spock.lang.Specification
 
-class MappingAnnotationWriterSpec extends Specification {
-    def writer = new MappingAnnotationWriter()
-    def target = new StringWriter()
+class MappingAnnotationFactorySpec extends Specification {
+    def factory = new MappingAnnotationFactory(new MicronautFrameworkAnnotations())
 
     void "writes http method specific mapping annotation" () {
-        def endpoint = createEndpoint (path: path, method: httpMethod, responses: [
+        def endpoint = endpoint (path: path, method: httpMethod, responses: [
             '204' : [new EmptyResponse ()]
         ])
 
         when:
-        writer.write (target, endpoint, endpoint.endpointResponses.first ())
+        def annotations = factory.create (endpoint, endpoint.endpointResponses.first ())
 
         then:
-        target.toString () == expected
+        annotations.first() == expected
 
         where:
         httpMethod         | path         | expected
@@ -44,18 +43,18 @@ class MappingAnnotationWriterSpec extends Specification {
     }
 
     void "writes 'consumes' parameter with body content type" () {
-        def endpoint = createEndpoint (path: '/foo', method: HttpMethod.GET, responses: [
+        def endpoint = endpoint (path: '/foo', method: HttpMethod.GET, responses: [
             '204' : [new EmptyResponse ()]
         ], requestBodies: [
             new RequestBody('body', contentType, new StringDataType (), false, false,
                     null)
         ])
 
         when:
-        writer.write (target, endpoint, endpoint.endpointResponses.first ())
+        def annotations = factory.create (endpoint, endpoint.endpointResponses.first ())
 
         then:
-        target.toString () == expected
+        annotations.first() == expected
 
         where:
         contentType         | expected
@@ -64,17 +63,17 @@ class MappingAnnotationWriterSpec extends Specification {
     }
 
     void "writes 'produces' parameter with response content type" () {
-        def endpoint = createEndpoint (path: '/foo', method: HttpMethod.GET, responses: [
+        def endpoint = endpoint (path: '/foo', method: HttpMethod.GET, responses: [
             '200' : [
                 new Response (contentType, new StringDataType (), null)
             ],
         ])
 
         when:
-        writer.write (target, endpoint, endpoint.endpointResponses.first ())
+        def annotations = factory.create (endpoint, endpoint.endpointResponses.first ())
 
         then:
-        target.toString () == expected
+        annotations.first() == expected
 
         where:
         contentType         | expected
@@ -83,7 +82,7 @@ class MappingAnnotationWriterSpec extends Specification {
     }
 
     void "writes 'consumes' & 'produces' parameters" () {
-        def endpoint = createEndpoint (path: '/foo', method: HttpMethod.GET, responses: [
+        def endpoint = endpoint (path: '/foo', method: HttpMethod.GET, responses: [
             '200' : [
                 new Response (responseContentType, new StringDataType (), null)
             ]
@@ -93,18 +92,18 @@ class MappingAnnotationWriterSpec extends Specification {
         ])
 
         when:
-        writer.write (target, endpoint, endpoint.endpointResponses.first ())
+        def annotations = factory.create (endpoint, endpoint.endpointResponses.first ())
 
         then:
-        target.toString () == expected
+        annotations.first() == expected
 
         where:
         requestContentType | responseContentType | expected
         'foo/in'           | 'foo/out'           | """@Get(uri = "/foo", consumes = {"foo/in"}, produces = {"foo/out"})"""
     }
 
     void "writes mapping annotation with multiple result content types" () {
-        def endpoint = createEndpoint (path: '/foo', method: HttpMethod.GET, responses: [
+        def endpoint = endpoint (path: '/foo', method: HttpMethod.GET, responses: [
             '200' : [
                 new Response ('application/json', new StringDataType (), null)
             ],
@@ -114,15 +113,14 @@ class MappingAnnotationWriterSpec extends Specification {
         ])
 
         when:
-        writer.write (target, endpoint, endpoint.endpointResponses.first ())
+        def annotations = factory.create (endpoint, endpoint.endpointResponses.first ())
 
         then:
-        target.toString () == """@Get(uri = "${endpoint.path}", produces = {"${endpoint.responses.'200'.first ().contentType}", "${endpoint.responses.'default'.first ().contentType}"})"""
+        annotations.first() == """@Get(uri = "${endpoint.path}", produces = {"${endpoint.responses.'200'.first ().contentType}", "${endpoint.responses.'default'.first ().contentType}"})"""
     }
 
-    @Ignore // todo
     void "writes 'consumes' of multipart/form-data" () {
-        def endpoint = createEndpoint (path: '/foo', method: HttpMethod.GET,
+        def endpoint = endpoint (path: '/foo', method: HttpMethod.GET,
             parameters: [
                 new MultipartParameter ('mp1', new StringDataType(), false, false, null),
                 new MultipartParameter ('mp2', new StringDataType(), false, false, null)
@@ -133,14 +131,14 @@ class MappingAnnotationWriterSpec extends Specification {
         )
 
         when:
-        writer.write (target, endpoint, endpoint.endpointResponses.first ())
+        def annotations = factory.create (endpoint, endpoint.endpointResponses.first ())
 
         then:
-        target.toString () == """@Get(uri = "${endpoint.path}", consumes = {"multipart/form-data"})"""
+        annotations.first() == """@Get(uri = "${endpoint.path}", consumes = {"multipart/form-data"})"""
     }
 
     void "writes unique 'consumes' parameter" () {
-        def endpoint = createEndpoint (path: '/foo', method: HttpMethod.GET, responses: [
+        def endpoint = endpoint (path: '/foo', method: HttpMethod.GET, responses: [
             '204' : [new EmptyResponse ()]
         ], requestBodies: [
             new RequestBody('body', 'foo/in', new StringDataType (), false, false,
@@ -152,14 +150,14 @@ class MappingAnnotationWriterSpec extends Specification {
         ])
 
         when:
-        writer.write (target, endpoint, endpoint.endpointResponses.first ())
+        def annotations = factory.create (endpoint, endpoint.endpointResponses.first ())
 
         then:
-        target.toString ().contains ('consumes = {"foo/in"}')
+        annotations.first().contains ('consumes = {"foo/in"}')
     }
 
     void "writes unique 'produces' parameters" () {
-        def endpoint = createEndpoint (path: '/foo', method: HttpMethod.GET, responses: [
+        def endpoint = endpoint (path: '/foo', method: HttpMethod.GET, responses: [
             '200' : [
                 new Response ('foo/out', new StringDataType (), null)
             ],
@@ -175,14 +173,13 @@ class MappingAnnotationWriterSpec extends Specification {
         ])
 
         when:
-        writer.write (target, endpoint, endpoint.endpointResponses.first ())
+        def annotations = factory.create (endpoint, endpoint.endpointResponses.first ())
 
         then:
-        target.toString ().contains ('produces = {"foo/out"}')
+        annotations.first().contains ('produces = {"foo/out"}')
     }
 
-    @Deprecated
-    private Endpoint createEndpoint (Map properties) {
+    private Endpoint endpoint(Map properties) {
         return new Endpoint(
             properties.path as String ?: '',
             properties.method as HttpMethod ?: HttpMethod.GET,