openapi-processor/openapi-processor-spring#198, create validation package

Author: hauner

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

@@ -5,6 +5,7 @@
 
 package io.openapiprocessor.core.writer
 
+import io.openapiprocessor.core.converter.ApiOptions
 import io.openapiprocessor.core.support.toURI
 import io.openapiprocessor.core.writer.java.PathWriter
 import org.slf4j.Logger
@@ -21,11 +22,9 @@ import kotlin.io.path.deleteRecursively
 /**
  * Writer factory for local file system. Must be initialized via [InitWriterTarget].
  */
-class DefaultWriterFactory: WriterFactory, InitWriterTarget {
+class DefaultWriterFactory(val options: ApiOptions) : WriterFactory, InitWriterTarget {
     private var log: Logger = LoggerFactory.getLogger(this.javaClass.name)
 
-    private lateinit var targetDir: String
-    private lateinit var packageName: String
     private lateinit var paths: Map<String, Path>
 
     override fun createWriter(packageName: String, className: String): Writer {
@@ -36,9 +35,7 @@ class DefaultWriterFactory: WriterFactory, InitWriterTarget {
         return BufferedWriter(PathWriter(packagePath.resolve("${className}.java")))
     }
 
-    override fun init(targetDir: String, packageName: String) {
-        this.targetDir = targetDir
-        this.packageName = packageName
+    override fun init() {
         val pkgPaths = HashMap<String, Path>()
 
         log.debug ("initializing target folders")
@@ -56,30 +53,36 @@ class DefaultWriterFactory: WriterFactory, InitWriterTarget {
         pkgPaths[supportName] = supportPath
         log.debug ("initialized target folder: {}", supportPath.toAbsolutePath ().toString ())
 
+        if (options.beanValidation) {
+            val (validationName, validationPath) = initTargetPackage("validation")
+            pkgPaths[validationName] = validationPath
+            log.debug("initialized target folder: {}", validationPath.toAbsolutePath().toString())
+        }
+
         paths = pkgPaths
     }
 
     @OptIn(ExperimentalPathApi::class)
     private fun clearTargetDir() {
         try {
-            Path.of(toURI(targetDir)).deleteRecursively()
+            Path.of(toURI(options.targetDir!!)).deleteRecursively()
         } catch (ex: IOException) {
-            log.error("failed to clean target directory: {}", targetDir, ex)
+            log.error("failed to clean target directory: {}", options.targetDir, ex)
         }
     }
 
     private fun initTargetPackage(subPackageName: String): Pair<String, Path> {
-        val rootPackageFolder = packageName.replace(".", "/")
+        val rootPackageFolder = options.packageName.replace(".", "/")
 
-        val apiPackage = packageName.plus(".$subPackageName")
+        val apiPackage = options.packageName.plus(".$subPackageName")
         val apiFolder = listOf(rootPackageFolder, subPackageName).joinToString("/")
         val apiPath = createTargetPackage(apiFolder)
 
         return Pair(apiPackage, apiPath)
     }
 
     private fun createTargetPackage(apiPkg: String): Path {
-        val pkg = listOf(targetDir, apiPkg).joinToString("/")
+        val pkg = listOf(options.targetDir, apiPkg).joinToString("/")
 
         val target = Paths.get (toURI(pkg))
         Files.createDirectories(target)

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

@@ -6,5 +6,5 @@
 package io.openapiprocessor.core.writer
 
 fun interface InitWriterTarget {
-    fun init(targetDir: String, packageName: String)
+    fun init()
 }

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

@@ -29,11 +29,11 @@ class ApiWriter(
     private val enumWriter: StringEnumWriter,
     private val interfaceDataTypeWriter: InterfaceDataTypeWriter,
     private val formatter: SourceFormatter = GoogleFormatter(),
-    private val writerFactory: WriterFactory = DefaultWriterFactory()
+    private val writerFactory: WriterFactory = DefaultWriterFactory(options)
 ) {
     init {
         if (writerFactory is InitWriterTarget) {
-            writerFactory.init(options.targetDir!!, options.packageName)
+            writerFactory.init()
         }
     }
 

openapi-processor-core/src/test/kotlin/io/openapiprocessor/core/writer/DefaultWriterFactorySpec.kt

@@ -27,31 +27,56 @@ class DefaultWriterFactorySpec : StringSpec({
     beforeTest {
         options.packageName = "io.openapiprocessor"
         options.targetDir = listOf(target.toString(), "java", "src").joinToString(File.separator)
+        options.beanValidation = false
     }
 
     "initializes package folders" {
-        val writerFactory = DefaultWriterFactory()
-        writerFactory.init(options.targetDir!!, options.packageName)
+        val writerFactory = DefaultWriterFactory(options)
+        writerFactory.init()
 
         val api = options.getSourceDir("api")
         val model = options.getSourceDir("model")
         val support = options.getSourceDir("support")
+        val validation = options.getSourceDir("validation")
 
         Files.exists(api) shouldBe true
         Files.isDirectory(api) shouldBe true
         Files.exists(model) shouldBe true
         Files.isDirectory(model) shouldBe true
         Files.exists(support) shouldBe true
         Files.isDirectory(support) shouldBe true
+        Files.exists(validation) shouldBe false
+        Files.isDirectory(validation) shouldBe false
+    }
+
+    "initializes package folders with validation" {
+        options.beanValidation = true
+        val writerFactory = DefaultWriterFactory(options)
+        writerFactory.init()
+
+        val api = options.getSourceDir("api")
+        val model = options.getSourceDir("model")
+        val support = options.getSourceDir("support")
+        val validation = options.getSourceDir("validation")
+
+        Files.exists(api) shouldBe true
+        Files.isDirectory(api) shouldBe true
+        Files.exists(model) shouldBe true
+        Files.isDirectory(model) shouldBe true
+        Files.exists(support) shouldBe true
+        Files.isDirectory(support) shouldBe true
+        Files.exists(validation) shouldBe true
+        Files.isDirectory(validation) shouldBe true
     }
 
     "does not fail if target folder structure already exists" {
         Files.createDirectories(options.getSourceDir("api"))
         Files.createDirectories(options.getSourceDir("model"))
         Files.createDirectories(options.getSourceDir("support"))
+        Files.createDirectories(options.getSourceDir("validation"))
 
         shouldNotThrowAny {
-            DefaultWriterFactory().init(options.targetDir!!, options.packageName)
+            DefaultWriterFactory(options).init()
         }
     }
 
@@ -60,8 +85,8 @@ class DefaultWriterFactorySpec : StringSpec({
             return options.getSourcePath("support", name).text
         }
 
-        val factory = DefaultWriterFactory()
-        factory.init(options.targetDir!!, options.packageName)
+        val factory = DefaultWriterFactory(options)
+        factory.init()
 
         val writer = factory.createWriter("${options.packageName}.support", "Generated")
         writer.write("public @interface Generated {}\n")
@@ -75,8 +100,8 @@ class DefaultWriterFactorySpec : StringSpec({
             return options.getSourcePath("api", name).text
         }
 
-        val factory = DefaultWriterFactory()
-        factory.init(options.targetDir!!, options.packageName)
+        val factory = DefaultWriterFactory(options)
+        factory.init()
 
         val writer = factory.createWriter("${options.packageName}.api", "Api")
         writer.write("public interface Api {}\n")
@@ -90,8 +115,8 @@ class DefaultWriterFactorySpec : StringSpec({
             return options.getSourcePath("model", name).text
         }
 
-        val factory = DefaultWriterFactory()
-        factory.init(options.targetDir!!, options.packageName)
+        val factory = DefaultWriterFactory(options)
+        factory.init()
 
         val writer = factory.createWriter("${options.packageName}.model", "Model")
         writer.write("public class Model {}\n")
@@ -104,25 +129,30 @@ class DefaultWriterFactorySpec : StringSpec({
         val api = options.getSourceDir("api")
         val model = options.getSourceDir("model")
         val support = options.getSourceDir("support")
+        val validation = options.getSourceDir("validation")
 
         Files.createDirectories(api)
         Files.createDirectories(model)
         Files.createDirectories(support)
+        Files.createDirectories(validation)
 
         api.resolve("Old.java").createFile()
         model.resolve("Old.java").createFile()
         support.resolve("Old.java").createFile()
+        validation.resolve("Old.java").createFile()
 
         Files.exists(api.resolve("Old.java")) shouldBe true
         Files.exists(model.resolve("Old.java")) shouldBe true
         Files.exists(support.resolve("Old.java")) shouldBe true
+        Files.exists(validation.resolve("Old.java")) shouldBe true
 
-        val factory = DefaultWriterFactory()
-        factory.init(options.targetDir!!, options.packageName)
+        val factory = DefaultWriterFactory(options)
+        factory.init()
 
         Files.exists(api.resolve("Old.java")) shouldBe false
         Files.exists(model.resolve("Old.java")) shouldBe false
         Files.exists(support.resolve("Old.java")) shouldBe false
+        Files.exists(validation.resolve("Old.java")) shouldBe false
     }
 })