Remove deprecated PlatformHelper

This is necessary so that we can get rid of the lazy isWindows which
causes issues with the configuration-cache on 8.4 nightly.

Author: deepy

CHANGELOG.md

@@ -4,6 +4,8 @@
 * Removed deprecated `nodeModulesDir` from `NodeExtension`
 * The resolved/computed node directory and platform are stored in `resolvedNodeDir` and `resolvedPlatform` on `NodeExtension`
 * Fixes configuration-cache issue in Gradle 8.4
+* Removes the entire `PlatformHelper` as the functionality has migrated into top-level functions
+* Removes the deprecated `HelperExecution`
 
 ## Version 5.0.0 *(2023-05-13)*
 * Support configuration-cache on Gradle 8.1 [#271](https://github.com/node-gradle/gradle-node-plugin/issues/271)

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

@@ -4,7 +4,6 @@ import com.fasterxml.jackson.databind.JsonNode
 import com.fasterxml.jackson.databind.ObjectMapper
 import org.gradle.api.Project
 import org.gradle.kotlin.dsl.property
-import org.gradle.util.GradleVersion
 
 /**
  * Provides a parsed view of package.json

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

@@ -19,7 +19,7 @@ fun buildExecConfiguration(
 ):
         Provider<ExecConfiguration> {
     val nodeDirProvider = nodeExtension.resolvedNodeDir
-    val nodeBinDirProvider = variantComputer.computeNodeBinDir(nodeDirProvider)
+    val nodeBinDirProvider = variantComputer.computeNodeBinDir(nodeDirProvider, nodeExtension.resolvedPlatform)
     val executableProvider = computeNodeExec(nodeExtension, nodeBinDirProvider)
     val additionalBinPathProvider = computeAdditionalBinPath(nodeExtension, nodeBinDirProvider)
     return zip(executableProvider, additionalBinPathProvider)

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

@@ -83,8 +83,8 @@ abstract class NpmExecRunner {
             Provider<ExecutableAndScript> {
         val nodeDirProvider = nodeExtension.resolvedNodeDir
         val npmDirProvider = variantComputer.computeNpmDir(nodeExtension, nodeDirProvider)
-        val nodeBinDirProvider = variantComputer.computeNodeBinDir(nodeDirProvider)
-        val npmBinDirProvider = variantComputer.computeNpmBinDir(npmDirProvider)
+        val nodeBinDirProvider = variantComputer.computeNodeBinDir(nodeDirProvider, nodeExtension.resolvedPlatform)
+        val npmBinDirProvider = variantComputer.computeNpmBinDir(npmDirProvider, nodeExtension.resolvedPlatform)
         val nodeExecProvider = computeNodeExec(nodeExtension, nodeBinDirProvider)
         val executableProvider =
             npmExecConfiguration.commandExecComputer(variantComputer, nodeExtension, npmBinDirProvider)
@@ -121,9 +121,9 @@ abstract class NpmExecRunner {
                 providers.provider { listOf<String>() }
             }
             val nodeDirProvider = nodeExtension.resolvedNodeDir
-            val nodeBinDirProvider = variantComputer.computeNodeBinDir(nodeDirProvider)
+            val nodeBinDirProvider = variantComputer.computeNodeBinDir(nodeDirProvider, nodeExtension.resolvedPlatform)
             val npmDirProvider = variantComputer.computeNpmDir(nodeExtension, nodeDirProvider)
-            val npmBinDirProvider = variantComputer.computeNpmBinDir(npmDirProvider)
+            val npmBinDirProvider = variantComputer.computeNpmBinDir(npmDirProvider, nodeExtension.resolvedPlatform)
             zip(npmBinDirProvider, nodeBinDirProvider).map { (npmBinDir, nodeBinDir) ->
                 listOf(npmBinDir, nodeBinDir).map { file -> file.asFile.absolutePath }
             }

src/main/kotlin/com/github/gradle/node/pnpm/exec/PnpmExecRunner.kt

@@ -76,8 +76,8 @@ abstract class PnpmExecRunner {
             Provider<ExecutableAndScript> {
         val nodeDirProvider = nodeExtension.resolvedNodeDir
         val pnpmDirProvider = variantComputer.computePnpmDir(nodeExtension)
-        val nodeBinDirProvider = variantComputer.computeNodeBinDir(nodeDirProvider)
-        val pnpmBinDirProvider = variantComputer.computePnpmBinDir(pnpmDirProvider)
+        val nodeBinDirProvider = variantComputer.computeNodeBinDir(nodeDirProvider, nodeExtension.resolvedPlatform)
+        val pnpmBinDirProvider = variantComputer.computePnpmBinDir(pnpmDirProvider, nodeExtension.resolvedPlatform)
         val nodeExecProvider = computeNodeExec(nodeExtension, nodeBinDirProvider)
         val executableProvider =
             pnpmExecConfiguration.commandExecComputer(variantComputer, nodeExtension, pnpmBinDirProvider)
@@ -106,9 +106,9 @@ abstract class PnpmExecRunner {
                 providers.provider { listOf<String>() }
             }
             val nodeDirProvider = nodeExtension.resolvedNodeDir
-            val nodeBinDirProvider = variantComputer.computeNodeBinDir(nodeDirProvider)
+            val nodeBinDirProvider = variantComputer.computeNodeBinDir(nodeDirProvider, nodeExtension.resolvedPlatform)
             val pnpmDirProvider = variantComputer.computePnpmDir(nodeExtension)
-            val pnpmBinDirProvider = variantComputer.computePnpmBinDir(pnpmDirProvider)
+            val pnpmBinDirProvider = variantComputer.computePnpmBinDir(pnpmDirProvider, nodeExtension.resolvedPlatform)
             zip(pnpmBinDirProvider, nodeBinDirProvider).map { (pnpmBinDir, nodeBinDir) ->
                 listOf(pnpmBinDir, nodeBinDir).map { file -> file.asFile.absolutePath }
             }

src/main/kotlin/com/github/gradle/node/pnpm/task/PnpmInstallTask.kt

@@ -1,6 +1,5 @@
 package com.github.gradle.node.pnpm.task
 
-import com.github.gradle.node.NodeExtension
 import com.github.gradle.node.NodePlugin
 import com.github.gradle.node.util.zip
 import org.gradle.api.Action

src/main/kotlin/com/github/gradle/node/pnpm/task/PnpmSetupTask.kt

@@ -1,7 +1,6 @@
 package com.github.gradle.node.pnpm.task
 
 import com.github.gradle.node.NodePlugin
-import com.github.gradle.node.npm.proxy.NpmProxy
 import com.github.gradle.node.npm.task.NpmSetupTask
 import com.github.gradle.node.variant.VariantComputer
 import org.gradle.api.provider.Provider
@@ -25,7 +24,7 @@ abstract class PnpmSetupTask : NpmSetupTask() {
 
     @get:OutputDirectory
     val pnpmDir by lazy {
-        val variantComputer = VariantComputer(platformHelper)
+        val variantComputer = VariantComputer()
         variantComputer.computePnpmDir(nodeExtension)
     }
 

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

@@ -1,24 +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
-import org.gradle.process.ExecOperations
 import org.gradle.process.ExecResult
-import javax.inject.Inject
 
 abstract class BaseTask : DefaultTask() {
 
     @get:Internal
     var result: ExecResult? = null
 
-    @get:Internal
-    var platformHelper = PlatformHelper()
-
     @get:Internal
     internal val variantComputer by lazy {
-        VariantComputer(platformHelper)
+        VariantComputer()
     }
 
 

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

@@ -63,7 +63,7 @@ abstract class NodeSetupTask : BaseTask() {
     private fun unpackNodeArchive() {
         val archiveFile = nodeArchiveFile.get().asFile
         val nodeDirProvider = nodeExtension.resolvedNodeDir
-        val nodeBinDirProvider = variantComputer.computeNodeBinDir(nodeDirProvider)
+        val nodeBinDirProvider = variantComputer.computeNodeBinDir(nodeDirProvider, nodeExtension.resolvedPlatform)
         val archivePath = nodeDirProvider.map { it.dir("../") }
         if (archiveFile.name.endsWith("zip")) {
             projectHelper.copy {
@@ -92,7 +92,10 @@ abstract class NodeSetupTask : BaseTask() {
 
     private fun setExecutableFlag() {
         if (!nodeExtension.resolvedPlatform.get().isWindows()) {
-            val nodeBinDirProvider = variantComputer.computeNodeBinDir(nodeExtension.resolvedNodeDir)
+            val nodeBinDirProvider = variantComputer.computeNodeBinDir(
+                nodeExtension.resolvedNodeDir,
+                nodeExtension.resolvedPlatform
+            )
             val nodeExecProvider = computeNodeExec(nodeExtension, nodeBinDirProvider)
             File(nodeExecProvider.get()).setExecutable(true)
         }

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

@@ -2,19 +2,6 @@ package com.github.gradle.node.util
 
 import java.util.concurrent.Callable
 
-
-@Deprecated(message = "This class is no longer needed, the computed output is stored in the NodeExtension")
-internal class DefaultHelperExecution : HelperExecution {
-    override fun exec(command: String, vararg args: String, timeout: Long): String {
-        return execute(command, *args, timeout = timeout)
-    }
-}
-
-@Deprecated(message = "This class is no longer needed, the computed output is stored in the NodeExtension")
-interface HelperExecution {
-    fun exec(command: String, vararg args: String, timeout: Long = 60): String
-}
-
 fun parsePlatform(name: String, arch: String, uname: () -> String): Platform {
     return Platform(parseOsName(name.toLowerCase()), parseOsArch(arch.toLowerCase(), uname))
 }
@@ -46,39 +33,6 @@ fun parseOsArch(arch: String, uname: Callable<String>): String {
     }
 }
 
-open class PlatformHelper(private val execution: HelperExecution = DefaultHelperExecution()) {
-    @get:Deprecated(message = "moved to NodeExtension")
-    open val osName: String by lazy {
-        parseOsName(property("os.name").toLowerCase())
-    }
-
-    @get:Deprecated(message = "moved to NodeExtension")
-    open val osArch: String by lazy {
-        val arch = property("os.arch").toLowerCase()
-        val uname = { property("uname") }
-        parseOsArch(arch, uname)
-    }
-
-    @get:Deprecated(message = "moved to NodeExtension",
-        replaceWith = ReplaceWith("nodeExtension.resolvedPlatform.get().isWindows()"))
-    open val isWindows: Boolean by lazy { osName == "win" }
-
-    private fun property(name: String): String {
-        return getSystemProperty(name) ?:
-            // Added so that we can test osArch on Windows and on non-arm systems
-            if (name == "uname") execution.exec("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()
-    }
-}
-
 fun main(args: Array<String>) {
     val osName = System.getProperty("os.name")
     val osArch = System.getProperty("os.arch")