[Kotlin] Add Kotlin plugin support to generate classes from Kotlin classes (#57)

This adds support for Kotlin compiled sources to be utilized in the assertj generator.

This closes #48.

Author: Nava2

.github/workflows/release.yml

@@ -20,7 +20,7 @@ jobs:
       - uses: gradle/gradle-build-action@v2
 
       - name: Verify all checks pass
-        run: ./gradlew check
+        run: ./gradlew test
 
       - name: Publish plugin
         run: ./gradlew publishPlugins

build.gradle.kts

@@ -62,12 +62,15 @@ repositories {
 }
 
 dependencies {
+  implementation(kotlin("stdlib"))
+
   api(gradleApi())
   api("com.google.code.findbugs:jsr305:3.0.2")
   api("org.assertj:assertj-assertions-generator:2.2.1")
 
   implementation(gradleKotlinDsl())
   implementation("com.google.guava:guava:31.1-jre")
+  implementation("org.jetbrains.kotlin:kotlin-gradle-plugin:1.8.10")
 
   testApi("junit:junit:4.13.2")
 
@@ -90,14 +93,6 @@ tasks.check {
   dependsOn(tasks.named("projectHealth"))
 }
 
-tasks.compileGroovy {
-  classpath += files(tasks.compileKotlin.flatMap { it.destinationDirectory })
-}
-
-tasks.classes {
-  dependsOn(tasks.compileGroovy)
-}
-
 detekt {
   parallel = true
   autoCorrect = true

src/main/kotlin/org/assertj/generator/gradle/AssertJGeneratorGradlePlugin.kt

@@ -20,9 +20,13 @@ import org.gradle.api.logging.Logging
 import org.gradle.api.model.ObjectFactory
 import org.gradle.api.plugins.JavaPluginExtension
 import org.gradle.api.tasks.SourceSet
+import org.gradle.api.tasks.TaskProvider
 import org.gradle.kotlin.dsl.create
 import org.gradle.kotlin.dsl.getByType
+import org.gradle.kotlin.dsl.named
 import org.gradle.kotlin.dsl.register
+import org.jetbrains.kotlin.gradle.dsl.kotlinExtension
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 import javax.inject.Inject
 
 private val logger = Logging.getLogger(AssertJGeneratorGradlePlugin::class.java)
@@ -45,34 +49,67 @@ open class AssertJGeneratorGradlePlugin @Inject internal constructor(
         // For each sourceSet we're enacting an action on each one that adds an assertJ generation task to it
         logger.info("sourceSet: $sourceSet creating tasks")
 
+        sourceSet.extensions.create<AssertJGeneratorExtension>(
+          "assertJ",
+          objects,
+          project,
+          sourceSet,
+        )
+
         sourceSet.addAndConfigureAssertJGenerate(project, javaPluginExtension)
       }
+
+      // If we don't have the java plugin, we can't compile the generated sources. Thus, this is in the
+      // withPlugin() block
+      project.pluginManager.withPlugin("org.jetbrains.kotlin.jvm") {
+        project.applyForKotlin(javaPluginExtension)
+      }
     }
   }
 
-  private fun SourceSet.addAndConfigureAssertJGenerate(
-    project: Project,
-    javaPlugin: JavaPluginExtension,
-  ) {
-    extensions.create<AssertJGeneratorExtension>(
-      "assertJ",
-      objects,
-      project,
-      this,
-    )
-
-    val generateTaskName = getTaskName("generate", "assertJ")
-
-    logger.info("generationTask: $generateTaskName, sourceSet: $this")
-
-    // Create a new task for the source set
-    val generationTask = project.tasks.register<AssertJGenerationTask>(generateTaskName, objects, this)
-    generationTask.configure { task ->
-      task.classDirectories.srcDir(this.java.classesDirectory)
+  private fun Project.applyForKotlin(javaPluginExtension: JavaPluginExtension) {
+    kotlinExtension.sourceSets.configureEach { kotlinSourceSet ->
+      if (kotlinSourceSet.name == "test") return@configureEach
+
+      javaPluginExtension.sourceSets.named(kotlinSourceSet.name) { javaSourceSet ->
+        val kotlinCompile = project.tasks.named<KotlinCompile>(javaSourceSet.getCompileTaskName("kotlin"))
+
+        project.configureGenerateTask(javaSourceSet) {
+          dependsOn(kotlinCompile)
+
+          classDirectories.srcDir(kotlinCompile.flatMap { it.destinationDirectory })
+        }
+      }
+    }
+  }
+
+  private fun SourceSet.addAndConfigureAssertJGenerate(project: Project, javaPlugin: JavaPluginExtension) {
+    val generationTask = project.registerGenerateTask(this) {
+      classDirectories.srcDir(this@addAndConfigureAssertJGenerate.java.classesDirectory)
     }
 
     javaPlugin.sourceSets.named("test").configure { sourceSet ->
       sourceSet.java.srcDir(generationTask.flatMap { it.outputDir })
     }
   }
+
+  private fun Project.registerGenerateTask(
+    sourceSet: SourceSet,
+    configureBlock: AssertJGenerationTask.() -> Unit,
+  ): TaskProvider<AssertJGenerationTask> {
+    return tasks.register<AssertJGenerationTask>(sourceSet.generateAssertJTaskName, objects, sourceSet).apply {
+      configure(configureBlock)
+    }
+  }
+
+  private fun Project.configureGenerateTask(
+    sourceSet: SourceSet,
+    configureBlock: AssertJGenerationTask.() -> Unit,
+  ): TaskProvider<AssertJGenerationTask> {
+    return tasks.named<AssertJGenerationTask>(sourceSet.generateAssertJTaskName) {
+      configureBlock()
+    }
+  }
 }
+
+private val SourceSet.generateAssertJTaskName: String get() = getTaskName("generate", "assertJ")

src/test/kotlin/org/assertj/generator/gradle/KotlinSourcesBuild.kt

@@ -0,0 +1,97 @@
+/*
+ * Copyright 2023. assertj-generator-gradle-plugin contributors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ */
+package org.assertj.generator.gradle
+
+import org.assertj.core.api.Assertions.assertThat
+import org.assertj.generator.gradle.TestUtils.writeDefaultBuildKts
+import org.gradle.testkit.runner.GradleRunner
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.TemporaryFolder
+import java.nio.file.Paths
+
+internal class KotlinSourcesBuild {
+
+  @get:Rule
+  val testProjectDir = TemporaryFolder()
+
+  @Test
+  fun `only have kotlin sources`() {
+    testProjectDir.newFile("build.gradle.kts").writeDefaultBuildKts()
+
+    val srcDir = testProjectDir.newFolder("src", "main", "kotlin")
+
+    val packagePath = Paths.get("org/example/")
+
+    val srcPackagePath = srcDir.toPath().resolve(packagePath)
+    srcPackagePath.toFile().mkdirs()
+    val helloWorldKt = srcPackagePath.resolve("HelloWorld2.kt").toFile()
+
+    helloWorldKt.writeKotlin(
+      """
+      package org.example
+      
+      class HelloWorld2 {
+          // Getter & Setter
+          val isBrains = false
+          
+          // Getter
+          val foo = -1
+      }
+      """
+    )
+
+    val testDir = testProjectDir.newFolder("src", "test", "kotlin")
+
+    testDir.toPath().resolve(packagePath).toFile().mkdirs()
+    val testPackagePath = testDir.toPath().resolve(packagePath)
+    testPackagePath.toFile().mkdirs()
+    val helloWorldTestKt = testPackagePath.resolve("HelloWorldTest.kt").toFile()
+
+    helloWorldTestKt.writeKotlin(
+      """
+      package org.example
+      
+      import org.junit.Test
+      import org.example.Assertions.assertThat
+      
+      internal class HelloWorldTest {                
+          @Test
+          fun check() {
+              val hw = HelloWorld2()
+              assertThat(hw).hasFoo(-1)
+                            .isNotBrains()
+          }
+      }
+      """
+    )
+
+    val result = GradleRunner.create()
+      .withProjectDir(testProjectDir.root)
+      .withDebug(true)
+      .withPluginClasspath()
+      .withArguments("-i", "-s", "test")
+      .build()
+
+    assertThat(result.task(":generateAssertJ")).isSuccessful()
+    assertThat(result.task(":test")).isSuccessful()
+
+    val generatedPackagePath = testProjectDir.root.toPath()
+      .resolve("build/generated-src/main-test/java")
+      .resolve("org/example")
+
+    assertThat(generatedPackagePath)
+      .isDirectoryContaining("glob:**/Assertions.java")
+      .isDirectoryContaining("glob:**/HelloWorld2Assert.java")
+  }
+}

src/test/kotlin/org/assertj/generator/gradle/TestUtils.kt

@@ -53,4 +53,32 @@ internal object TestUtils {
 
   @JvmStatic
   fun File.writeDefaultBuildFile(): Unit = this.writeBuildFile("")
+
+  fun File.writeBuildKts(@Language("Kotlin") content: String = "") {
+    writeKotlin(
+      """
+      plugins { 
+          id("org.assertj.generator")
+          `java`
+          id("org.jetbrains.kotlin.jvm") version "1.8.10"
+      } 
+      
+      $content
+      
+      repositories {
+          mavenCentral()
+      }
+      
+      dependencies {
+          implementation(kotlin("stdlib"))
+          implementation("javax.annotation:javax.annotation-api:1.3.2")
+
+          testImplementation("org.assertj:assertj-core:3.24.2")
+          testImplementation("junit:junit:4.13.1")
+      }
+      """.trimIndent()
+    )
+  }
+
+  fun File.writeDefaultBuildKts(): Unit = this.writeBuildKts("")
 }