initial hacky implementation

Everything is duplicated into NpmExecSource

Author: adam-enko

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

@@ -1,13 +1,29 @@
 package com.github.gradle.node
 
+import com.github.gradle.node.npm.exec.NpmExecResult
+import com.github.gradle.node.npm.exec.NpmExecSource
+import com.github.gradle.node.npm.exec.NpmExecSpec
 import com.github.gradle.node.npm.proxy.ProxySettings
 import com.github.gradle.node.util.Platform
+import com.github.gradle.node.variant.VariantComputer
+import com.github.gradle.node.variant.computeNodeExec
 import org.gradle.api.Project
+import org.gradle.api.file.DirectoryProperty
+import org.gradle.api.provider.Property
+import org.gradle.api.provider.Provider
+import org.gradle.api.provider.ProviderFactory
 import org.gradle.kotlin.dsl.create
 import org.gradle.kotlin.dsl.getByType
+import org.gradle.kotlin.dsl.of
 import org.gradle.kotlin.dsl.property
-
-open class NodeExtension(project: Project) {
+import javax.inject.Inject
+
+abstract class NodeExtension
+@Inject
+internal constructor(
+    project: Project,
+    private val providers: ProviderFactory,
+) {
     private val cacheDir = project.layout.projectDirectory.dir(".gradle")
 
     /**
@@ -18,7 +34,7 @@ open class NodeExtension(project: Project) {
     /**
      * The directory where npm is installed (when a specific version is defined)
      */
-    val npmWorkDir = project.objects.directoryProperty().convention(cacheDir.dir("npm"))
+    val npmWorkDir: DirectoryProperty = project.objects.directoryProperty().convention(cacheDir.dir("npm"))
 
     /**
      * The directory where pnpm is installed (when a pnpm task is used)
@@ -53,7 +69,7 @@ open class NodeExtension(project: Project) {
      * If specified, installs it in the npmWorkDir
      * If empty, the plugin will use the npm command bundled with Node.js
      */
-    val npmVersion = project.objects.property<String>().convention("")
+    val npmVersion: Property<String> = project.objects.property<String>().convention("")
 
     /**
      * Version of pnpm to use
@@ -111,7 +127,7 @@ open class NodeExtension(project: Project) {
      * If true, it will download node using above parameters
      * Note that npm is bundled with Node.js
      */
-    val download = project.objects.property<Boolean>().convention(false)
+    val download: Property<Boolean> = project.objects.property<Boolean>().convention(false)
 
     /**
      * Whether the plugin automatically should add the proxy configuration to npm and yarn commands
@@ -168,7 +184,7 @@ open class NodeExtension(project: Project) {
     /**
      * Computed path to nodejs directory
      */
-    val resolvedNodeDir = project.objects.directoryProperty()
+    val resolvedNodeDir: DirectoryProperty = project.objects.directoryProperty()
 
     /**
      * Operating system and architecture
@@ -179,7 +195,7 @@ open class NodeExtension(project: Project) {
     /**
      * Operating system and architecture
      */
-    val resolvedPlatform = project.objects.property<Platform>()
+    val resolvedPlatform: Property<Platform> = project.objects.property<Platform>()
 
     init {
         distBaseUrl.set("https://nodejs.org/dist")
@@ -193,6 +209,30 @@ open class NodeExtension(project: Project) {
         nodeProxySettings.set(if (value) ProxySettings.SMART else ProxySettings.OFF)
     }
 
+    @Suppress("UnstableApiUsage")
+    fun npmExec(
+        configuration: NpmExecSpec.() -> Unit
+    ): Provider<NpmExecResult> {
+
+        val vc = VariantComputer()
+        val nodeDirProvider = resolvedNodeDir
+        val npmDirProvider = vc.computeNpmDir(this, nodeDirProvider)
+        val nodeBinDirProvider = vc.computeNodeBinDir(nodeDirProvider, resolvedPlatform)
+        val npmBinDirProvider = vc.computeNpmBinDir(npmDirProvider, resolvedPlatform)
+        val nodeExecProvider = computeNodeExec(this, nodeBinDirProvider)
+
+        vc.computeNpmExec(this, npmBinDirProvider)
+
+        return providers.of(NpmExecSource::class) {
+            parameters.apply(configuration)
+//            parameters {
+//                executable
+//                ignoreExitValue
+//                workingDir
+//            }
+        }
+    }
+
     companion object {
         /**
          * Extension name in Gradle

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

@@ -0,0 +1,30 @@
+package com.github.gradle.node.npm.exec
+
+import org.gradle.api.GradleException
+import org.gradle.process.ExecResult
+
+class NpmExecResult internal constructor(
+    val exitValue: Int,
+    val failure: GradleException?,
+    val capturedOutput: String,
+) {
+
+    internal fun asExecResult(): ExecResult = object : ExecResult {
+
+        override fun assertNormalExitValue(): ExecResult {
+            if (failure != null) {
+                throw failure
+            }
+            return this
+        }
+
+        override fun getExitValue(): Int = exitValue
+
+        override fun rethrowFailure(): ExecResult {
+            assertNormalExitValue()
+            return this
+        }
+    }
+
+    override fun toString(): String = "NpmExecResult(exitValue=$exitValue, failure=$failure)"
+}

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

@@ -24,17 +24,26 @@ abstract class NpmExecRunner {
         project: ProjectApiHelper,
         extension: NodeExtension,
         nodeExecConfiguration: NodeExecConfiguration,
-        variants: VariantComputer
+        variants: VariantComputer,
     ): ExecResult {
         val npmExecConfiguration = NpmExecConfiguration(
-            "npm"
-        ) { variantComputer, nodeExtension, npmBinDir -> variantComputer.computeNpmExec(nodeExtension, npmBinDir) }
+            command = "npm",
+            commandExecComputer = { variantComputer, nodeExtension, npmBinDir ->
+                variantComputer.computeNpmExec(
+                    nodeExtension,
+                    npmBinDir
+                )
+            }
+        )
         return executeCommand(
-            project,
-            extension,
-            NpmProxy.addProxyEnvironmentVariables(extension.nodeProxySettings.get(), nodeExecConfiguration),
-            npmExecConfiguration,
-            variants
+            project = project,
+            extension = extension,
+            nodeExecConfiguration = NpmProxy.addProxyEnvironmentVariables(
+                proxySettings = extension.nodeProxySettings.get(),
+                nodeExecConfiguration = nodeExecConfiguration
+            ),
+            npmExecConfiguration = npmExecConfiguration,
+            variantComputer = variants
         )
     }
 
@@ -78,9 +87,13 @@ abstract class NpmExecRunner {
                     if (executableAndScript.script != null) listOf(executableAndScript.script) else listOf()
                 val args = argsPrefix.plus(nodeExecConfiguration.command)
                 ExecConfiguration(
-                    executableAndScript.executable, args, additionalBinPath,
-                    nodeExecConfiguration.environment, nodeExecConfiguration.workingDir,
-                    nodeExecConfiguration.ignoreExitValue, nodeExecConfiguration.execOverrides
+                    executable = executableAndScript.executable,
+                    args = args,
+                    additionalBinPaths = additionalBinPath,
+                    environment = nodeExecConfiguration.environment,
+                    workingDir = nodeExecConfiguration.workingDir,
+                    ignoreExitValue = nodeExecConfiguration.ignoreExitValue,
+                    execOverrides = nodeExecConfiguration.execOverrides,
                 )
             }
     }
@@ -97,18 +110,34 @@ abstract class NpmExecRunner {
         val nodeExecProvider = computeNodeExec(nodeExtension, nodeBinDirProvider)
         val executableProvider =
             npmExecConfiguration.commandExecComputer(variantComputer, nodeExtension, npmBinDirProvider)
-        val isWindows = nodeExtension.resolvedPlatform.get().isWindows()
         val npmScriptFileProvider =
-            computeNpmScriptFile(nodeDirProvider, npmExecConfiguration.command, isWindows)
+            computeNpmScriptFile(nodeDirProvider, npmExecConfiguration.command, nodeExtension.resolvedPlatform)
+        return computeExecutable(
+            npmExecConfiguration.command,
+            nodeExtension,
+            executableProvider,
+            nodeExecProvider,
+            npmScriptFileProvider
+        )
+    }
+
+    private fun computeExecutable(
+        command: String,
+        nodeExtension: NodeExtension,
+        executableProvider: Provider<String>,
+        nodeExecProvider: Provider<String>,
+        npmScriptFileProvider: Provider<String>,
+    ): Provider<ExecutableAndScript> {
         return zip(
-            nodeExtension.download, nodeExtension.nodeProjectDir, executableProvider, nodeExecProvider,
+            nodeExtension.download,
+            nodeExtension.nodeProjectDir,
+            executableProvider,
+            nodeExecProvider,
             npmScriptFileProvider
-        ).map {
-            val (download, nodeProjectDir, executable, nodeExec,
-                npmScriptFile) = it
+        ).map { (download, nodeProjectDir, executable, nodeExec, npmScriptFile) ->
             if (download) {
                 val localCommandScript = nodeProjectDir.dir("node_modules/npm/bin")
-                    .file("${npmExecConfiguration.command}-cli.js").asFile
+                    .file("${command}-cli.js").asFile
                 if (localCommandScript.exists()) {
                     return@map ExecutableAndScript(nodeExec, localCommandScript.absolutePath)
                 } else if (!File(executable).exists()) {
@@ -121,7 +150,7 @@ abstract class NpmExecRunner {
 
     private data class ExecutableAndScript(
         val executable: String,
-        val script: String? = null
+        val script: String? = null,
     )
 
     private fun computeAdditionalBinPath(