use custom gradle dependencies block to configure processor dependencies

Author: hauner

build.gradle.kts

@@ -95,7 +95,7 @@ gradlePlugin {
         create("processorPlugin") {
             id = "io.openapiprocessor.openapi-processor"
             displayName = "Gradle openapi-processor plugin"
-            description = "plugin to run openapi-processor-*, e.g. openapi-processor-spring (requires gradle 7.2+)"
+            description = "plugin to run openapi-processor-*, e.g. openapi-processor-spring (requires gradle 8.7+)"
             tags.set(listOf("openapi", "openapi-processor"))
             implementationClass = "io.openapiprocessor.gradle.OpenApiProcessorPlugin"
         }

src/main/kotlin/com/github/hauner/openapi/gradle/Processor.kt

@@ -5,8 +5,10 @@
 
 package com.github.hauner.openapi.gradle
 
+import org.gradle.api.model.ObjectFactory
+
 /**
  * backward compatibility, replaced by [io.openapiprocessor.gradle.ProcessorBase]
  */
 @Deprecated("backward compatibility.")
-class Processor(name: String): io.openapiprocessor.gradle.Processor(name)
+class Processor(name: String, objects: ObjectFactory): io.openapiprocessor.gradle.Processor(name, objects)

src/main/kotlin/io/openapiprocessor/gradle/OpenApiProcessorPlugin.kt

@@ -11,9 +11,11 @@ import io.openapiprocessor.gradle.version.GitHubVersionCheck
 import io.openapiprocessor.gradle.version.GitHubVersionProvider
 import io.openapiprocessor.gradle.version.VersionCheck
 import org.gradle.api.Action
+import org.gradle.api.NamedDomainObjectProvider
 import org.gradle.api.Plugin
 import org.gradle.api.Project
-import org.gradle.api.artifacts.Dependency
+import org.gradle.api.artifacts.ResolvableConfiguration
+import org.gradle.util.GradleVersion
 import java.io.File
 
 /**
@@ -36,7 +38,7 @@ class OpenApiProcessorPlugin: Plugin<Project> {
 
     private fun addOpenApiProcessorRepository (project: Project) {
         val snapshots = project.findProperty ("openapi-processor-gradle.snapshots")
-        if (snapshots == null || snapshots != "true") {
+        if ((snapshots == null) || (snapshots != "true")) {
             project.logger.debug("openapi-processor: snapshot repository disabled")
             return
         }
@@ -65,16 +67,31 @@ class OpenApiProcessorPlugin: Plugin<Project> {
     /**
      * Create a 'process{ProcessorName}' task for each configured processor.
      */
+    @Suppress("UnstableApiUsage")
     fun createProcessingTasks(project: Project, extension: OpenApiProcessorExtension) {
         extension.processors.configureEach(
             object : Action<Processor> {
                 override fun execute(processor: Processor) {
                     val name = "process${processor.name.replaceFirstChar { it.uppercase() }}"
 
+                    val scope = project.configurations.dependencyScope("${processor.name}Scope") {
+                        fromDependencyCollector(processor.dependencies.process)
+                    }
+
+                    project.dependencies.add(
+                        scope.name,
+                        "io.openapiprocessor:openapi-processor-api:${Versions.api}")
+
+                    val resolvable = project.configurations.resolvable("${processor.name}Classpath") {
+                            extendsFrom(scope.get())
+                            isCanBeResolved = true
+                            isCanBeConsumed = false
+                        }
+
                     project.tasks.register(
                         name,
                         OpenApiProcessorTask::class.java,
-                        createTaskBuilderAction(name, processor, extension)
+                        createTaskBuilderAction(processor, extension, resolvable)
                     )
                 }
             })
@@ -83,8 +100,12 @@ class OpenApiProcessorPlugin: Plugin<Project> {
     /**
      * Creates an Action that configures a 'process{ProcessorName}' task from its configuration.
      */
-    private fun createTaskBuilderAction(name: String, processor: Processor, extension: OpenApiProcessorExtension):
-        Action<OpenApiProcessorTask> {
+    @Suppress("UnstableApiUsage")
+    private fun createTaskBuilderAction(
+        processor: Processor,
+        extension: OpenApiProcessorExtension,
+        processorClasspath: NamedDomainObjectProvider<ResolvableConfiguration>
+    ): Action<OpenApiProcessorTask> {
 
         return object: Action<OpenApiProcessorTask> {
             // copy common api path to openapi-processor props if not set
@@ -121,32 +142,12 @@ class OpenApiProcessorPlugin: Plugin<Project> {
                 task.group = "openapi processor"
                 task.description = "process openapi with openapi-processor-${processor.name}"
 
-                copyApiPath (task)
+                copyApiPath(task)
                 task.getApiDir().set(project.layout.projectDirectory.dir(getInputDirectory()))
                 task.getTargetDir().set(project.layout.projectDirectory.dir(getOutputDirectory()))
                 processor.getMapping()?.let { task.getMapping().set(project.file(it)) }
 
-                val handler = project.dependencies
-                val dependencies = ArrayList<Dependency>()
-
-                if (processor.dependencies.isEmpty()) {
-                    task.logger.warn ("'${EXTENSION_NAME_DEFAULT}.${name}.processor' not set!")
-                }
-
-                dependencies.add (handler.create("io.openapiprocessor:openapi-processor-api:${Versions.api}"))
-
-                processor.dependencies.forEach {
-                    dependencies.add (handler.create (it))
-                }
-
-                val deps = dependencies.toTypedArray()
-                val cfg = project.configurations.detachedConfiguration(*deps)
-
-                cfg.isCanBeResolved = true
-                cfg.isCanBeConsumed = false
-                cfg.isTransitive = true
-                cfg.description = "the dependencies of the process${name.replaceFirstChar { it.uppercase() }} task."
-                task.getDependencies().from (cfg)
+                task.getDependencies().from(processorClasspath)
             }
         }
     }
@@ -157,11 +158,12 @@ class OpenApiProcessorPlugin: Plugin<Project> {
 
     companion object {
         private fun isSupportedGradleVersion(project: Project): Boolean {
-            val version: String = project.gradle.gradleVersion
+            val currentVersion = GradleVersion.current()
+            val minVersion = GradleVersion.version("8.7")
 
-            if (version < "7.0") {
-                project.logger.error ("the current gradle version is $version")
-                project.logger.error ("openapi-processor-gradle requires gradle 7.0+")
+            if (currentVersion < minVersion) {
+                project.logger.error ("the current gradle version is $currentVersion")
+                project.logger.error ("openapi-processor-gradle requires gradle $minVersion+")
                 return false
             }
 

src/main/kotlin/io/openapiprocessor/gradle/Processor.kt

@@ -6,32 +6,49 @@
 package io.openapiprocessor.gradle
 
 import groovy.lang.GString
+import org.gradle.api.Action
+import org.gradle.api.artifacts.Dependency
+import org.gradle.api.artifacts.dsl.DependencyCollector
 import org.gradle.api.file.Directory
+import org.gradle.api.file.FileCollection
 import org.gradle.api.file.RegularFile
+import org.gradle.api.model.ObjectFactory
 import org.gradle.api.provider.Provider
+import org.gradle.api.tasks.Nested
+import java.io.File
 import javax.inject.Inject
 
 /**
  * represents an openapi-processor configured in [OpenApiProcessorExtension]
  */
 
-open class Processor @Inject constructor(configName: String): ProcessorBase() {
+open class Processor @Inject constructor(configName: String, val objects: ObjectFactory): ProcessorBase() {
 
     companion object {
         const val API_PATH = "apiPath"
         const val TARGET_DIR = "targetDir"
     }
 
+    interface ProcessorDependencies {
+        val process: DependencyCollector
+    }
+
     var name: String
     val config: String
     val other: MutableMap<String, Any> = mutableMapOf()
-    val dependencies: MutableCollection<Any> = mutableListOf()
 
     init {
         name = configName
         config = configName
     }
 
+    @get:Nested
+    val dependencies: ProcessorDependencies = objects.newInstance(ProcessorDependencies::class.java)
+
+    fun dependencies(action: Action<in ProcessorDependencies>) {
+        action.execute(dependencies)
+    }
+
     fun processorName(processorName: String) {
         this.name = processorName
     }
@@ -40,8 +57,17 @@ open class Processor @Inject constructor(configName: String): ProcessorBase() {
         this.name = processorName.toString()
     }
 
+    //@Deprecated("use dependencies { process(dependency) } instead")
     fun processor(dependency: Any) {
-        dependencies.add(dependency)
+        @Suppress("UNCHECKED_CAST")
+        when (dependency) {
+            is CharSequence -> dependencies.process.add(dependency)
+            is File -> dependencies.process.add(objects.fileCollection().from(dependency))
+            is FileCollection -> dependencies.process.add(dependency)
+            is Dependency -> dependencies.process.add(dependency)
+            is Provider<*> -> dependencies.process.add(dependency as Provider<out Dependency>)
+            else -> dependencies.process.add(dependency.toString())
+        }
     }
 
     fun getTargetDir(): String {
@@ -77,7 +103,7 @@ open class Processor @Inject constructor(configName: String): ProcessorBase() {
     }
 
     /**
-     * allow to assign targetDir like
+     * allow assigning targetDir like
      *
      * {@code targetDir = layout.buildDirectory.dir("openapi")}
      *

src/test/groovy/io/openapiprocessor/gradle/OpenApiProcessorExtensionSpec.groovy

@@ -6,6 +6,7 @@
 package io.openapiprocessor.gradle
 
 import org.gradle.api.Project
+import org.gradle.api.artifacts.FileCollectionDependency
 import org.gradle.testfixtures.ProjectBuilder
 import spock.lang.Specification
 
@@ -50,21 +51,32 @@ class OpenApiProcessorExtensionSpec extends Specification {
     void "creates processor from string" () {
         when:
         ex.process("test", {
-            processor("/a processor")
+            processor("io.openapiprocessor:processor:1.0.0")
         })
 
         then:
-        ex.processors.getByName("test").dependencies.first() == "/a processor"
+        def processor = ex.processors.getByName("test")
+        def dependencies = processor.dependencies.process.dependencies.get()
+            .collect {
+                return "${it.group}:${it.name}:${it.version}" as String
+            }
+
+        dependencies.first() == "io.openapiprocessor:processor:1.0.0"
     }
 
     void "creates processor from file" () {
         when:
         ex.process("test") {
-            processor(project.file("processor"))
+            processor(project.file("processor.jar"))
         }
 
         then:
-        ex.processors.getByName("test").dependencies.first().name == "processor"
+        def processor = ex.processors.getByName("test")
+        def dependencies = processor.dependencies.process.dependencies.get()
+            .collect {(it as FileCollectionDependency).files.files }
+            .flatten() as List<File>
+
+        dependencies.first().name.endsWith("processor.jar")
     }
 
     void "converts processor properties to map via process()/prop() methods" () {
@@ -118,4 +130,20 @@ class OpenApiProcessorExtensionSpec extends Specification {
         then:
         ex.api.get().asFile == project.file("src/api/openapi.yaml")
     }
+
+    void "add processor specific dependency"() {
+        when:
+        ex.process ("test") {
+            dependencies {
+                process("com.google.googlejavaformat:google-java-format:1.24.0")
+            }
+        }
+
+        then:
+        def config = project.configurations.getByName("testScope")
+        def dependencies = config.dependencies.collect { "${it.group}:${it.name}:${it.version}" as String }
+
+        dependencies.contains("io.openapiprocessor:openapi-processor-api:${Versions.api}" as String)
+        dependencies.contains("com.google.googlejavaformat:google-java-format:1.24.0")
+    }
 }

src/test/groovy/io/openapiprocessor/gradle/ProcessorSpec.groovy

@@ -5,14 +5,17 @@
 
 package io.openapiprocessor.gradle
 
+import org.gradle.api.Project
 import org.gradle.testfixtures.ProjectBuilder
 import spock.lang.Specification
 
 @SuppressWarnings('ConfigurationAvoidance')
 class ProcessorSpec extends Specification {
 
+    Project project = ProjectBuilder.builder().build()
+
     void "gets & sets named props" () {
-        def processor = new Processor('test')
+        def processor = new Processor('test', project.objects)
 
         when:
         processor."${prop}" (value)
@@ -27,7 +30,7 @@ class ProcessorSpec extends Specification {
     }
 
     void "maps unknown properties via methodMissing" () {
-        def processor = new Processor('test')
+        def processor = new Processor('test', project.objects)
 
         when:
         processor.unknown ('foo')
@@ -37,7 +40,7 @@ class ProcessorSpec extends Specification {
     }
 
     void "maps nested properties via methodMissing" () {
-        def processor = new Processor('test')
+        def processor = new Processor('test', project.objects)
 
         when:
         processor.test {
@@ -57,7 +60,7 @@ class ProcessorSpec extends Specification {
     }
 
     void "maps unknown properties via prop()" () {
-        def processor = new Processor('test')
+        def processor = new Processor('test', project.objects)
 
         when:
         processor.prop ('foo', "any")
@@ -69,7 +72,7 @@ class ProcessorSpec extends Specification {
     }
 
     void "maps nested properties via prop()" () {
-        def processor = new Processor('test')
+        def processor = new Processor('test', project.objects)
 
         when:
         processor.prop("test", [
@@ -89,7 +92,6 @@ class ProcessorSpec extends Specification {
     }
 
     void "accept targetDir when given as Directory" () {
-        def project = ProjectBuilder.builder().build()
         project.pluginManager.apply(OpenApiProcessorPlugin)
 
         when:
@@ -107,7 +109,6 @@ class ProcessorSpec extends Specification {
     }
 
     void "accept targetDir when given as Provider<Directory>" () {
-        def project = ProjectBuilder.builder().build()
         project.pluginManager.apply(OpenApiProcessorPlugin)
 
         when:
@@ -125,7 +126,6 @@ class ProcessorSpec extends Specification {
     }
 
     void "accept targetDir assignment with Provider<Directory>" () {
-        def project = ProjectBuilder.builder().build()
         project.pluginManager.apply(OpenApiProcessorPlugin)
 
         when:
@@ -143,7 +143,6 @@ class ProcessorSpec extends Specification {
     }
 
     void "accept mapping property when given as RegularFile" () {
-        def project = ProjectBuilder.builder().build()
         project.pluginManager.apply(OpenApiProcessorPlugin)
 
         when:

src/testInt/groovy/io/openapiprocessor/gradle/GroovyDslSpec.groovy

@@ -47,21 +47,6 @@ class GroovyDslSpec extends PluginSpec {
         ['--stacktrace', 'processV1']
     }
 
-    @Unroll
-    void "test groovy (method) dsl with with gradle 7 (#gradleVersion)" () {
-        when:
-        def result = build(gradleVersion)
-
-        then:
-        result.task(':processV1').outcome == SUCCESS
-        result.output.contains("processor v1 did run !")
-
-        where:
-        gradleVersion << Gradle.VERSIONS_7
-                .findAll { it.groovy }
-                .collect { it.version }
-    }
-
     @Unroll
     void "test groovy (method) dsl with with gradle 8 (#gradleVersion)" () {
         when: