[Modernize] Use *.class files as sources instead of *.java (#47)

This is a smaller change that has a few big benefits:

1. Removes all deprecation warnings 🎉
2. Inputs are now correctly handled, if there is any change in classes we will always regenerate everything -- previously it would only regenerate changed files which is misleading due to the reflected data potentially being incorrect
3. Excluding files via `sourceSet.exclude` works again -- restoring the ignored test 
    - part of a fix for #16
5. This enables us to add support for other JVM languages: Groovy, Kotlin, etc. 🚀 

Closes #5 
Closes #17

Author: Nava2

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

@@ -67,6 +67,9 @@ open class AssertJGeneratorGradlePlugin @Inject internal constructor(
 
     // 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)
+    }
 
     javaPlugin.sourceSets.named("test").configure { sourceSet ->
       sourceSet.java.srcDir(generationTask.flatMap { it.outputDir })

src/main/kotlin/org/assertj/generator/gradle/internal/tasks/AssertionsGeneratorReport.kt

@@ -33,8 +33,8 @@ internal class AssertionsGeneratorReport(
   private val inputClassesNotFound = TreeSet<String>()
   private val userTemplates = mutableListOf<String>()
 
-  fun addGeneratedAssertionFiles(vararg generatedCustomAssertionFiles: File) {
-    generatedCustomAssertionFileNames += generatedCustomAssertionFiles.map { it.canonicalPath }
+  fun addGeneratedAssertionFiles(vararg files: File) {
+    generatedCustomAssertionFileNames += files.map { it.canonicalPath }
   }
 
   fun getReportContent(): String = buildString {

src/main/kotlin/org/assertj/generator/gradle/tasks/AssertJGenerationTask.kt

@@ -12,7 +12,6 @@
  */
 package org.assertj.generator.gradle.tasks
 
-import com.google.common.collect.Sets
 import com.google.common.reflect.TypeToken
 import org.assertj.assertions.generator.AssertionsEntryPointType
 import org.assertj.assertions.generator.BaseAssertionGenerator
@@ -22,29 +21,29 @@ import org.assertj.assertions.generator.util.ClassUtil
 import org.assertj.generator.gradle.internal.tasks.AssertionsGeneratorReport
 import org.assertj.generator.gradle.tasks.config.AssertJGeneratorExtension
 import org.assertj.generator.gradle.tasks.config.SerializedTemplate
+import org.gradle.api.DefaultTask
 import org.gradle.api.file.ConfigurableFileCollection
 import org.gradle.api.file.DirectoryProperty
 import org.gradle.api.file.FileCollection
-import org.gradle.api.file.FileTree
-import org.gradle.api.file.FileVisitDetails
+import org.gradle.api.file.SourceDirectorySet
 import org.gradle.api.model.ObjectFactory
 import org.gradle.api.provider.ListProperty
 import org.gradle.api.provider.Property
 import org.gradle.api.provider.SetProperty
 import org.gradle.api.tasks.CacheableTask
 import org.gradle.api.tasks.Classpath
+import org.gradle.api.tasks.IgnoreEmptyDirectories
 import org.gradle.api.tasks.Input
 import org.gradle.api.tasks.InputFiles
 import org.gradle.api.tasks.Optional
 import org.gradle.api.tasks.OutputDirectory
 import org.gradle.api.tasks.SkipWhenEmpty
 import org.gradle.api.tasks.SourceSet
-import org.gradle.api.tasks.SourceTask
 import org.gradle.api.tasks.TaskAction
-import org.gradle.api.tasks.incremental.IncrementalTaskInputs
 import org.gradle.kotlin.dsl.getByType
 import org.gradle.kotlin.dsl.property
 import org.gradle.kotlin.dsl.setProperty
+import org.gradle.work.InputChanges
 import java.io.File
 import java.net.URLClassLoader
 import java.nio.file.Path
@@ -53,7 +52,7 @@ import javax.inject.Inject
 import kotlin.io.path.extension
 import kotlin.io.path.isDirectory
 import kotlin.io.path.nameWithoutExtension
-import kotlin.io.path.useLines
+import kotlin.io.path.relativeTo
 
 /**
  * Executes AssertJ generation against provided sources using the configured templates.
@@ -62,13 +61,19 @@ import kotlin.io.path.useLines
 open class AssertJGenerationTask @Inject internal constructor(
   objects: ObjectFactory,
   sourceSet: SourceSet,
-) : SourceTask() {
+) : DefaultTask() {
 
   @get:InputFiles
   @get:Classpath
   val generationClasspath: ConfigurableFileCollection = objects.fileCollection()
     .from(sourceSet.runtimeClasspath)
 
+  @get:Classpath
+  @get:InputFiles
+  @get:SkipWhenEmpty
+  @get:IgnoreEmptyDirectories
+  val classDirectories: SourceDirectorySet
+
   @OutputDirectory
   val outputDir: DirectoryProperty
 
@@ -95,14 +100,14 @@ open class AssertJGenerationTask @Inject internal constructor(
   init {
     description = "Generates AssertJ assertions for the  ${sourceSet.name} sources."
 
-    source(sourceSet.allJava)
     dependsOn(sourceSet.compileJavaTaskName)
 
     val assertJOptions = sourceSet.extensions.getByType<AssertJGeneratorExtension>()
 
     outputDir = assertJOptions.outputDir
     templateFiles = assertJOptions.templates.templateFiles
     generatorTemplates = assertJOptions.templates.generatorTemplates
+    classDirectories = assertJOptions.classDirectories
 
     skip.set(project.provider { assertJOptions.skip })
     hierarchical.set(project.provider { assertJOptions.hierarchical })
@@ -111,66 +116,36 @@ open class AssertJGenerationTask @Inject internal constructor(
   }
 
   @TaskAction
-  fun execute(inputs: IncrementalTaskInputs) {
-    if (skip.get()) {
+  fun execute(inputs: InputChanges) {
+    if (skip.getOrElse(false)) {
       return
     }
 
-    val sourceFiles = source.files
-
-    var classesToGenerate = mutableSetOf<File>()
-    var fullRegenRequired = false
-    inputs.outOfDate { change ->
-      if (generationClasspath.contains(change.file)) {
-        // file is part of classpath
-        fullRegenRequired = true
-      } else if (sourceFiles.contains(change.file)) {
-        // source file changed
-        classesToGenerate += change.file
-      } else if (templateFiles.contains(change.file)) {
-        fullRegenRequired = true
-      }
-    }
+    // We always regen every time
+    project.delete(outputDir)
 
-    inputs.removed { change ->
-      // TODO Handle deleted file
-//            def targetFile = project.file("$outputDir/${change.file.name}")
-//            if (targetFile.exists()) {
-//                targetFile.delete()
-//            }
-    }
+    val classLoader = URLClassLoader((generationClasspath + classDirectories).map { it.toURI().toURL() }.toTypedArray())
 
-    if (fullRegenRequired || !inputs.isIncremental) {
-      project.delete(outputDir.asFileTree.files)
-      classesToGenerate = sourceFiles
-    }
-
-    val classLoader = URLClassLoader(generationClasspath.map { it.toURI().toURL() }.toTypedArray())
-
-    val inputClassNames = getClassNames()
+    val allClassNames = getClassNames(classDirectories)
 
     @Suppress("SpreadOperator") // Java interop
-    val classes = ClassUtil.collectClasses(
+    val allClasses = ClassUtil.collectClasses(
       classLoader,
-      *inputClassNames.values.flatten().toTypedArray(),
+      *allClassNames.toTypedArray(),
     )
 
-    val classesByTypeName = classes.associateBy { it.type.typeName }
-
-    val inputClassesToFile = inputClassNames.asSequence()
-      .flatMap { (file, classDefs) ->
-        classDefs.map { classesByTypeName.getValue(it) to file }
-      }
-      .filter { (_, file) -> file in classesToGenerate }
-      .toMap()
+    val changedFiles = if (inputs.isIncremental) {
+      inputs.getFileChanges(classDirectories).asSequence().map { it.file }.filter { it.isFile }.toSet()
+    } else {
+      classDirectories.files
+    }
 
-    runGeneration(classes, inputClassNames, inputClassesToFile)
+    runGeneration(allClasses, changedFiles)
   }
 
   private fun runGeneration(
     allClasses: Set<TypeToken<*>>,
-    inputClassNames: Map<File, Set<String>>,
-    inputClassesToFile: Map<TypeToken<*>, File>
+    changedFiles: Set<File>,
   ) {
     val generator = BaseAssertionGenerator()
     val converter = ClassToClassDescriptionConverter()
@@ -180,7 +155,7 @@ open class AssertJGenerationTask @Inject internal constructor(
     val filteredClasses = removeAssertClasses(allClasses)
     val report = AssertionsGeneratorReport(
       directoryPathWhereAssertionFilesAreGenerated = absOutputDir,
-      inputClasses = inputClassNames.values.flatten(),
+      inputClasses = changedFiles.map { it.absolutePath },
       excludedClassesFromAssertionGeneration = allClasses - filteredClasses,
     )
 
@@ -195,19 +170,17 @@ open class AssertJGenerationTask @Inject internal constructor(
       val classDescriptions = if (hierarchical.get()) {
         generateHierarchical(converter, generator, report, filteredClasses)
       } else {
-        generateFlat(generator, converter, report, filteredClasses, inputClassesToFile)
-      }.toSet()
-
-      if (inputClassesToFile.isNotEmpty()) {
-        // only generate the entry points if there are classes that have changed (or exist..)
-        for (assertionsEntryPointType in entryPoints.get()) {
-          val assertionsEntryPointFile = generator.generateAssertionsEntryPointClassFor(
-            classDescriptions,
-            assertionsEntryPointType,
-            entryPointsClassPackage.orNull,
-          )
-          report.reportEntryPointGeneration(assertionsEntryPointType, assertionsEntryPointFile)
-        }
+        generateFlat(generator, converter, report, filteredClasses)
+      }
+
+      // only generate the entry points if there are classes that have changed (or exist..)
+      for (assertionsEntryPointType in entryPoints.get()) {
+        val assertionsEntryPointFile = generator.generateAssertionsEntryPointClassFor(
+          classDescriptions.toSet(),
+          assertionsEntryPointType,
+          entryPointsClassPackage.orNull,
+        )
+        report.reportEntryPointGeneration(assertionsEntryPointType, assertionsEntryPointFile)
       }
     } catch (@Suppress("TooGenericExceptionCaught") e: Exception) {
       report.exception = e
@@ -221,14 +194,14 @@ open class AssertJGenerationTask @Inject internal constructor(
     generator: BaseAssertionGenerator,
     report: AssertionsGeneratorReport,
     classes: Set<TypeToken<*>>,
-  ): Collection<ClassDescription> {
+  ): List<ClassDescription> {
     return classes.map { clazz ->
       val classDescription = converter.convertToClassDescription(clazz)
       val generatedCustomAssertionFiles = generator.generateHierarchicalCustomAssertionFor(
         classDescription,
         classes,
       )
-      report.addGeneratedAssertionFiles(generatedCustomAssertionFiles = generatedCustomAssertionFiles)
+      report.addGeneratedAssertionFiles(files = generatedCustomAssertionFiles)
       classDescription
     }
   }
@@ -238,42 +211,16 @@ open class AssertJGenerationTask @Inject internal constructor(
     converter: ClassToClassDescriptionConverter,
     report: AssertionsGeneratorReport,
     classes: Set<TypeToken<*>>,
-    inputClassesToFile: Map<TypeToken<*>, File>,
-  ): Collection<ClassDescription> {
+  ): List<ClassDescription> {
     return classes.map { clazz ->
       val classDescription = converter.convertToClassDescription(clazz)
 
-      if (clazz in inputClassesToFile) {
-        val generatedCustomAssertionFile = generator.generateCustomAssertionFor(classDescription)
-        report.addGeneratedAssertionFiles(generatedCustomAssertionFile)
-      }
+      val generatedCustomAssertionFile = generator.generateCustomAssertionFor(classDescription)
+      report.addGeneratedAssertionFiles(generatedCustomAssertionFile)
 
       classDescription
     }
   }
-
-  /**
-   * Returns the source for this task, after the include and exclude patterns have been applied. Ignores source files
-   * which do not exist.
-   *
-   * @return The source.
-   */
-  // This method is here as the Gradle DSL generation can't handle properties with setters and getters in different
-  // classes.
-  @InputFiles
-  @SkipWhenEmpty
-  override fun getSource(): FileTree = super.getSource()
-
-  private fun getClassNames(): Map<File, Set<String>> {
-    val fullyQualifiedNames = mutableMapOf<File, Set<String>>()
-
-    source.visit { fileVisitDetails: FileVisitDetails ->
-      val file = fileVisitDetails.file.toPath()
-      fullyQualifiedNames[fileVisitDetails.file] = getClassesInFile(file)
-    }
-
-    return fullyQualifiedNames.filterValues { it.isNotEmpty() }
-  }
 }
 
 private fun removeAssertClasses(classList: Set<TypeToken<*>>): Set<TypeToken<*>> {
@@ -287,30 +234,28 @@ private fun removeAssertClasses(classList: Set<TypeToken<*>>): Set<TypeToken<*>>
   return filteredClassList
 }
 
-private val PACKAGE_JAVA_PATH = Paths.get("package-info.java")
-
-private fun getClassesInFile(path: Path): Set<String> {
-  if (path.isDirectory()) return setOf()
+private fun getClassNames(source: SourceDirectorySet): Set<String> {
+  val srcDirs = source.sourceDirectories.map { it.toPath() }
 
-  // Ignore package-info.java, it's not supposed to be included.
-  if (path.fileName == PACKAGE_JAVA_PATH) return setOf()
+  val classFiles = source.asFileTree.filter { it.isFile && it.extension == "class" }
+  return classFiles.asSequence()
+    .map { it.toPath() }
+    .mapNotNull { getFullyQualifiedClassForFile(srcDirs, it) }
+    .toSet()
+}
 
-  val extension = path.extension
-  val fileNameWithoutExtension = path.fileName.nameWithoutExtension
+private val PACKAGE_INFO_PATH = Paths.get("package-info.class")
 
-  val (packageName, classNames) = when (extension) {
-    "java" -> {
-      path.useLines { lines ->
-        val packageLine = lines.first { it.startsWith("package ") }
+private fun getFullyQualifiedClassForFile(srcDirs: List<Path>, path: Path): String? {
+  if (path.isDirectory() || path.extension != "class") return null
 
-        val packageName = packageLine.removePrefix("package ").trimEnd(';')
-        val classNames = Sets.newHashSet(fileNameWithoutExtension)
-        Pair(packageName, classNames)
-      }
-    }
+  // Ignore package-info.java, it's not supposed to be included.
+  if (path.fileName == PACKAGE_INFO_PATH) return null
+  val className = path.nameWithoutExtension
 
-    else -> error("Unsupported extension: $extension")
-  }
+  val srcDir = srcDirs.single { path.startsWith(it) }
+  val relativePath = path.relativeTo(srcDir).parent.toString()
+    .replace(File.separatorChar, '.')
 
-  return classNames.asSequence().map { "$packageName.$it" }.toSet()
+  return "$relativePath.$className"
 }

src/main/kotlin/org/assertj/generator/gradle/tasks/config/AssertJGeneratorExtension.kt

@@ -16,6 +16,7 @@ import org.assertj.assertions.generator.AssertionsEntryPointType
 import org.gradle.api.Action
 import org.gradle.api.Project
 import org.gradle.api.file.DirectoryProperty
+import org.gradle.api.file.SourceDirectorySet
 import org.gradle.api.model.ObjectFactory
 import org.gradle.api.tasks.SourceSet
 import org.gradle.kotlin.dsl.newInstance
@@ -30,6 +31,9 @@ open class AssertJGeneratorExtension @Inject internal constructor(
   project: Project,
   sourceSet: SourceSet
 ) {
+  val classDirectories: SourceDirectorySet =
+    objects.sourceDirectorySet("assertJClasses", "Classes to generate AssertJ assertions from")
+
   /**
    * Generate generating Soft Assertions entry point class.
    * @return templates value, never {@code null}