eclipse code formatter (#8)

Author: hauner

openapi-processor-core/build.gradle

@@ -74,6 +74,7 @@ dependencies {
     implementation (libs.commons.text)
     implementation (libs.commonmark)
     implementation (libs.format.java.google)
+    implementation (libs.format.java.eclipse)
     implementation (libs.slf4j)
 
     testImplementation (project(":openapi-processor-core-parser-api"))

openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/ApiOptions.kt

@@ -92,6 +92,11 @@ class ApiOptions: MappingSettings {
      */
     var formatCode = false
 
+    /**
+     * formatter: google or eclipse
+     */
+    var formatCodeFormatter: String? = null
+
     /**
      *  enable/disable the @Generated annotation (optional).
      */

openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/converter/OptionsConverter.kt

@@ -85,7 +85,11 @@ class OptionsConverter(private val checkObsoleteProcessorOptions: Boolean = fals
 
                     options.javadoc = mapping.options.javadoc
                     options.oneOfInterface = mapping.options.oneOfInterface
-                    options.formatCode = mapping.options.formatCode
+
+                    val (enableFormatCode, formatCodeFormatter) = checkFormatter(mapping.options)
+                    options.formatCode = enableFormatCode
+                    options.formatCodeFormatter = formatCodeFormatter
+
                     options.generatedAnnotation = mapping.options.generatedAnnotation
                     options.generatedDate = mapping.options.generatedDate
                     options.jsonPropertyAnnotation = JsonPropertyAnnotationMode.findBy(
@@ -128,6 +132,15 @@ class OptionsConverter(private val checkObsoleteProcessorOptions: Boolean = fals
         }
     }
 
+    private fun checkFormatter(options: Options): Pair<Boolean, String?> {
+        return when (options.formatCode) {
+            "true" -> Pair(true, "google")
+            "google" -> Pair(true, "google")
+            "eclipse" -> Pair(true, "eclipse")
+            else -> Pair(false, null)
+        }
+    }
+
     private fun checkServerUrl(options: Options): Pair<Boolean, Int?> {
         return when (options.basePath.serverUrl) {
             "false" -> Pair(false, null)

openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/processor/mapping/v2/Options.kt

@@ -70,7 +70,7 @@ data class Options(
     /**
      * enable/disable the code formatter (optional)
      */
-    val formatCode: Boolean = false,
+    val formatCode: String = "false",
 
     /**
      * enable/disable the @Generated annotation (optional)

openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/writer/java/EclipseFormatter.kt

@@ -0,0 +1,69 @@
+package io.openapiprocessor.core.writer.java
+
+import io.openapiprocessor.core.writer.SourceFormatter
+import org.eclipse.jdt.core.formatter.CodeFormatter
+import org.eclipse.jdt.core.ToolFactory
+import org.eclipse.jface.text.Document
+import java.io.StringReader
+import java.util.*
+import java.util.stream.Collectors
+
+
+class EclipseFormatter: SourceFormatter {
+    private lateinit var formatter: CodeFormatter
+
+    init {
+        initFormatter()
+    }
+
+    override fun format(raw: String): String {
+        try {
+            val textEdit = formatter.format(
+                CodeFormatter.K_COMPILATION_UNIT + CodeFormatter.F_INCLUDE_COMMENTS,
+                raw,
+                0,
+                raw.length,
+                0,
+                "\n"
+            )
+
+            val document = Document(raw)
+            textEdit.apply(document)
+
+            return correctEndOfFile(document.get())
+        } catch (e: Exception) {
+            throw FormattingException("failed to format the generated source: \n>>\n$raw\n<<", e)
+        }
+    }
+
+    private fun correctEndOfFile(formatted: String): String {
+        return StringBuilder()
+            .append(formatted)
+            .append("\n")
+            .toString()
+    }
+
+    private fun initFormatter() {
+        formatter = ToolFactory.createCodeFormatter(convertOptions(loadStyleOptions()))
+    }
+
+    private fun loadStyleOptions(): Properties {
+        val content = this.javaClass.getResource("/formatter.properties")!!.readText()
+        val reader = StringReader(content)
+        val properties = Properties()
+        properties.load(reader)
+        return properties
+    }
+
+    private fun convertOptions(prop: Properties): HashMap<String, String> {
+        return prop.entries
+            .stream()
+            .collect(
+                Collectors.toMap(
+                    { e -> e.toString() },
+                    { v -> v.toString() },
+                    { _, next -> next })
+                { HashMap() }
+            )
+    }
+}

openapi-processor-core/src/main/resources/formatter.properties

@@ -0,0 +1,3 @@
+org.eclipse.jdt.core.compiler.source = 1.8
+org.eclipse.jdt.core.formatter.tabulation.char = space
+org.eclipse.jdt.core..formatter.tabulation.size = 4

openapi-processor-core/src/main/resources/mapping/v11/mapping.example.yaml

@@ -0,0 +1,150 @@
+##
+## mapping example with keys & values
+##
+
+# mapping format [required]
+openapi-processor-mapping: v10
+
+options: # general processor options [required]
+
+  # target package [required]: io.openapiprocessor.generated (default)
+  package-name: io.openapiprocessor.generated
+
+  # validation annotation (optional): true or false (default), javax, jakarta.
+  bean-validation: jakarta
+
+  # generate javadoc from OpenAPI 'description' properties.
+  javadoc: true
+
+  # enable/disable code formatter: false (default), true (= google), google or eclipse
+  format-code: false
+
+  # suffix for model class names and enum names. Default is none.
+  model-name-suffix: Resource
+
+  # default (i.e pojo) or record
+  model-type: default
+
+  # default, string, supplier
+  enum-type: default
+
+  # generate common interface for an `oneOf` object list (optional): true or false (default)
+  one-of-interface: true
+
+  # enable/disable deletion of targetDir: true (default) or false.
+  clear-target-dir: false
+
+  # enable/disable @Generated annotation
+  generated-annotation: true
+
+  # enable/disable date on @Generated annotation
+  generated-date: true
+
+  # control @JsonProperty annotation (always|auto|never)
+  json-property-annotation: always
+
+  # target-dir related configuration
+  target-dir:
+    clear: true
+    layout: standard
+
+  # server-url related configuration
+  base-path:
+    # false, true = 0, 1, ..
+    prefix: 0
+    # property resource with the uri base path
+    properties-name: openapi.properties
+
+logging:
+  mapping: true
+  mapping-target: stdout
+
+compatibility:
+  bean-validation-valid-on-reactive: false
+  identifier-word-break-from-digit-to-letter: false
+
+map: # the type mappings
+
+  # global mappings, apply to all paths/endpoints
+
+  # response wrapper (optional)
+  result: org.springframework.http.ResponseEntity
+
+  # result style (optional, default "success")
+  result-style: all
+
+  # reactive single wrapper (optional)
+  single: reactor.core.publisher.Mono
+
+  # reactive array wrapper (optional)
+  multi: reactor.core.publisher.Flux
+
+  types: # global type mappings (optional)
+
+    - type: array => java.util.Collection
+
+    - type: Schema => java.util.Map
+      generics:
+        - java.lang.String
+        - java.lang.Double
+
+    - type: Schema @ io.openapiprocessor.Annotation()
+
+  parameters: # global parameter mappings (optional)
+
+    - name: foo => java.util.List
+    - name: bar => com.github.hauner.openapi.Bar
+    - name: param @ io.openapiprocessor.Annotation()
+    - type: Schema @ io.openapiprocessor.Annotation()
+
+  responses:  # global response mappings (optional)
+
+    - content: application/vnd.something => java.util.List
+    - content: application/json => com.github.hauner.openapi.FooBar
+
+
+  paths: # path/endpoint specific mappings (optional)
+
+    /first: # a path/endpoint from the openapi.yaml
+
+      # generate endpoint to a separate "excluded" interface
+      exclude: true
+
+    /second: # another path/endpoint from the openapi.yaml
+
+      # path mappings, allow the same mappings as on the global level (except the "paths" property)
+      # all mappings apply only to the parent path overriding any matching global mapping
+
+      # override top level "result" property, "plain" means no wrapper
+      result: plain
+      single: reactor.core.publisher.Mono
+      multi: reactor.core.publisher.Flux
+
+      types:
+        - type: Schema => java.util.Collection
+
+      parameters:
+        - name: foo => java.util.List
+        - add: bar => java.util.Set
+        - type: Schema @ io.openapiprocessor.Annotation()
+
+      responses:
+        - content: application/vnd.any => java.util.Set
+        - content: application/json => java.util.Map
+
+    /third:
+      result: plain
+
+      # path mappings can be limited to a specific http method
+
+      patch:
+        # path method mappings, allow the same mappings as on the global level (except the "paths" property)
+        # all mappings apply only to the parent path and method overriding any matching global mapping
+
+        null: org.openapitools.jackson.nullable.JsonNullable = JsonNullable.undefined()
+
+  extensions:
+    x-something: foo @ some.Annotation
+    x-something-else:
+      - foo @ some.custom.FooAnnotation
+      - bar @ some.custom.BarAnnotation