Support Groovy outputs

fixtures-annotations/build.gradle.kts

@@ -17,7 +17,7 @@ dependencies {
 }
 
 tasks.dokkaHtml.configure {
-    outputDirectory.set(buildDir.resolve("dokka"))
+    outputDirectory.set(layout.buildDirectory.asFile.get().resolve("dokka"))
 }
 
 plugins.withId("com.vanniktech.maven.publish") {

fixtures-processor/build.gradle.kts → fixtures-core/build.gradle.kts

@@ -1,15 +1,12 @@
 plugins {
     kotlin("jvm")
     id("org.jetbrains.dokka")
-    id("com.vanniktech.maven.publish")
 }
 
 repositories {
     mavenCentral()
 }
 
-apply(plugin = "com.vanniktech.maven.publish")
-
 dependencies {
     // Kotlin Dependencies
     implementation(Dependencies.Kotlin.KOTLIN)
@@ -25,11 +22,5 @@ dependencies {
 }
 
 tasks.dokkaHtml.configure {
-    outputDirectory.set(buildDir.resolve("dokka"))
-}
-
-plugins.withId("com.vanniktech.maven.publish") {
-    mavenPublish {
-        sonatypeHost = com.vanniktech.maven.publish.SonatypeHost.S01
-    }
+    outputDirectory.set(layout.buildDirectory.asFile.get().resolve("dokka"))
 }

fixtures-core/src/main/kotlin/com/theblueground/fixtures/FixtureBuilderGenerator.kt

@@ -0,0 +1,18 @@
+package com.theblueground.fixtures
+
+import com.google.devtools.ksp.symbol.KSFile
+import com.squareup.kotlinpoet.TypeName
+
+/**
+ * It uses the information that was extracted from [FixtureVisitor] to generate a file that contains
+ * a helper function which will create test data.
+ */
+interface FixtureBuilderGenerator {
+
+    fun generate(
+        randomize: Boolean,
+        containingFile: KSFile,
+        processedFixtures: List<ProcessedFixture>,
+        fixtureAdapters: Map<TypeName, ProcessedFixtureAdapter>,
+    )
+}

fixtures-processor/src/main/kotlin/com/theblueground/fixtures/FixtureProcessor.kt → fixtures-core/src/main/kotlin/com/theblueground/fixtures/FixtureProcessor.kt

@@ -1,6 +1,5 @@
 package com.theblueground.fixtures
 
-import com.google.devtools.ksp.processing.CodeGenerator
 import com.google.devtools.ksp.processing.KSPLogger
 import com.google.devtools.ksp.processing.Resolver
 import com.google.devtools.ksp.processing.SymbolProcessor
@@ -19,9 +18,9 @@ import com.squareup.kotlinpoet.ksp.KotlinPoetKspPreview
  * to generate the functions.
  */
 @KotlinPoetKspPreview
-internal class FixtureProcessor(
+class FixtureProcessor(
+    private val fixtureBuilderGenerator: FixtureBuilderGenerator,
     options: Map<String, String>,
-    codeGenerator: CodeGenerator,
     private val logger: KSPLogger,
 ) : SymbolProcessor {
 
@@ -33,8 +32,6 @@ internal class FixtureProcessor(
         private val FIXTURE_ANNOTATION_FULLY_QUALIFIED_NAME = Fixture::class.java.name
     }
 
-    private val fixtureBuilderGenerator = FixtureBuilderGenerator(codeGenerator = codeGenerator)
-
     private val processedFixtureAdapters = mutableMapOf<TypeName, ProcessedFixtureAdapter>()
 
     private val fixtureAdapterVisitor = FixtureAdapterVisitor(

fixtures-processor/src/main/kotlin/com/theblueground/fixtures/ProcessedFixture.kt → fixtures-core/src/main/kotlin/com/theblueground/fixtures/ProcessedFixture.kt

@@ -7,17 +7,17 @@ import com.squareup.kotlinpoet.ClassName
  * [Fixture] annotation. The information will be used in order to generate a helper function which
  * will create test data.
  */
-internal data class ProcessedFixture(
+data class ProcessedFixture(
     val parentName: String,
     val classType: ClassName,
     val parameters: List<ProcessedFixtureParameter>,
 )
 
-internal val ProcessedFixture.simpleName
+val ProcessedFixture.simpleName
     get() = this.classType.simpleName
 
-internal val ProcessedFixture.qualifiedName
+val ProcessedFixture.qualifiedName
     get() = this.classType.canonicalName
 
-internal val ProcessedFixture.packageName
+val ProcessedFixture.packageName
     get() = this.classType.packageName

fixtures-processor/src/main/kotlin/com/theblueground/fixtures/ProcessedFixtureAdapter.kt → fixtures-core/src/main/kotlin/com/theblueground/fixtures/ProcessedFixtureAdapter.kt

@@ -1,6 +1,6 @@
 package com.theblueground.fixtures
 
-internal data class ProcessedFixtureAdapter(
+data class ProcessedFixtureAdapter(
     val packageName: String,
     val functionName: String,
 )

fixtures-processor/src/main/kotlin/com/theblueground/fixtures/ProcessedFixtureParameter.kt → fixtures-core/src/main/kotlin/com/theblueground/fixtures/ProcessedFixtureParameter.kt

@@ -13,7 +13,7 @@ import com.squareup.kotlinpoet.WildcardTypeName
  * should be annotated with the [Fixture] annotation. The information will be used in order to
  * generate a helper function which will create test data.
  */
-internal sealed class ProcessedFixtureParameter(
+sealed class ProcessedFixtureParameter(
     open val name: String,
     open val type: TypeName,
 ) {
@@ -121,7 +121,7 @@ internal sealed class ProcessedFixtureParameter(
     )
 }
 
-internal val ProcessedFixtureParameter.packageName: String
+val ProcessedFixtureParameter.packageName: String
     get() = when (val type = this.type) {
         is ClassName -> type.packageName
         is ParameterizedTypeName -> type.rawType.packageName
@@ -132,7 +132,7 @@ internal val ProcessedFixtureParameter.packageName: String
         -> ""
     }
 
-internal val ProcessedFixtureParameter.typeName: String
+val ProcessedFixtureParameter.typeName: String
     get() = when (val type = this.type) {
         is ClassName -> type.canonicalName.removePrefix(type.packageName).replace(".", "")
         is ParameterizedTypeName -> type.rawType.simpleName

fixtures-processor-groovy/build.gradle.kts

@@ -0,0 +1,46 @@
+plugins {
+    kotlin("jvm")
+    id("org.jetbrains.dokka")
+    id("com.vanniktech.maven.publish")
+}
+
+repositories {
+    mavenCentral()
+}
+
+apply(plugin = "com.vanniktech.maven.publish")
+
+dependencies {
+    // Kotlin Dependencies
+    implementation(Dependencies.Kotlin.KOTLIN)
+    implementation(Dependencies.Kotlin.KSP)
+    implementation(Dependencies.Square.Poet.KSP)
+
+    compileOnly(project(":fixtures-core"))
+
+    testImplementation(TestDependencies.JUnit.JUNIT)
+    testImplementation(TestDependencies.Google.TRUTH)
+    testImplementation(project(":fixtures-test-utils"))
+}
+
+tasks.dokkaHtml.configure {
+    outputDirectory.set(layout.buildDirectory.asFile.get().resolve("dokka"))
+}
+
+plugins.withId("com.vanniktech.maven.publish") {
+    mavenPublish {
+        sonatypeHost = com.vanniktech.maven.publish.SonatypeHost.S01
+    }
+}
+tasks.named<Jar>("jar") {
+    from({
+        project(":fixtures-annotations").sourceSets["main"].output
+    })
+    from({
+        project(":fixtures-core").sourceSets["main"].output
+    })
+
+    from(sourceSets["main"].output)
+
+    destinationDirectory.set(file("${layout.buildDirectory.get()}/libs"))
+}

fixtures-processor-groovy/src/main/kotlin/com/theblueground/fixtures/FixtureBuilderGroovyGenerator.kt

@@ -0,0 +1,166 @@
+package com.theblueground.fixtures
+
+import com.google.devtools.ksp.processing.CodeGenerator
+import com.google.devtools.ksp.processing.Dependencies
+import com.google.devtools.ksp.symbol.KSFile
+import com.squareup.kotlinpoet.ClassName
+import com.squareup.kotlinpoet.TypeName
+import java.io.File
+import java.util.Locale
+
+/**
+ * It uses the information that was extracted from [FixtureVisitor] to generate a file that contains
+ * a helper function which will create test data.
+ */
+internal class FixtureBuilderGroovyGenerator(
+    private val codeGenerator: CodeGenerator,
+) : FixtureBuilderGenerator {
+
+    companion object {
+
+        private const val TAB = "\t"
+
+        const val OUTPUT_FIXTURE_FILENAME_SUFFIX = "Fixture"
+    }
+
+    private val valueGenerator = ParameterGroovyValueGenerator()
+
+    override fun generate(
+        randomize: Boolean,
+        containingFile: KSFile,
+        processedFixtures: List<ProcessedFixture>,
+        fixtureAdapters: Map<TypeName, ProcessedFixtureAdapter>,
+    ) {
+        val fileNameWithoutExtension = File(containingFile.fileName).nameWithoutExtension
+        val filename = fileNameWithoutExtension + OUTPUT_FIXTURE_FILENAME_SUFFIX
+        val dependencies = Dependencies(aggregating = true, containingFile)
+        val packageName = containingFile.packageName.asString()
+        val output = codeGenerator.createNewFile(
+            dependencies = dependencies,
+            packageName = packageName,
+            fileName = filename,
+            extensionName = "groovy",
+        )
+
+        output.write("package $packageName\n\n".toByteArray())
+        output.write(buildImports(processedFixtures = processedFixtures).toByteArray())
+        processedFixtures.forEach {
+            val builderClass = it.buildBuilderClass(
+                randomize = randomize,
+                fixtureAdapters = fixtureAdapters,
+            )
+            output.write(builderClass.toByteArray())
+        }
+
+        output.close()
+    }
+
+    private fun buildImports(
+        processedFixtures: List<ProcessedFixture>,
+    ): String = processedFixtures
+        .flatMap { it.parameters }
+        .filterNot { it is ProcessedFixtureParameter.PrimitiveParameter }
+        .distinct()
+        .joinToString("\n") {
+            // To support default value assignment of ZonedDateTime
+            if (it.javaTypeName == "ZonedDateTime") {
+                "import ${it.packageName}.${it.javaTypeName}\n" +
+                    "import ${it.packageName}.ZoneId"
+            } else {
+                "import ${it.packageName}.${it.javaTypeName}"
+            }
+        } + "\n"
+
+    private fun ProcessedFixture.buildBuilderClass(
+        randomize: Boolean,
+        fixtureAdapters: Map<TypeName, ProcessedFixtureAdapter>,
+    ): String {
+        val className = "$parentName${simpleName.replaceFirstChar { it.uppercaseChar() }}Builder"
+        val parametersPart = buildParametersPart(
+            randomize = randomize,
+            fixtureAdapters = fixtureAdapters,
+            parameters = parameters,
+        )
+        val functionsPart = buildFunctionsPart(
+            className = className,
+            parameters = parameters,
+        )
+        val instantiationPart = buildInstantiationPart(processedFixture = this)
+
+        return """
+            |
+            |class $className {
+            |
+            |$parametersPart
+            |
+            |${TAB}private $className() { }
+            |
+            |${TAB}static $className a$className() {
+            |$TAB${TAB}new $className()
+            |$TAB}
+            $functionsPart
+            |
+            $instantiationPart
+            |}
+            |
+        """.trimMargin()
+    }
+
+    private fun buildParametersPart(
+        randomize: Boolean,
+        fixtureAdapters: Map<TypeName, ProcessedFixtureAdapter>,
+        parameters: List<ProcessedFixtureParameter>,
+    ): String = parameters.joinToString("\n") {
+        val value = valueGenerator.generateDefaultValue(
+            randomize = randomize,
+            parameter = it,
+            fixtureAdapters = fixtureAdapters,
+        )
+
+        "${TAB}private ${it.javaTypeName} ${it.name} = $value"
+    }
+
+    private fun buildFunctionsPart(
+        className: String,
+        parameters: List<ProcessedFixtureParameter>,
+    ): String = parameters.joinToString("\n") {
+        val type = it.javaTypeName
+        val name = it.name
+        val capitalizeName = name.replaceFirstChar { char -> char.titlecase(Locale.getDefault()) }
+        """|
+           |$TAB$className with$capitalizeName($type $name) {
+           |$TAB${TAB}this.$name = $name
+           |$TAB${TAB}this
+           |$TAB}"""
+    }
+
+    private fun buildInstantiationPart(
+        processedFixture: ProcessedFixture,
+    ): String {
+        val parameters = processedFixture.parameters.joinToString("\n") {
+            "|$TAB$TAB${TAB}this.${it.name},"
+        }
+
+        val parent = if (processedFixture.parentName.isNotBlank()) {
+            "${processedFixture.parentName}."
+        } else {
+            ""
+        }
+
+        val name = processedFixture.simpleName
+        return """|$TAB$parent$name build() {
+                  |$TAB${TAB}new $parent$name(
+                  $parameters
+                  |$TAB$TAB)
+                  |$TAB}"""
+    }
+
+    private val ProcessedFixtureParameter.javaTypeName: String
+        get() = with(type) {
+            if (this is ClassName && this.simpleName == "Int") {
+                "Integer"
+            } else {
+                typeName
+            }
+        }
+}

fixtures-processor-groovy/src/main/kotlin/com/theblueground/fixtures/FixtureGroovyProcessorProvider.kt

@@ -0,0 +1,18 @@
+package com.theblueground.fixtures
+
+import com.google.devtools.ksp.processing.SymbolProcessor
+import com.google.devtools.ksp.processing.SymbolProcessorEnvironment
+import com.google.devtools.ksp.processing.SymbolProcessorProvider
+import com.squareup.kotlinpoet.ksp.KotlinPoetKspPreview
+
+@KotlinPoetKspPreview
+internal class FixtureGroovyProcessorProvider : SymbolProcessorProvider {
+
+    override fun create(
+        environment: SymbolProcessorEnvironment,
+    ): SymbolProcessor = FixtureProcessor(
+        fixtureBuilderGenerator = FixtureBuilderGroovyGenerator(codeGenerator = environment.codeGenerator),
+        options = environment.options,
+        logger = environment.logger,
+    )
+}