Open utility classes for external consumption.

Author: deepy

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

@@ -4,7 +4,7 @@ import org.gradle.api.Action
 import org.gradle.process.ExecSpec
 import java.io.File
 
-internal data class ExecConfiguration(
+data class ExecConfiguration(
         val executable: String,
         val args: List<String> = listOf(),
         val additionalBinPaths: List<String> = listOf(),

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

@@ -5,7 +5,36 @@ import com.github.gradle.node.util.ProjectApiHelper
 import org.gradle.api.file.DirectoryProperty
 import java.io.File
 
-internal class ExecRunner {
+/**
+ * Helper function that will calculate the environment variables that should be used.
+ *
+ * This is operating-system aware and will check Path and PATH in additionalBinPaths on Windows
+ *
+ * @param execConfiguration configuration to get environment variables from
+ */
+fun computeEnvironment(execConfiguration: ExecConfiguration): Map<String, String> {
+    val execEnvironment = mutableMapOf<String, String>()
+    execEnvironment += System.getenv()
+    execEnvironment += execConfiguration.environment
+    if (execConfiguration.additionalBinPaths.isNotEmpty()) {
+        // Take care of Windows environments that may contain "Path" OR "PATH" - both existing
+        // possibly (but not in parallel as of now)
+        val pathEnvironmentVariableName = if (execEnvironment["Path"] != null) "Path" else "PATH"
+        val actualPath = execEnvironment[pathEnvironmentVariableName]
+        val additionalPathsSerialized = execConfiguration.additionalBinPaths.joinToString(File.pathSeparator)
+        execEnvironment[pathEnvironmentVariableName] =
+            "${additionalPathsSerialized}${File.pathSeparator}${actualPath}"
+    }
+    return execEnvironment
+}
+
+fun computeWorkingDir(nodeProjectDir: DirectoryProperty, execConfiguration: ExecConfiguration): File? {
+    val workingDir = execConfiguration.workingDir ?: nodeProjectDir.get().asFile
+    workingDir.mkdirs()
+    return workingDir
+}
+
+class ExecRunner {
     fun execute(projectHelper: ProjectApiHelper, extension: NodeExtension, execConfiguration: ExecConfiguration) {
         projectHelper.exec {
             executable = execConfiguration.executable
@@ -16,26 +45,4 @@ internal class ExecRunner {
             execConfiguration.execOverrides?.execute(this)
         }
     }
-
-    private fun computeEnvironment(execConfiguration: ExecConfiguration): Map<String, String> {
-        val execEnvironment = mutableMapOf<String, String>()
-        execEnvironment += System.getenv()
-        execEnvironment += execConfiguration.environment
-        if (execConfiguration.additionalBinPaths.isNotEmpty()) {
-            // Take care of Windows environments that may contain "Path" OR "PATH" - both existing
-            // possibly (but not in parallel as of now)
-            val pathEnvironmentVariableName = if (execEnvironment["Path"] != null) "Path" else "PATH"
-            val actualPath = execEnvironment[pathEnvironmentVariableName]
-            val additionalPathsSerialized = execConfiguration.additionalBinPaths.joinToString(File.pathSeparator)
-            execEnvironment[pathEnvironmentVariableName] =
-                    "${additionalPathsSerialized}${File.pathSeparator}${actualPath}"
-        }
-        return execEnvironment
-    }
-
-    private fun computeWorkingDir(nodeProjectDir: DirectoryProperty, execConfiguration: ExecConfiguration): File? {
-        val workingDir = execConfiguration.workingDir ?: nodeProjectDir.get().asFile
-        workingDir.mkdirs()
-        return workingDir
-    }
 }

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

@@ -4,7 +4,7 @@ import org.gradle.api.Action
 import org.gradle.process.ExecSpec
 import java.io.File
 
-internal data class NodeExecConfiguration(
+data class NodeExecConfiguration(
         val command: List<String> = listOf(),
         val environment: Map<String, String> = mapOf(),
         val workingDir: File? = null,

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

@@ -7,33 +7,36 @@ import com.github.gradle.node.variant.VariantComputer
 import org.gradle.api.file.Directory
 import org.gradle.api.provider.Provider
 
-internal class NodeExecRunner {
+/**
+ * This function is responsible for setting up the configuration used when running the tasks.
+ */
+fun buildExecConfiguration(nodeExtension: NodeExtension, nodeExecConfiguration: NodeExecConfiguration):
+        Provider<ExecConfiguration> {
+    val variantComputer = VariantComputer()
+    val nodeDirProvider = variantComputer.computeNodeDir(nodeExtension)
+    val nodeBinDirProvider = variantComputer.computeNodeBinDir(nodeDirProvider)
+    val executableProvider = variantComputer.computeNodeExec(nodeExtension, nodeBinDirProvider)
+    val additionalBinPathProvider = computeAdditionalBinPath(nodeExtension, nodeBinDirProvider)
+    return zip(executableProvider, additionalBinPathProvider)
+        .map { (executable, additionalBinPath) ->
+            ExecConfiguration(executable, nodeExecConfiguration.command, additionalBinPath,
+                nodeExecConfiguration.environment, nodeExecConfiguration.workingDir,
+                nodeExecConfiguration.ignoreExitValue, nodeExecConfiguration.execOverrides)
+        }
+}
+
+fun computeAdditionalBinPath(nodeExtension: NodeExtension, nodeBinDirProvider: Provider<Directory>):
+        Provider<List<String>> {
+    return zip(nodeExtension.download, nodeBinDirProvider)
+        .map { (download, nodeBinDir) ->
+            if (download) listOf(nodeBinDir.asFile.absolutePath) else listOf()
+        }
+}
+
+class NodeExecRunner {
     fun execute(project: ProjectApiHelper, extension: NodeExtension, nodeExecConfiguration: NodeExecConfiguration) {
         val execConfiguration = buildExecConfiguration(extension, nodeExecConfiguration).get()
         val execRunner = ExecRunner()
         execRunner.execute(project, extension, execConfiguration)
     }
-
-    private fun buildExecConfiguration(nodeExtension: NodeExtension, nodeExecConfiguration: NodeExecConfiguration):
-            Provider<ExecConfiguration> {
-        val variantComputer = VariantComputer()
-        val nodeDirProvider = variantComputer.computeNodeDir(nodeExtension)
-        val nodeBinDirProvider = variantComputer.computeNodeBinDir(nodeDirProvider)
-        val executableProvider = variantComputer.computeNodeExec(nodeExtension, nodeBinDirProvider)
-        val additionalBinPathProvider = computeAdditionalBinPath(nodeExtension, nodeBinDirProvider)
-        return zip(executableProvider, additionalBinPathProvider)
-                .map { (executable, additionalBinPath) ->
-                    ExecConfiguration(executable, nodeExecConfiguration.command, additionalBinPath,
-                            nodeExecConfiguration.environment, nodeExecConfiguration.workingDir,
-                            nodeExecConfiguration.ignoreExitValue, nodeExecConfiguration.execOverrides)
-                }
-    }
-
-    private fun computeAdditionalBinPath(nodeExtension: NodeExtension, nodeBinDirProvider: Provider<Directory>):
-            Provider<List<String>> {
-        return zip(nodeExtension.download, nodeBinDirProvider)
-                .map { (download, nodeBinDir) ->
-                    if (download) listOf(nodeBinDir.asFile.absolutePath) else listOf()
-                }
-    }
 }

src/main/kotlin/com/github/gradle/node/npm/proxy/NpmProxy.kt

@@ -5,7 +5,7 @@ import java.util.stream.Collectors.toList
 import java.util.stream.Stream
 import kotlin.text.Charsets.UTF_8
 
-internal class NpmProxy {
+class NpmProxy {
 
     companion object {
         // These are the environment variables that HTTPing applications checks, proxy is on and off.
@@ -28,6 +28,11 @@ internal class NpmProxy {
             return proxyEnvironmentVariables.toMap()
         }
 
+        /**
+         * Helper function for deciding whether to set proxy settings or not.
+         *
+         * If you make use of
+         */
         fun shouldConfigureProxy(env: Map<String, String>, settings: ProxySettings): Boolean {
             if (settings == ProxySettings.FORCED) {
                 return true

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

@@ -43,7 +43,7 @@ interface ProjectApiHelper {
     fun exec(action: Action<ExecSpec>): ExecResult
 }
 
-internal open class DefaultProjectApiHelper @Inject constructor(
+open class DefaultProjectApiHelper @Inject constructor(
         private val factory: ObjectFactory,
         private val execOperations: ExecOperations,
         private val fileSystemOperations: FileSystemOperations,
@@ -74,7 +74,7 @@ internal open class DefaultProjectApiHelper @Inject constructor(
     }
 }
 
-internal open class LegacyProjectApiHelper(private val project: Project) : ProjectApiHelper {
+open class LegacyProjectApiHelper(private val project: Project) : ProjectApiHelper {
 
     override fun fileTree(directory: Directory): ConfigurableFileTree {
         return project.fileTree(directory)

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

@@ -7,7 +7,7 @@ import com.github.gradle.node.util.zip
 import org.gradle.api.file.Directory
 import org.gradle.api.provider.Provider
 
-internal class VariantComputer @JvmOverloads constructor(
+open class VariantComputer @JvmOverloads constructor(
         private val platformHelper: PlatformHelper = PlatformHelper.INSTANCE
 ) {
     fun computeNodeDir(nodeExtension: NodeExtension): Provider<Directory> {