fix: Configuration Cache Support

Author: wba2hi

vss-processor-plugin/src/main/java/org/eclipse/velocitas/vssprocessor/VssModelGenerator.kt

@@ -22,23 +22,28 @@ import org.eclipse.kuksa.vsscore.model.parentClassName
 import org.eclipse.velocitas.vssprocessor.parser.factory.VssParserFactory
 import org.eclipse.velocitas.vssprocessor.spec.VssNodeSpecModel
 import org.eclipse.velocitas.vssprocessor.spec.VssPath
-import org.gradle.api.Project
 import org.gradle.api.logging.Logger
 
 /**
  * Generates a [org.eclipse.kuksa.vsscore.model.VssNode] for every entry listed in the input file.
  * These nodes are a usable kotlin data class reflection of the element.
  *
+ * @param projectDir absolute path to the project which has embedded the vss-processor-plugin.
  * @param logger to log output with
  */
 class VssModelGenerator(
-    val project: Project,
-    val logger: Logger,
+    projectDir: File,
+    private val logger: Logger,
 ) {
     private val vssParserFactory = VssParserFactory()
 
-    val sourceSetBasePath = "build" + fileSeparator + "generated" + fileSeparator + "vss" + fileSeparator + "kotlin"
-    val outputPath = sourceSetBasePath + fileSeparator + PACKAGE_NAME.replace(".", fileSeparator)
+    private val packageName = "org.eclipse.velocitas.vss"
+
+    private val buildDir = File(projectDir, "build")
+    private val generatedDir = File(buildDir, "generated")
+    private val vssDir = File(generatedDir, "vss")
+    val sourceSetBaseDir = File(vssDir, "kotlin")
+    val outputDir = File(sourceSetBaseDir, packageName.replace(".", File.separator))
 
     fun generate(vssFiles: Set<File>) {
         val simpleNodeElements = mutableListOf<VssNodeSpecModel>()
@@ -75,27 +80,25 @@ class VssModelGenerator(
 
             specModel.logger = logger
             val classSpec = specModel.createClassSpec(
-                PACKAGE_NAME,
+                packageName,
                 vssPathToVssNode.values,
                 duplicateNodeNames,
             )
 
             val className = classSpec.name ?: throw NoSuchFieldException("Class spec $classSpec has no name field!")
-            val fileSpecBuilder = FileSpec.builder(PACKAGE_NAME, className)
+            val fileSpecBuilder = FileSpec.builder(packageName, className)
 
             val parentImport = buildParentImport(specModel, generatedFilesVssPathToClassName)
             if (parentImport.isNotEmpty()) {
-                fileSpecBuilder.addImport(PACKAGE_NAME, parentImport)
+                fileSpecBuilder.addImport(packageName, parentImport)
             }
 
             val file = fileSpecBuilder
                 .addType(classSpec)
                 .build()
 
-            val sourcePath = sourceSetBasePath + fileSeparator + PACKAGE_NAME.replace(".", fileSeparator)
-            val sourceDir = project.file(sourcePath)
-            sourceDir.mkdirs()
-            sourceDir.resolve(file.name + ".kt").writeText(file.toString())
+            outputDir.mkdirs()
+            outputDir.resolve(file.name + ".kt").writeText(file.toString())
 
             generatedFilesVssPathToClassName[vssPath.path] = className
         }
@@ -133,9 +136,4 @@ class VssModelGenerator(
             parentClassName // Main class = File name
         }
     }
-
-    private companion object {
-        private val fileSeparator = File.separator
-        private const val PACKAGE_NAME = "org.eclipse.velocitas.vss"
-    }
 }

vss-processor-plugin/src/main/java/org/eclipse/velocitas/vssprocessor/plugin/VssProcessorPlugin.kt

@@ -36,6 +36,7 @@ import org.gradle.api.provider.Property
 import org.gradle.api.tasks.CacheableTask
 import org.gradle.api.tasks.IgnoreEmptyDirectories
 import org.gradle.api.tasks.InputDirectory
+import org.gradle.api.tasks.Internal
 import org.gradle.api.tasks.OutputDirectory
 import org.gradle.api.tasks.PathSensitive
 import org.gradle.api.tasks.PathSensitivity
@@ -59,8 +60,6 @@ internal constructor(objectFactory: ObjectFactory) {
     val searchPath: Property<String> = objectFactory.property(String::class.java).convention("")
 }
 
