Support Gradle 7.4 configuration caching

.github/workflows/build.yml

@@ -6,9 +6,9 @@ jobs:
     strategy:
       matrix:
         config:
-          - {os: ubuntu-latest, params: "-PtestAllSupportedGradleVersions=true -PtestProxyIntegrationTests=false" }
-          - {os: windows-latest, params: "-PtestProxyIntegrationTests=false" }
-          - {os: macos-latest, params: "-PtestProxyIntegrationTests=false" }
+          - {os: ubuntu-latest, params: "-PtestAllSupportedGradleVersions=true" }
+          - {os: windows-latest, params: "" }
+          - {os: macos-latest, params: "" }
     steps:
       - name: Checkout Source Code
         uses: actions/checkout@v2

build.gradle.kts

@@ -74,7 +74,6 @@ tasks.test {
     )
     systemProperty("testMinimumCurrentGradleVersion", project.properties["testMinimumCurrentGradleVersion"] ?: "false")
     systemProperty("testCurrentGradleVersion", project.properties["testCurrentGradleVersion"] ?: "true")
-    systemProperty("testProxyIntegrationTests", project.properties["testProxyIntegrationTests"] ?: "true")
 
     val processorsCount = Runtime.getRuntime().availableProcessors()
     maxParallelForks = if (processorsCount > 2) processorsCount.div(2) else processorsCount

src/main/kotlin/com/github/gradle/node/NodePlugin.kt

@@ -107,13 +107,12 @@ class NodePlugin : Plugin<Project> {
     }
 
     private fun configureNodeSetupTask(nodeExtension: NodeExtension) {
-        val variantComputer = VariantComputer()
-        val nodeArchiveDependencyProvider = variantComputer.computeNodeArchiveDependency(nodeExtension)
-        val archiveFileProvider = nodeArchiveDependencyProvider
-                .map { nodeArchiveDependency ->
-                    resolveNodeArchiveFile(nodeArchiveDependency)
-                }
         project.tasks.named<NodeSetupTask>(NodeSetupTask.NAME) {
+            val nodeArchiveDependencyProvider = variantComputer.computeNodeArchiveDependency(nodeExtension)
+            val archiveFileProvider = nodeArchiveDependencyProvider
+                    .map { nodeArchiveDependency ->
+                        resolveNodeArchiveFile(nodeArchiveDependency)
+                    }
             nodeArchiveFile.set(project.layout.file(archiveFileProvider))
         }
     }

src/main/kotlin/com/github/gradle/node/exec/NodeExecRunner.kt

@@ -10,9 +10,8 @@ import org.gradle.api.provider.Provider
 /**
  * This function is responsible for setting up the configuration used when running the tasks.
  */
