update to api changes in core

Author: hauner

src/main/kotlin/io/openapiprocessor/spring/processor/SpringProcessor.kt

@@ -13,7 +13,7 @@ import io.openapiprocessor.core.writer.SourceFormatter
 import io.openapiprocessor.core.writer.java.*
 import io.openapiprocessor.spring.Versions
 import io.openapiprocessor.spring.writer.java.*
-import io.openapiprocessor.spring.writer.java.MappingAnnotationWriter
+import io.openapiprocessor.spring.writer.java.MappingAnnotationFactory
 import io.openapiprocessor.spring.writer.java.ParameterAnnotationWriter
 import io.openapiprocessor.spring.writer.java.StatusAnnotationWriter
 import io.openapiprocessor.test.api.OpenApiProcessorTest
@@ -54,7 +54,7 @@ class SpringProcessor : OpenApiProcessorTest {
             val generatedWriter = GeneratedWriterImpl(generatedInfo, options)
             val validationWriter = ValidationWriter(options, generatedWriter)
             val beanValidations = BeanValidationFactory(options)
-            val javaDocWriter = JavaDocWriter(identifier)
+            val javaDocWriter = JavaDocFactory(identifier)
             val formatter = getFormatter(options)
 
             val writer = ApiWriter(
@@ -68,7 +68,7 @@ class SpringProcessor : OpenApiProcessorTest {
                         options,
                         identifier,
                         StatusAnnotationWriter(annotations),
-                        MappingAnnotationWriter(annotations),
+                        MappingAnnotationFactory(annotations),
                         ParameterAnnotationWriter(annotations),
                         beanValidations,
                         javaDocWriter

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

@@ -8,16 +8,15 @@ package io.openapiprocessor.spring.writer.java
 import io.openapiprocessor.core.model.Endpoint
 import io.openapiprocessor.core.model.EndpointResponse
 import io.openapiprocessor.spring.processor.SpringFrameworkAnnotations
-import java.io.Writer
-import io.openapiprocessor.core.writer.java.MappingAnnotationWriter as CoreMappingAnnotationWriter
+import io.openapiprocessor.core.writer.java.MappingAnnotationFactory as CoreMappingAnnotationFactory
 
 /**
- * spring mapping annotation writer
+ * spring mapping annotation factory
  */
-class MappingAnnotationWriter(private val annotations: SpringFrameworkAnnotations): CoreMappingAnnotationWriter {
+class MappingAnnotationFactory(private val annotations: SpringFrameworkAnnotations): 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 {

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

@@ -15,21 +15,20 @@ import io.openapiprocessor.core.model.datatypes.StringDataType
 import io.openapiprocessor.spring.processor.SpringFrameworkAnnotations
 import spock.lang.Specification
 
-class MappingAnnotationWriterSpec extends Specification {
+class MappingAnnotationFactorySpec extends Specification {
 
-    def writer = new MappingAnnotationWriter(new SpringFrameworkAnnotations())
-    def target = new StringWriter()
+    def factory = new MappingAnnotationFactory(new SpringFrameworkAnnotations())
 
     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,17 +43,17 @@ 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
@@ -63,15 +62,15 @@ 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
@@ -80,7 +79,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)
             ]
@@ -90,18 +89,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'           | """@GetMapping(path = "/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)
             ],
@@ -111,14 +110,14 @@ class MappingAnnotationWriterSpec extends Specification {
         ])
 
         when:
-        writer.write (target, endpoint, endpoint.endpointResponses.first ())
+        def annotations = factory.create (endpoint, endpoint.endpointResponses.first ())
 
         then:
-        target.toString () == """@GetMapping(path = "${endpoint.path}", produces = {"${endpoint.responses.'200'.first ().contentType}", "${endpoint.responses.'default'.first ().contentType}"})"""
+        annotations.first() == """@GetMapping(path = "${endpoint.path}", produces = {"${endpoint.responses.'200'.first ().contentType}", "${endpoint.responses.'default'.first ().contentType}"})"""
     }
 
     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,
@@ -130,14 +129,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)
             ],
@@ -153,14 +152,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,
@@ -172,5 +170,4 @@ class MappingAnnotationWriterSpec extends Specification {
             new Documentation(null, properties.description as String),
         )
     }
-
 }

src/test/groovy/io/openapiprocessor/spring/writer/java/MethodWriterSpec.groovy

@@ -20,7 +20,7 @@ import io.openapiprocessor.core.model.Documentation
 import io.openapiprocessor.core.model.datatypes.DataTypeName
 import io.openapiprocessor.core.model.datatypes.GenericDataType
 import io.openapiprocessor.core.model.datatypes.MappedDataType
-import io.openapiprocessor.core.writer.java.JavaDocWriter
+import io.openapiprocessor.core.writer.java.JavaDocFactory
 import io.openapiprocessor.core.writer.java.JavaIdentifier
 import io.openapiprocessor.spring.model.parameters.QueryParameter
 import io.openapiprocessor.spring.processor.SpringFrameworkAnnotations
@@ -40,10 +40,10 @@ class MethodWriterSpec extends Specification {
         apiOptions,
         identifier,
         new StatusAnnotationWriter(new SpringFrameworkAnnotations()),
-        new MappingAnnotationWriter(new SpringFrameworkAnnotations()),
+        new MappingAnnotationFactory(new SpringFrameworkAnnotations()),
         new ParameterAnnotationWriter(new SpringFrameworkAnnotations()),
         new BeanValidationFactory (apiOptions),
-        new JavaDocWriter(identifier))
+        new JavaDocFactory(identifier))
     def target = new StringWriter ()
 
     @Deprecated