-private val fileSeparator = File.separator
-
 /**
  * This Plugin searches for compatible VSS files, generates VSS Model classes and copies them into an output folder
  * which is added as a main sourceSet.
@@ -72,19 +71,18 @@ class VssProcessorPlugin : Plugin<Project> {
 
         // The extension variables are only available after the project has been evaluated
         project.afterEvaluate {
-            val vssModelGenerator = VssModelGenerator(project, logger)
-            val sourceSetBasePath = vssModelGenerator.sourceSetBasePath
+            val modelGenerator = VssModelGenerator(project.projectDir, logger)
+            val sourceSetBaseDir = modelGenerator.sourceSetBaseDir
 
-            addGeneratedPathToSourceSets(project, sourceSetBasePath)
+            addGeneratedPathToSourceSets(project, sourceSetBaseDir)
 
             val generateVssModelsTask = project.tasks.register<GenerateVssModelsTask>(GENERATE_TASK_NAME) {
-                val defaultVssPath = "${rootDir}${fileSeparator}$VSS_FOLDER_NAME"
-                val vssPath = vssProcessorExtension.searchPath.get().ifEmpty { defaultVssPath }
-                val vssDir = File(vssPath)
-                inputDir.set(vssDir)
+                vssModelGenerator = modelGenerator
+
+                val vssDir = readVssDir(vssProcessorExtension)
+                this.vssDir.set(vssDir)
 
-                val genOutputDir = File(vssModelGenerator.outputPath)
-                outputDir.set(genOutputDir)
+                generatedOutputDir.set(sourceSetBaseDir)
             }
 
             tasks.withType(KotlinCompile::class.java).configureEach {
@@ -99,9 +97,16 @@ class VssProcessorPlugin : Plugin<Project> {
         }
     }
 
+    private fun Project.readVssDir(vssProcessorExtension: VssProcessorPluginExtension): File {
+        val defaultVssPath = File(rootDir, VSS_FOLDER_NAME)
+        val vssPath = vssProcessorExtension.searchPath.get().ifEmpty { defaultVssPath.absolutePath }
+        val vssDir = File(vssPath)
+        return vssDir
+    }
+
     private fun addGeneratedPathToSourceSets(
         project: Project,
-        sourceSetBasePath: String,
+        sourceSetBaseDir: File,
     ) {
         val extensions = project.extensions
         val pluginManager = project.pluginManager
@@ -113,15 +118,15 @@ class VssProcessorPlugin : Plugin<Project> {
         if (isAndroidApplication) {
             val androidExtension = extensions.getByType(AppExtension::class.java)
             val mainSourceSet = androidExtension.sourceSets.named(SOURCESET_MAIN_NAME).get()
-            mainSourceSet.java.srcDirs(sourceSetBasePath)
+            mainSourceSet.java.srcDirs(sourceSetBaseDir)
         } else if (isAndroidLibrary) {
             val androidExtension = extensions.getByType(LibraryExtension::class.java)
             val mainSourceSet = androidExtension.sourceSets.named(SOURCESET_MAIN_NAME).get()
-            mainSourceSet.java.srcDirs(sourceSetBasePath)
+            mainSourceSet.java.srcDirs(sourceSetBaseDir)
         } else if (isJavaProject) {
             val sourceSets = extensions.getByType(SourceSetContainer::class.java)
             val mainSourceSet = sourceSets.named(SOURCESET_MAIN_NAME).get()
-            mainSourceSet.java.srcDirs(sourceSetBasePath)
+            mainSourceSet.java.srcDirs(sourceSetBaseDir)
         } else {
             throw GradleException("Project does not contain any supported plugin")
         }
@@ -142,27 +147,26 @@ class VssProcessorPlugin : Plugin<Project> {
 }
 
 /**
- * This task takes an input directory [inputDir] which should contain all available VSS files and an
- * output directory [outputDir] where all files are copied to so the VSSProcessor can work with them.
+ * This task takes an input directory [vssDir] which should contain all available VSS files and an
+ * output directory [generatedOutputDir] where all files are copied to so the VSSProcessor can work with them.
  */
 @CacheableTask
 private abstract class GenerateVssModelsTask : DefaultTask() {
     @get:Incremental
     @get:IgnoreEmptyDirectories
     @get:PathSensitive(PathSensitivity.NAME_ONLY)
     @get:InputDirectory
-    abstract val inputDir: DirectoryProperty
+    abstract val vssDir: DirectoryProperty
 
     @get:OutputDirectory
-    abstract val outputDir: DirectoryProperty
+    abstract val generatedOutputDir: DirectoryProperty
 
-    private val vssModelGenerator by lazy {
-        VssModelGenerator(project, logger)
-    }
+    @Internal
+    lateinit var vssModelGenerator: VssModelGenerator
 
     @TaskAction
     fun provideFile(inputChanges: InputChanges) {
-        inputChanges.getFileChanges(inputDir).forEach { change ->
+        inputChanges.getFileChanges(vssDir).forEach { change ->
             if (change.fileType == FileType.DIRECTORY) return@forEach
 
             val file = change.file
@@ -172,18 +176,18 @@ private abstract class GenerateVssModelsTask : DefaultTask() {
                 return@forEach
             }
 
-            val targetFile = outputDir.file(change.normalizedPath).get().asFile
+            val targetFile = generatedOutputDir.file(change.normalizedPath).get().asFile
             logger.info("Found VSS file changes for: ${targetFile.name}, change: ${change.changeType}")
 
             when (change.changeType) {
                 ChangeType.ADDED,
                 ChangeType.MODIFIED,
                 -> {
-                    val outputDir = outputDir.asFile.get()
+                    val outputDir = generatedOutputDir.asFile.get()
                     outputDir.deleteRecursively()
                     outputDir.mkdirs()
 
-                    val vssFiles = inputDir.asFile.get()
+                    val vssFiles = vssDir.asFile.get()
                         .walk()
                         .filter { it.isFile }
                         .filter { validVssExtension.contains(it.extension) }
@@ -196,7 +200,7 @@ private abstract class GenerateVssModelsTask : DefaultTask() {
                     vssModelGenerator.generate(vssFiles)
                 }
 
-                ChangeType.REMOVED -> outputDir.asFile.get().deleteRecursively()
+                ChangeType.REMOVED -> generatedOutputDir.asFile.get().deleteRecursively()
                 else -> logger.warn("Could not determine file change type: ${change.changeType}")
             }
         }