-fun buildExecConfiguration(nodeExtension: NodeExtension, nodeExecConfiguration: NodeExecConfiguration):
+fun buildExecConfiguration(nodeExtension: NodeExtension, nodeExecConfiguration: NodeExecConfiguration, variantComputer: VariantComputer):
         Provider<ExecConfiguration> {
-    val variantComputer = VariantComputer()
     val nodeDirProvider = variantComputer.computeNodeDir(nodeExtension)
     val nodeBinDirProvider = variantComputer.computeNodeBinDir(nodeDirProvider)
     val executableProvider = variantComputer.computeNodeExec(nodeExtension, nodeBinDirProvider)
@@ -34,8 +33,8 @@ fun computeAdditionalBinPath(nodeExtension: NodeExtension, nodeBinDirProvider: P
 }
 
 class NodeExecRunner {
-    fun execute(project: ProjectApiHelper, extension: NodeExtension, nodeExecConfiguration: NodeExecConfiguration) {
-        val execConfiguration = buildExecConfiguration(extension, nodeExecConfiguration).get()
+    fun execute(project: ProjectApiHelper, extension: NodeExtension, nodeExecConfiguration: NodeExecConfiguration, variantComputer: VariantComputer) {
+        val execConfiguration = buildExecConfiguration(extension, nodeExecConfiguration, variantComputer).get()
         val execRunner = ExecRunner()
         execRunner.execute(project, extension, execConfiguration)
     }

src/main/kotlin/com/github/gradle/node/npm/exec/NpmExecRunner.kt

@@ -18,13 +18,12 @@ abstract class NpmExecRunner {
     @get:Inject
     abstract val providers: ProviderFactory
 
-    private val variantComputer = VariantComputer()
-
-    fun executeNpmCommand(project: ProjectApiHelper, extension: NodeExtension, nodeExecConfiguration: NodeExecConfiguration) {
+    fun executeNpmCommand(project: ProjectApiHelper, extension: NodeExtension, nodeExecConfiguration: NodeExecConfiguration, variants: VariantComputer) {
         val npmExecConfiguration = NpmExecConfiguration("npm"
         ) { variantComputer, nodeExtension, npmBinDir -> variantComputer.computeNpmExec(nodeExtension, npmBinDir) }
         executeCommand(project, extension, addProxyEnvironmentVariables(extension, nodeExecConfiguration),
-                npmExecConfiguration)
+                npmExecConfiguration,
+            variants)
     }
 
     private fun addProxyEnvironmentVariables(nodeExtension: NodeExtension,
@@ -40,25 +39,27 @@ abstract class NpmExecRunner {
         return nodeExecConfiguration
     }
 
-    fun executeNpxCommand(project: ProjectApiHelper, extension: NodeExtension, nodeExecConfiguration: NodeExecConfiguration) {
+    fun executeNpxCommand(project: ProjectApiHelper, extension: NodeExtension, nodeExecConfiguration: NodeExecConfiguration, variants: VariantComputer) {
         val npxExecConfiguration = NpmExecConfiguration("npx") { variantComputer, nodeExtension, npmBinDir ->
             variantComputer.computeNpxExec(nodeExtension, npmBinDir)
         }
-        executeCommand(project, extension, nodeExecConfiguration, npxExecConfiguration)
+        executeCommand(project, extension, nodeExecConfiguration, npxExecConfiguration, variants)
     }
 
     private fun executeCommand(project: ProjectApiHelper, extension: NodeExtension, nodeExecConfiguration: NodeExecConfiguration,
-                               npmExecConfiguration: NpmExecConfiguration) {
+                               npmExecConfiguration: NpmExecConfiguration,
+                               variantComputer: VariantComputer) {
         val execConfiguration =
-                computeExecConfiguration(extension, npmExecConfiguration, nodeExecConfiguration).get()
+                computeExecConfiguration(extension, npmExecConfiguration, nodeExecConfiguration, variantComputer).get()
         val execRunner = ExecRunner()
         execRunner.execute(project, extension, execConfiguration)
     }
 
-    private fun computeExecConfiguration(extension: NodeExtension,  npmExecConfiguration: NpmExecConfiguration,
-                                         nodeExecConfiguration: NodeExecConfiguration): Provider<ExecConfiguration> {
-        val additionalBinPathProvider = computeAdditionalBinPath(extension)
-        val executableAndScriptProvider = computeExecutable(extension, npmExecConfiguration)
+    private fun computeExecConfiguration(extension: NodeExtension, npmExecConfiguration: NpmExecConfiguration,
+                                         nodeExecConfiguration: NodeExecConfiguration,
+                                         variantComputer: VariantComputer): Provider<ExecConfiguration> {
+        val additionalBinPathProvider = computeAdditionalBinPath(extension, variantComputer)
+        val executableAndScriptProvider = computeExecutable(extension, npmExecConfiguration, variantComputer)
         return zip(additionalBinPathProvider, executableAndScriptProvider)
                 .map { (additionalBinPath, executableAndScript) ->
                     val argsPrefix =
@@ -70,7 +71,7 @@ abstract class NpmExecRunner {
                 }
     }
 
-    private fun computeExecutable(nodeExtension: NodeExtension, npmExecConfiguration: NpmExecConfiguration):
+    private fun computeExecutable(nodeExtension: NodeExtension, npmExecConfiguration: NpmExecConfiguration, variantComputer: VariantComputer):
             Provider<ExecutableAndScript> {
         val nodeDirProvider = variantComputer.computeNodeDir(nodeExtension)
         val npmDirProvider = variantComputer.computeNpmDir(nodeExtension, nodeDirProvider)
@@ -103,7 +104,7 @@ abstract class NpmExecRunner {
             val script: String? = null
     )
 
-    private fun computeAdditionalBinPath(nodeExtension: NodeExtension): Provider<List<String>> {
+    private fun computeAdditionalBinPath(nodeExtension: NodeExtension, variantComputer: VariantComputer): Provider<List<String>> {
         return nodeExtension.download.flatMap { download ->
             if (!download) {
                 providers.provider { listOf<String>() }

src/main/kotlin/com/github/gradle/node/npm/task/NpmSetupTask.kt

@@ -4,10 +4,9 @@ import com.github.gradle.node.NodeExtension
 import com.github.gradle.node.NodePlugin
 import com.github.gradle.node.exec.NodeExecConfiguration
 import com.github.gradle.node.npm.exec.NpmExecRunner
+import com.github.gradle.node.task.BaseTask
 import com.github.gradle.node.task.NodeSetupTask
 import com.github.gradle.node.util.ProjectApiHelper
-import com.github.gradle.node.variant.VariantComputer
-import org.gradle.api.DefaultTask
 import org.gradle.api.model.ObjectFactory
 import org.gradle.api.provider.Provider
 import org.gradle.api.provider.ProviderFactory
@@ -22,7 +21,7 @@ import javax.inject.Inject
 /**
  * npm install that only gets executed if gradle decides so.
  */
-abstract class NpmSetupTask : DefaultTask() {
+abstract class NpmSetupTask : BaseTask() {
 
     @get:Inject
     abstract val objects: ObjectFactory
@@ -44,7 +43,6 @@ abstract class NpmSetupTask : DefaultTask() {
 
     @get:OutputDirectory
     val npmDir by lazy {
-        val variantComputer = VariantComputer()
         val nodeDir = variantComputer.computeNodeDir(nodeExtension)
         variantComputer.computeNpmDir(nodeExtension, nodeDir)
     }
@@ -73,7 +71,7 @@ abstract class NpmSetupTask : DefaultTask() {
         val command = computeCommand()
         val nodeExecConfiguration = NodeExecConfiguration(command)
         val npmExecRunner = objects.newInstance(NpmExecRunner::class.java)
-        npmExecRunner.executeNpmCommand(projectHelper, nodeExtension, nodeExecConfiguration)
+        npmExecRunner.executeNpmCommand(projectHelper, nodeExtension, nodeExecConfiguration, variantComputer)
     }
 
     protected open fun computeCommand(): List<String> {

src/main/kotlin/com/github/gradle/node/npm/task/NpmTask.kt

@@ -4,9 +4,9 @@ import com.github.gradle.node.NodeExtension
 import com.github.gradle.node.NodePlugin
 import com.github.gradle.node.exec.NodeExecConfiguration
 import com.github.gradle.node.npm.exec.NpmExecRunner
+import com.github.gradle.node.task.BaseTask
 import com.github.gradle.node.util.ProjectApiHelper
 import org.gradle.api.Action
-import org.gradle.api.DefaultTask
 import org.gradle.api.model.ObjectFactory
 import org.gradle.api.provider.ProviderFactory
 import org.gradle.api.tasks.Input
@@ -19,7 +19,7 @@ import org.gradle.kotlin.dsl.property
 import org.gradle.process.ExecSpec
 import javax.inject.Inject
 
-abstract class NpmTask : DefaultTask() {
+abstract class NpmTask : BaseTask() {
     @get:Inject
     abstract val objects: ObjectFactory
 
@@ -70,6 +70,6 @@ abstract class NpmTask : DefaultTask() {
                 NodeExecConfiguration(command, environment.get(), workingDir.asFile.orNull, ignoreExitValue.get(),
                         execOverrides.orNull)
         val npmExecRunner = objects.newInstance(NpmExecRunner::class.java)
-        npmExecRunner.executeNpmCommand(projectHelper, nodeExtension, nodeExecConfiguration)
+        npmExecRunner.executeNpmCommand(projectHelper, nodeExtension, nodeExecConfiguration, variantComputer)
     }
 }

src/main/kotlin/com/github/gradle/node/npm/task/NpxTask.kt

@@ -4,9 +4,9 @@ import com.github.gradle.node.NodeExtension
 import com.github.gradle.node.NodePlugin
 import com.github.gradle.node.exec.NodeExecConfiguration
 import com.github.gradle.node.npm.exec.NpmExecRunner
+import com.github.gradle.node.task.BaseTask
 import com.github.gradle.node.util.ProjectApiHelper
 import org.gradle.api.Action
-import org.gradle.api.DefaultTask
 import org.gradle.api.model.ObjectFactory
 import org.gradle.api.provider.ProviderFactory
 import org.gradle.api.tasks.Input
@@ -18,7 +18,7 @@ import org.gradle.kotlin.dsl.property
 import org.gradle.process.ExecSpec
 import javax.inject.Inject
 
-abstract class NpxTask : DefaultTask() {
+abstract class NpxTask : BaseTask() {
 
     @get:Inject
     abstract val objects: ObjectFactory
@@ -70,6 +70,6 @@ abstract class NpxTask : DefaultTask() {
                 NodeExecConfiguration(fullCommand, environment.get(), workingDir.asFile.orNull,
                         ignoreExitValue.get(), execOverrides.orNull)
         val npmExecRunner = objects.newInstance(NpmExecRunner::class.java)
-        npmExecRunner.executeNpxCommand(projectHelper, extension, nodeExecConfiguration)
+        npmExecRunner.executeNpxCommand(projectHelper, extension, nodeExecConfiguration, variantComputer)
     }
 }

src/main/kotlin/com/github/gradle/node/task/BaseTask.kt

@@ -0,0 +1,18 @@
+package com.github.gradle.node.task
+
+import com.github.gradle.node.util.PlatformHelper
+import com.github.gradle.node.variant.VariantComputer
+import org.gradle.api.DefaultTask
+import org.gradle.api.tasks.Internal
+
+abstract class BaseTask : DefaultTask() {
+
+    @get:Internal
+    var platformHelper = PlatformHelper.INSTANCE
+
+    @get:Internal
+    internal val variantComputer by lazy {
+        VariantComputer(platformHelper)
+    }
+
+}

src/main/kotlin/com/github/gradle/node/task/NodeSetupTask.kt

@@ -2,10 +2,8 @@ package com.github.gradle.node.task
 
 import com.github.gradle.node.NodeExtension
 import com.github.gradle.node.NodePlugin
-import com.github.gradle.node.util.PlatformHelper
 import com.github.gradle.node.util.ProjectApiHelper
 import com.github.gradle.node.variant.VariantComputer
-import org.gradle.api.DefaultTask
 import org.gradle.api.model.ObjectFactory
 import org.gradle.api.provider.ProviderFactory
 import org.gradle.api.tasks.*
@@ -14,15 +12,14 @@ import java.nio.file.Files
 import java.nio.file.Paths
 import javax.inject.Inject
 
-abstract class NodeSetupTask : DefaultTask() {
+abstract class NodeSetupTask : BaseTask() {
 
     @get:Inject
     abstract val objects: ObjectFactory
 
     @get:Inject
     abstract val providers: ProviderFactory
 
-    private val variantComputer = VariantComputer()
     private val nodeExtension = NodeExtension[project]
 
     @get:Input
@@ -90,7 +87,7 @@ abstract class NodeSetupTask : DefaultTask() {
     }
 
     private fun setExecutableFlag() {
-        if (!PlatformHelper.INSTANCE.isWindows) {
+        if (!platformHelper.isWindows) {
             val nodeDirProvider = variantComputer.computeNodeDir(nodeExtension)
             val nodeBinDirProvider = variantComputer.computeNodeBinDir(nodeDirProvider)
             val nodeExecProvider = variantComputer.computeNodeExec(nodeExtension, nodeBinDirProvider)

src/main/kotlin/com/github/gradle/node/task/NodeTask.kt

@@ -6,7 +6,6 @@ import com.github.gradle.node.exec.NodeExecConfiguration
 import com.github.gradle.node.exec.NodeExecRunner
 import com.github.gradle.node.util.ProjectApiHelper
 import org.gradle.api.Action
-import org.gradle.api.DefaultTask
 import org.gradle.api.model.ObjectFactory
 import org.gradle.api.provider.ProviderFactory
 import org.gradle.api.tasks.*
@@ -20,7 +19,7 @@ import javax.inject.Inject
 /**
  * Gradle task for running a Node.js script
  */
-abstract class NodeTask : DefaultTask() {
+abstract class NodeTask : BaseTask() {
     @get:Inject
     abstract val objects: ObjectFactory
 
@@ -95,6 +94,6 @@ abstract class NodeTask : DefaultTask() {
                 NodeExecConfiguration(command, environment.get(), workingDir.asFile.orNull,
                         ignoreExitValue.get(), execOverrides.orNull)
         val nodeExecRunner = NodeExecRunner()
-        nodeExecRunner.execute(projectHelper, extension, nodeExecConfiguration)
+        nodeExecRunner.execute(projectHelper, extension, nodeExecConfiguration, variantComputer)
     }
 }

src/main/kotlin/com/github/gradle/node/util/PlatformHelper.kt

@@ -2,7 +2,7 @@ package com.github.gradle.node.util
 
 import java.util.*
 
-open class PlatformHelper constructor(private val props: Properties = System.getProperties()) {
+open class PlatformHelper {
     open val osName: String by lazy {
         val name = property("os.name").toLowerCase()
         when {
@@ -34,13 +34,16 @@ open class PlatformHelper constructor(private val props: Properties = System.get
     open val isWindows: Boolean by lazy { osName == "win" }
 
     private fun property(name: String): String {
-        val value = props.getProperty(name)
-        return value ?: System.getProperty(name) ?:
+        return getSystemProperty(name) ?:
             // Added so that we can test osArch on Windows and on non-arm systems
             if (name == "uname") execute("uname", "-m")
             else error("Unable to find a value for property [$name].")
     }
 
+    open fun getSystemProperty(name: String): String? {
+        return System.getProperty(name);
+    }
+
     companion object {
         var INSTANCE = PlatformHelper()
     }

src/main/kotlin/com/github/gradle/node/variant/VariantComputer.kt

@@ -7,8 +7,8 @@ import com.github.gradle.node.util.zip
 import org.gradle.api.file.Directory
 import org.gradle.api.provider.Provider
 
-open class VariantComputer @JvmOverloads constructor(
-        private val platformHelper: PlatformHelper = PlatformHelper.INSTANCE
+open class VariantComputer constructor(
+        private val platformHelper: PlatformHelper
 ) {
     /**
      * Get the expected directory for a given node version.

src/main/kotlin/com/github/gradle/node/yarn/exec/YarnExecRunner.kt

@@ -17,15 +17,18 @@ abstract class YarnExecRunner {
     @get:Inject
     abstract val providers: ProviderFactory
 
-    private val variantComputer = VariantComputer()
-
-    fun executeYarnCommand(project: ProjectApiHelper, nodeExtension: NodeExtension, nodeExecConfiguration: NodeExecConfiguration) {
+    fun executeYarnCommand(
+        project: ProjectApiHelper,
+        nodeExtension: NodeExtension,
+        nodeExecConfiguration: NodeExecConfiguration,
+        variantComputer: VariantComputer
+    ) {
         val nodeDirProvider = variantComputer.computeNodeDir(nodeExtension)
         val yarnDirProvider = variantComputer.computeYarnDir(nodeExtension)
         val yarnBinDirProvider = variantComputer.computeYarnBinDir(yarnDirProvider)
         val yarnExecProvider = variantComputer.computeYarnExec(nodeExtension, yarnBinDirProvider)
         val additionalBinPathProvider =
-                computeAdditionalBinPath(nodeExtension, nodeDirProvider, yarnBinDirProvider)
+                computeAdditionalBinPath(nodeExtension, nodeDirProvider, yarnBinDirProvider, variantComputer)
         val execConfiguration = ExecConfiguration(yarnExecProvider.get(),
                 nodeExecConfiguration.command, additionalBinPathProvider.get(),
                 addNpmProxyEnvironment(nodeExtension, nodeExecConfiguration), nodeExecConfiguration.workingDir,
@@ -45,9 +48,12 @@ abstract class YarnExecRunner {
         return nodeExecConfiguration.environment
     }
 
-    private fun computeAdditionalBinPath(nodeExtension: NodeExtension,
-                                         nodeDirProvider: Provider<Directory>,
-                                         yarnBinDirProvider: Provider<Directory>): Provider<List<String>> {
+    private fun computeAdditionalBinPath(
+        nodeExtension: NodeExtension,
+        nodeDirProvider: Provider<Directory>,
+        yarnBinDirProvider: Provider<Directory>,
+        variantComputer: VariantComputer
+    ): Provider<List<String>> {
         return nodeExtension.download.flatMap { download ->
             if (!download) {
                 providers.provider { listOf<String>() }

src/main/kotlin/com/github/gradle/node/yarn/task/YarnSetupTask.kt

@@ -24,7 +24,6 @@ abstract class YarnSetupTask : NpmSetupTask() {
 
     @get:OutputDirectory
     val yarnDir by lazy {
-        val variantComputer = VariantComputer()
         variantComputer.computeYarnDir(nodeExtension)
     }