Support multiple library directories in LibrariesTask

Refactored LibrariesTask to accept multiple input directories via ConfigurableFileCollection instead of a single DirectoryProperty.

Author: Stefterv

java/gradle/src/main/kotlin/LibrariesTask.kt

@@ -1,10 +1,9 @@
 package org.processing.java.gradle
 
 import org.gradle.api.DefaultTask
-import org.gradle.api.file.DirectoryProperty
+import org.gradle.api.file.ConfigurableFileCollection
 import org.gradle.api.file.RegularFileProperty
-import org.gradle.api.tasks.InputDirectory
-import org.gradle.api.tasks.Optional
+import org.gradle.api.tasks.InputFiles
 import org.gradle.api.tasks.OutputFile
 import org.gradle.api.tasks.TaskAction
 import java.io.File
@@ -17,19 +16,17 @@ This task stores the resulting information in a file that can be used later to r
  */
 abstract class LibrariesTask : DefaultTask() {
 
-    // TODO: Allow multiple directories
-    @InputDirectory
-    @Optional
-    val librariesDirectory: DirectoryProperty = project.objects.directoryProperty()
+    @InputFiles
+    val libraryDirectories: ConfigurableFileCollection = project.files()
 
     @OutputFile
     val librariesMetaData: RegularFileProperty = project.objects.fileProperty()
 
     init{
-        librariesMetaData.convention(project.layout.buildDirectory.file("processing/libraries"))
+        librariesMetaData.convention { project.gradle.gradleUserHomeDir.resolve("common/processing/libraries") }
     }
 
-    data class Jar(
+     data class Jar(
         val path: File,
         val classes: List<String>
     ) : java.io.Serializable
@@ -40,45 +37,45 @@ abstract class LibrariesTask : DefaultTask() {
 
     @TaskAction
     fun execute() {
-        if (!librariesDirectory.isPresent) {
-            logger.error("Libraries directory is not set. Libraries will not be imported.")
-            val meta = ObjectOutputStream(librariesMetaData.get().asFile.outputStream())
-            meta.writeObject(arrayListOf<Library>())
-            meta.close()
-            return
-        }
-        val libraries = librariesDirectory.get().asFile
-            .listFiles { file -> file.isDirectory }
-            ?.map { folder ->
-                // Find all the jars in the sketchbook
-                val jars = folder.resolve("library")
-                    .listFiles{ file -> file.extension == "jar" }
-                    ?.map{ file ->
+        val output = libraryDirectories.flatMap { librariesDirectory ->
+            if (!librariesDirectory.exists()) {
+                logger.error("Libraries directory (${librariesDirectory.path}) does not exist. Libraries will not be imported.")
+                return@flatMap emptyList()
+            }
+            val libraries = librariesDirectory
+                .listFiles { file -> file.isDirectory }
+                ?.map { folder ->
+                    // Find all the jars in the sketchbook
+                    val jars = folder.resolve("library")
+                        .listFiles{ file -> file.extension == "jar" }
+                        ?.map{ file ->
 
-                        // Inside each jar, look for the defined classes
-                        val jar = JarFile(file)
-                        val classes = jar.entries().asSequence()
-                            .filter { entry -> entry.name.endsWith(".class") }
-                            .map { entry -> entry.name }
-                            .map { it.substringBeforeLast('/').replace('/', '.') }
-                            .distinct()
-                            .toList()
+                            // Inside each jar, look for the defined classes
+                            val jar = JarFile(file)
+                            val classes = jar.entries().asSequence()
+                                .filter { entry -> entry.name.endsWith(".class") }
+                                .map { entry -> entry.name }
+                                .map { it.substringBeforeLast('/').replace('/', '.') }
+                                .distinct()
+                                .toList()
 
-                        // Return a reference to the jar and its classes
-                        return@map Jar(
-                            path = file,
-                            classes = classes
-                        )
-                    }?: emptyList()
+                            // Return a reference to the jar and its classes
+                            return@map Jar(
+                                path = file,
+                                classes = classes
+                            )
+                        }?: emptyList()
 
-                // Save the parsed jars and which folder
-                return@map Library(
-                    jars = jars
-                )
-            }?: emptyList()
+                    // Save the parsed jars and which folder
+                    return@map Library(
+                        jars = jars
+                    )
+                }?: emptyList()
 
+            return@flatMap libraries
+        }
         val meta = ObjectOutputStream(librariesMetaData.get().asFile.outputStream())
-        meta.writeObject(libraries)
+        meta.writeObject(output)
         meta.close()
     }
 }

java/gradle/src/main/kotlin/ProcessingPlugin.kt

@@ -13,7 +13,6 @@ import org.jetbrains.compose.ComposeExtension
 import org.jetbrains.compose.desktop.DesktopExtension
 import java.io.File
 import java.net.Socket
-import java.util.Properties
 import javax.inject.Inject
 
 class ProcessingPlugin @Inject constructor(private val objectFactory: ObjectFactory) : Plugin<Project> {
@@ -181,8 +180,7 @@ class ProcessingPlugin @Inject constructor(private val objectFactory: ObjectFact
             val librariesTaskName = sourceSet.getTaskName("scanLibraries", "PDE")
             val librariesScan = project.tasks.register(librariesTaskName, LibrariesTask::class.java) { task ->
                 task.description = "Scans the libraries in the sketchbook"
-                task.librariesDirectory.set(sketchbook?.let { File(it, "libraries") })
-                // TODO: Save the libraries metadata to settings folder to share between sketches
+                task.libraryDirectories.from(sketchbook?.let { File(it, "libraries") })
             }
 
             // Create a task to process the .pde files before compiling the java sources
@@ -198,9 +196,9 @@ class ProcessingPlugin @Inject constructor(private val objectFactory: ObjectFact
 
             val depsTaskName = sourceSet.getTaskName("addLegacyDependencies", "PDE")
             project.tasks.register(depsTaskName, DependenciesTask::class.java){ task ->
-                task.librariesMetaData
+                // Link the output of the libraries task to the dependencies task
+                task.librariesMetaData.set(librariesScan.get().librariesMetaData)
                 task.dependsOn(pdeTask, librariesScan)
-                // TODO: Save the libraries metadata to settings folder to share between sketches
             }
 
             // Make sure that the PDE tasks runs before the java compilation task