@platforma-sdk/workflow-tengo 2.9.6 → 2.9.8

package/dist/tengo/lib/exec.internal.lib.tengo

@@ -1,9 +1,9 @@
-
-
-
-
-
-
+/**
+ * Internal 'exec' module library.
+ *
+ * NOT INTENDEND FOR USE OUTSIDE 'exec' MODULE.
+ * May completely change API from release to release.
+ */
 
 ll := import("@platforma-sdk/workflow-tengo:ll")
 json := import("json")
@@ -20,7 +20,7 @@ constants := import("@platforma-sdk/workflow-tengo:exec.constants")
 desc := import("@platforma-sdk/workflow-tengo:exec.descriptor")
 validation := import("@platforma-sdk/workflow-tengo:validation")
 
-
+// Variables, substituted in command arguments and environment variable values.
 _ARG_VAR_PKG            := "pkg"  // abs path to software package
 _ARG_VAR_JAVA           := "java" // abs path to 'java' run environment
 _ARG_VAR_PYTHON         := "python" // abs path to 'python' run environment
@@ -28,388 +28,388 @@ _ARG_VAR_R              := "R" // abs path to 'R' run environment runtime
 _ARG_VAR_R_VENV         := "rVenv" // abs path to 'R' portable virtual environment
 _ARG_VAR_MNZ            := "monetization" // monetization env value
 
-
+/** Converts the args above to the expressions. */
 _expr := func(varName) {
-return "{" + varName + "}"
+	return "{" + varName + "}"
 }
 
 _newTypedArg := func(type, value) {
-return ll.toStrict({
-type: type,
-value: value
-})
-}
-
-
-
-
-
-
-
-
+	return ll.toStrict({
+		type: type,
+		value: value
+	})
+}
+
+/**
+ * Create new argument with a type. The type can be either string, expression or variable.
+ * Decides whether we need a simple argument or an expression one.
+ * Until 15 Mar 2025, we keep deprecated variable arguments.
+ *
+ * @param isString: boolean - whether it is a string or a difficult (expression) argument.
+ */
 _newArg := func(isString, value) {
-if isString {
-return _newTypedArg(constants.ARG_TYPE_STRING, value)
-}
-if desc.canBackendUseExpressions() {
-return _newTypedArg(constants.ARG_TYPE_EXPRESSION, value)
-}
-return _newTypedArg(constants.ARG_TYPE_VAR, value)
+	if isString {
+		return _newTypedArg(constants.ARG_TYPE_STRING, value)
+	}
+	if desc.canBackendUseExpressions() {
+		return _newTypedArg(constants.ARG_TYPE_EXPRESSION, value)
+	}
+	return _newTypedArg(constants.ARG_TYPE_VAR, value)
 }
 
 _newRefVar := func(varName, refName, reference) {
-
-if !desc.canBackendUseExpressions() {
-return ll.toStrict({
-varName: "{" + varName + "}",
-refName: refName,
-reference: reference
-})
-}
-
-return ll.toStrict({
-varName: varName,
-refName: refName,
-reference: reference
-})
+	// deprecated, remove on 15 Mar 2025
+	if !desc.canBackendUseExpressions() {
+		return ll.toStrict({
+			varName: "{" + varName + "}",
+			refName: refName,
+			reference: reference
+		})
+	}
+
+	return ll.toStrict({
+		varName: varName,
+		refName: refName,
+		reference: reference
+	})
 }
 
 _installSoftware := func(registry, pkgName) {
-ll.assert(is_string(registry), "exec.internal._installSoftware(): registry is not a string, got: %v", registry, pkgName)
-ll.assert(is_string(pkgName), "exec.internal._installSoftware(): pkgName is not a string, got: %v", pkgName, registry)
+	ll.assert(is_string(registry), "exec.internal._installSoftware(): registry is not a string, got: %v", registry, pkgName)
+	ll.assert(is_string(pkgName), "exec.internal._installSoftware(): pkgName is not a string, got: %v", pkgName, registry)
 
-archive := pkg.get(registry, pkgName).archive()
-return pkg.install(archive).package()
+	archive := pkg.get(registry, pkgName).archive()
+	return pkg.install(archive).package()
 }
 
 _directCallOptions := func(runOptions) {
-return ll.toStrict({
-variables: [],
-customPaths: [],
-cmd: _newArg(true, runOptions.cmd),
-args: [],
-envs: {}
-})
+	return ll.toStrict({
+		variables: [],
+		customPaths: [],
+		cmd: _newArg(true, runOptions.cmd),
+		args: [],
+		envs: {}
+	})
 }
 
 _loadJavaRunEnvironment := func(operationMode, descriptor) {
-javaPkg := _installSoftware(descriptor.runEnv.registry, descriptor.runEnv.package)
-javaRefVar := _newRefVar(_ARG_VAR_JAVA, descriptor.runEnv.name, javaPkg)
+	javaPkg := _installSoftware(descriptor.runEnv.registry, descriptor.runEnv.package)
+	javaRefVar := _newRefVar(_ARG_VAR_JAVA, descriptor.runEnv.name, javaPkg)
 
-return ll.toStrict({
-runEnvType: "java",
+	return ll.toStrict({
+		runEnvType: "java",
 
-variables: [ javaRefVar ],
-customPaths: [ _newArg(false, path.join(_expr(_ARG_VAR_JAVA), descriptor.runEnv.binDir)) ],
-envs: {}
-})
+		variables: [ javaRefVar ],
+		customPaths: [ _newArg(false, path.join(_expr(_ARG_VAR_JAVA), descriptor.runEnv.binDir)) ],
+		envs: {}
+	})
 }
 
 _loadPythonRunEnvironment := func(operationMode, descriptor, softName, softPkg) {
-venvBuilder := python.venvBuilder().
-software(softPkg).
-runEnvDescriptor(descriptor.runEnv).
-dependencies(descriptor.dependencies)
+	venvBuilder := python.venvBuilder().
+		software(softPkg).
+		runEnvDescriptor(descriptor.runEnv).
+		dependencies(descriptor.dependencies)
 
-if !is_undefined(descriptor.toolset) && descriptor.toolset != "" {
-venvBuilder.useToolset(descriptor.toolset)
-}
+	if !is_undefined(descriptor.toolset) && descriptor.toolset != "" {
+		venvBuilder.useToolset(descriptor.toolset)
+	}
 
-venv := venvBuilder.
-cacheDays(7).
-build().
-venv()
+	venv := venvBuilder.
+		cacheDays(7).
+		build().
+		venv()
 
-venvRoot := path.join(_expr(_ARG_VAR_PYTHON), "venv")
-venvRefKey := softName + "/venv"
+	venvRoot := path.join(_expr(_ARG_VAR_PYTHON), "venv")
+	venvRefKey := softName + "/venv"
 
-pythonRefVar := _newRefVar(_ARG_VAR_PYTHON, venvRefKey, venv)
+	pythonRefVar := _newRefVar(_ARG_VAR_PYTHON, venvRefKey, venv)
 
-return ll.toStrict({
-runEnvType: "python",
+	return ll.toStrict({
+		runEnvType: "python",
 
-variables: [ pythonRefVar ],
-customPaths: [ _newArg(false, path.join(venvRoot, "bin")) ],
-envs: {
-"VIRTUAL_ENV": _newArg(false, venvRoot)
-}
-})
+		variables: [ pythonRefVar ],
+		customPaths: [ _newArg(false, path.join(venvRoot, "bin")) ],
+		envs: {
+			"VIRTUAL_ENV": _newArg(false, venvRoot)
+		}
+	})
 }
 
 _loadRRunEnvironment := func(operationMode, descriptor, softName, softPkg) {
-renvBuilder := R.rVenvBuilder().
-operationMode(operationMode).
-software(softPkg).
-runEnvDescriptor(descriptor.runEnv).
-dependencies(descriptor.dependencies)
-
-if !is_undefined(descriptor.toolset) && descriptor.toolset != "" {
-renvBuilder.useToolset(descriptor.toolset)
-}
-
-rRuntime := renvBuilder.
-cacheDays(7).
-build()
+	renvBuilder := R.rVenvBuilder().
+		operationMode(operationMode).
+		software(softPkg).
+		runEnvDescriptor(descriptor.runEnv).
+		dependencies(descriptor.dependencies)
 
-rEnv := rRuntime.venv()
-rPackage := rRuntime.R()
+	if !is_undefined(descriptor.toolset) && descriptor.toolset != "" {
+		renvBuilder.useToolset(descriptor.toolset)
+	}
 
-rBinDir := path.join(_expr(_ARG_VAR_R), descriptor.runEnv.binDir)
+	rRuntime := renvBuilder.
+		cacheDays(7).
+		build()
 
-rRefKey := softName + "/R-runtime"
-rRefVar := _newRefVar(_ARG_VAR_R, rRefKey, rPackage)
+	rEnv := rRuntime.venv()
+	rPackage := rRuntime.R()
 
-rEnvRefKey := softName + "/R-virtual-env"
-rEnvRefVar := _newRefVar(_ARG_VAR_R_VENV, rEnvRefKey, rEnv)
+	rBinDir := path.join(_expr(_ARG_VAR_R), descriptor.runEnv.binDir)
 
-renvRootArg := path.join(_expr(_ARG_VAR_R), "renv-root")
+	rRefKey := softName + "/R-runtime"
+	rRefVar := _newRefVar(_ARG_VAR_R, rRefKey, rPackage)
 
-envs := {
-"RHOME": _newArg(false, _expr(_ARG_VAR_R)), // for Rscript (it uses RHOME instead of R_HOME)
-"R_HOME_DIR": _newArg(false, _expr(_ARG_VAR_R)), // for R startup script. It configures all the rest required for R to start.
-"RENV_PATHS_ROOT": _newArg(false, renvRootArg),
-"RENV_PATHS_BINARY": _newArg(false, path.join(renvRootArg, "binaries")),
-"RENV_PATHS_SOURCE": _newArg(false, path.join(renvRootArg, "sources")),
-"RENV_PATHS_CACHE": _newArg(false, path.join(renvRootArg, "cache")),
-"RENV_PATHS_RENV": _newArg(false, path.join(_expr(_ARG_VAR_R_VENV), "renv")),
-"RENV_PATHS_LOCKFILE": _newArg(false, path.join(_expr(_ARG_VAR_PKG), descriptor.dependencies.lockFile))
-}
+	rEnvRefKey := softName + "/R-virtual-env"
+	rEnvRefVar := _newRefVar(_ARG_VAR_R_VENV, rEnvRefKey, rEnv)
 
-if (operationMode != "dev-local") {
+	renvRootArg := path.join(_expr(_ARG_VAR_R), "renv-root")
 
+	envs := {
+		"RHOME": _newArg(false, _expr(_ARG_VAR_R)), // for Rscript (it uses RHOME instead of R_HOME)
+		"R_HOME_DIR": _newArg(false, _expr(_ARG_VAR_R)), // for R startup script. It configures all the rest required for R to start.
+		"RENV_PATHS_ROOT": _newArg(false, renvRootArg),
+		"RENV_PATHS_BINARY": _newArg(false, path.join(renvRootArg, "binaries")),
+		"RENV_PATHS_SOURCE": _newArg(false, path.join(renvRootArg, "sources")),
+		"RENV_PATHS_CACHE": _newArg(false, path.join(renvRootArg, "cache")),
+		"RENV_PATHS_RENV": _newArg(false, path.join(_expr(_ARG_VAR_R_VENV), "renv")),
+		"RENV_PATHS_LOCKFILE": _newArg(false, path.join(_expr(_ARG_VAR_PKG), descriptor.dependencies.lockFile))
+	}
 
-envs["RENV_CONFIG_REPOS_OVERRIDE"] = _newArg(false, path.join(_expr(_ARG_VAR_R), "packages"))
-}
+	if (operationMode != "dev-local") {
+		// In production we can use only locally cached packages: most of commercials have
+		// Platforma Backend executed in a very restricted environment with limited access to the internet.
+		envs["RENV_CONFIG_REPOS_OVERRIDE"] = _newArg(false, path.join(_expr(_ARG_VAR_R), "packages"))
+	}
 
-return ll.toStrict({
-runEnvType: "R",
+	return ll.toStrict({
+		runEnvType: "R",
 
-variables: [ rRefVar, rEnvRefVar ],
-customPaths: [ _newArg(false, rBinDir) ],
-envs: envs
-})
+		variables: [ rRefVar, rEnvRefVar ],
+		customPaths: [ _newArg(false, rBinDir) ],
+		envs: envs
+	})
 }
 
 
 _loadRunEnvironment := func(operationMode, descriptor, softName, softPackage) {
-if descriptor.runEnv.type == "java" {
-return _loadJavaRunEnvironment(operationMode, descriptor)
-}
-if descriptor.runEnv.type == "python" {
-return _loadPythonRunEnvironment(operationMode, descriptor, softName, softPackage)
-}
-if descriptor.runEnv.type == "R" {
-return _loadRRunEnvironment(operationMode, descriptor, softName, softPackage)
-}
-
-ll.panic("run environment type %q is not currently supported by workflow-sdk",	descriptor.runEnv.type)
-}
-
-
-
-
+	if descriptor.runEnv.type == "java" {
+		return _loadJavaRunEnvironment(operationMode, descriptor)
+	}
+	if descriptor.runEnv.type == "python" {
+		return _loadPythonRunEnvironment(operationMode, descriptor, softName, softPackage)
+	}
+	if descriptor.runEnv.type == "R" {
+		return _loadRRunEnvironment(operationMode, descriptor, softName, softPackage)
+	}
+
+	ll.panic("run environment type %q is not currently supported by workflow-sdk",	descriptor.runEnv.type)
+}
+
+/**
+ * @param operationMode: "remote" | "dev-local"
+ */
 _binPackageCallOptions := func(operationMode, softwareName, variables, descriptor, softPackage) {
-customPaths := []
-envs := ll.toStrict({})
-args := []
-runEnvType := "binary"
-
-
-
-if (maps.containsKey(descriptor, "runEnv")) {
-runEnvInfo := _loadRunEnvironment(operationMode, descriptor, softwareName, softPackage)
-
-runEnvType = runEnvInfo.runEnvType
-if len(runEnvInfo.variables) > 0 {
-variables = append(variables, runEnvInfo.variables...)
-}
-if len(runEnvInfo.customPaths) > 0 {
-customPaths = append(customPaths, runEnvInfo.customPaths...)
-}
-if len(runEnvInfo.envs) > 0 {
-for n, v in runEnvInfo.envs {
-envs[n] = v
-}
-}
-}
-
-ll.assert(
-len(descriptor.cmd) != 0,
-"cannot render final command for software: empty 'cmd' and 'command' in software descriptor")
-
-cmd := _newArg(false, descriptor.cmd[0])
-
-for arg in splice(descriptor.cmd, 1) {
-args = append(args, _newArg(false, arg))
-}
-
-return ll.toStrict({
-runEnvType: runEnvType,
-variables: variables,
-customPaths: customPaths,
-cmd: cmd,
-args: args,
-envs: envs
-})
+	customPaths := []
+	envs := ll.toStrict({})
+	args := []
+	runEnvType := "binary"
+
+	// Real command should be:
+	//   [<runEnv bin>] [<runEnv options>] [<entrypoint bin>] [<entrypoint options>] <cmd> <args>
+	if (maps.containsKey(descriptor, "runEnv")) {
+		runEnvInfo := _loadRunEnvironment(operationMode, descriptor, softwareName, softPackage)
+
+		runEnvType = runEnvInfo.runEnvType
+		if len(runEnvInfo.variables) > 0 {
+			variables = append(variables, runEnvInfo.variables...)
+		}
+		if len(runEnvInfo.customPaths) > 0 {
+			customPaths = append(customPaths, runEnvInfo.customPaths...)
+		}
+		if len(runEnvInfo.envs) > 0 {
+			for n, v in runEnvInfo.envs {
+				envs[n] = v
+			}
+		}
+	}
+
+	ll.assert(
+		len(descriptor.cmd) != 0,
+		"cannot render final command for software: empty 'cmd' and 'command' in software descriptor")
+
+	cmd := _newArg(false, descriptor.cmd[0])
+
+	for arg in splice(descriptor.cmd, 1) {
+		args = append(args, _newArg(false, arg))
+	}
+
+	return ll.toStrict({
+		runEnvType: runEnvType,
+		variables: variables,
+		customPaths: customPaths,
+		cmd: cmd,
+		args: args,
+		envs: envs
+	})
 }
 
 _devLocalPackageCallOptions := func(softwareName, localDescriptor) {
-softPackage := pkg.use({
-hash: localDescriptor.hash,
-path: localDescriptor.path,
-descriptor: json.encode(ll.fromStrict(localDescriptor)),
-origin: {
-registry: "dev-local",
-url: "file://" + localDescriptor.path,
-packageName: softwareName
-}
-}).package()
+	softPackage := pkg.use({
+		hash: localDescriptor.hash,
+		path: localDescriptor.path,
+		descriptor: json.encode(ll.fromStrict(localDescriptor)),
+		origin: {
+			registry: "dev-local",
+			url: "file://" + localDescriptor.path,
+			packageName: softwareName
+		}
+	}).package()
 
-variables := [ _newRefVar(_ARG_VAR_PKG, softwareName, softPackage) ]
+	variables := [ _newRefVar(_ARG_VAR_PKG, softwareName, softPackage) ]
 
-return _binPackageCallOptions("dev-local", softwareName, variables, localDescriptor, softPackage)
+	return _binPackageCallOptions("dev-local", softwareName, variables, localDescriptor, softPackage)
 }
 
 _remotePackageCallOptions := func(softwareName, binaryDescriptor) {
-softPackage := _installSoftware(binaryDescriptor.registry, binaryDescriptor.package)
+	softPackage := _installSoftware(binaryDescriptor.registry, binaryDescriptor.package)
 
-variables := [ _newRefVar(_ARG_VAR_PKG, softwareName, softPackage) ]
+	variables := [ _newRefVar(_ARG_VAR_PKG, softwareName, softPackage) ]
 
-return _binPackageCallOptions("remote", softwareName, variables, binaryDescriptor, softPackage)
+	return _binPackageCallOptions("remote", softwareName, variables, binaryDescriptor, softPackage)
 }
 
-
-
-
-
+/** Turns a given software to a list of options that needs to be passed to run cmd builder.
+ * Creates resources to install a software
+ * and runs R or Python env builder templates
+ * if it's necessary. */
 swToRunCmdOptions := func(softwareName, softwareVersion, softwareDescriptor) {
-ll.assert(is_string(softwareName),
-"exec.internal.swToRunCmdOptions: software name must be a string, got %v", softwareName)
-ll.assert(is_string(softwareVersion),
-"exec.internal.swToRunCmdOptions: software version must be a string, got %v", softwareVersion)
-validation.assertJsonSchema(softwareDescriptor, desc.scheme,
-"exec.internal.swToRunCmdOptions: descriptor does not fit schema")
-
-result := undefined
-if maps.containsKey(softwareDescriptor, "local") {
-result = _devLocalPackageCallOptions(softwareName, softwareDescriptor.local)
-} else if maps.containsKey(softwareDescriptor, "binary") {
-result = _remotePackageCallOptions(softwareName, softwareDescriptor.binary)
-} else {
-ll.panic(
-"Unable to run software %s v%s: 'binary' execution mode is not enabled in software descriptor",
-softwareName, softwareVersion)
-}
-
-
-
-return ll.toStrict({
-runEnvType: result.runEnvType,
-variables: result.variables,
-customPaths: result.customPaths,
-cmd: result.cmd,
-args: result.args,
-envs: result.envs
-})
+	ll.assert(is_string(softwareName),
+		"exec.internal.swToRunCmdOptions: software name must be a string, got %v", softwareName)
+	ll.assert(is_string(softwareVersion),
+		"exec.internal.swToRunCmdOptions: software version must be a string, got %v", softwareVersion)
+	validation.assertJsonSchema(softwareDescriptor, desc.scheme,
+		"exec.internal.swToRunCmdOptions: descriptor does not fit schema")
+
+	result := undefined
+	if maps.containsKey(softwareDescriptor, "local") {
+		result = _devLocalPackageCallOptions(softwareName, softwareDescriptor.local)
+	} else if maps.containsKey(softwareDescriptor, "binary") {
+		result = _remotePackageCallOptions(softwareName, softwareDescriptor.binary)
+	} else {
+		ll.panic(
+			"Unable to run software %s v%s: 'binary' execution mode is not enabled in software descriptor",
+			softwareName, softwareVersion)
+	}
+
+	// Clone result fields explicitly here
+	// just to have a gist of what the function returns.
+	return ll.toStrict({
+		runEnvType: result.runEnvType,
+		variables: result.variables,
+		customPaths: result.customPaths,
+		cmd: result.cmd,
+		args: result.args,
+		envs: result.envs
+	})
 }
 
 binaryRunOptions := func(runOptions, mnzEnvs) {
-validation.assertJsonSchema(mnzEnvs, {"any": validation.reference})
-
-runCmdOpts := undefined
-if (is_undefined(ll.fromStrict(runOptions).software)) {
+	validation.assertJsonSchema(mnzEnvs, {"any": validation.reference})
 
+	runCmdOpts := undefined
+	if (is_undefined(ll.fromStrict(runOptions).software)) {
+		//
+		// Simple local command run, no software packages involved (backward compatibility)
+		//
+		runCmdOpts = _directCallOptions(runOptions)
+	} else {
+		software := runOptions.software
+		descriptor := software.descriptor
 
+		runCmdOpts = swToRunCmdOptions(software.name, software.version, descriptor)
+	}
 
-runCmdOpts = _directCallOptions(runOptions)
-} else {
-software := runOptions.software
-descriptor := software.descriptor
+	// adds exec builder's defined options from run options.
+	// If argsTyped or envsTyped are set (which is a new API from exec.builder),
+	// then pass them directly.
+	// Otherwise, pass args and envs the old way, without possible expression evaluating.
+	opts := ll.fromStrict(runOptions)
+	shouldUseNewTyped := !is_undefined(opts.argsTyped) || !is_undefined(opts.envsTyped)
 
-runCmdOpts = swToRunCmdOptions(software.name, software.version, descriptor)
-}
-
-
-
-
-
-opts := ll.fromStrict(runOptions)
-shouldUseNewTyped := !is_undefined(opts.argsTyped) || !is_undefined(opts.envsTyped)
-
-args := shouldUseNewTyped ? runOptions.argsTyped : runOptions.args
-for _, arg in args {
-typedArg := shouldUseNewTyped ? _newTypedArg(arg.type, arg.value) :	_newArg(true, arg)
-runCmdOpts.args = append(runCmdOpts.args, typedArg)
-}
-
-envs := shouldUseNewTyped ? runOptions.envsTyped : runOptions.envs
-for name, v in envs {
-typedEnv := shouldUseNewTyped ? _newTypedArg(v.type, v.value) : _newArg(true, v)
-runCmdOpts.envs[name] = typedEnv
-}
+	args := shouldUseNewTyped ? runOptions.argsTyped : runOptions.args
+	for _, arg in args {
+		typedArg := shouldUseNewTyped ? _newTypedArg(arg.type, arg.value) :	_newArg(true, arg)
+		runCmdOpts.args = append(runCmdOpts.args, typedArg)
+	}
 
-for name, val in mnzEnvs { // can be empty
+	envs := shouldUseNewTyped ? runOptions.envsTyped : runOptions.envs
+	for name, v in envs {
+		typedEnv := shouldUseNewTyped ? _newTypedArg(v.type, v.value) : _newArg(true, v)
+		runCmdOpts.envs[name] = typedEnv
+	}
 
+	for name, val in mnzEnvs { // can be empty
+		// if it's not empty, then we create an env that has
+		// a result of monetization client.
+		runCmdOpts.envs[name] = _newArg(false, _expr(_ARG_VAR_MNZ))
 
-runCmdOpts.envs[name] = _newArg(false, _expr(_ARG_VAR_MNZ))
-
-runCmdOpts.variables = append(runCmdOpts.variables,
-_newRefVar(_ARG_VAR_MNZ, "monetization", val))
-}
+		runCmdOpts.variables = append(runCmdOpts.variables,
+			_newRefVar(_ARG_VAR_MNZ, "monetization", val))
+	}
 
 
-return oop.inherit(runOptions, ll.fromStrict(runCmdOpts))
+	return oop.inherit(runOptions, ll.fromStrict(runCmdOpts))
 }
 
 prepareCommandRun := func(wd, opts) {
-runBuilder := runcmd.builder(wd)
-
-
-for varInfo in opts.variables {
-runBuilder.ref(varInfo.refName, varInfo.reference)
-runBuilder.substitutionRule(varInfo.varName, varInfo.refName)
-}
+	runBuilder := runcmd.builder(wd)
 
+	// Make installed packages to be available for the command run
+	for varInfo in opts.variables {
+		runBuilder.ref(varInfo.refName, varInfo.reference)
+		runBuilder.substitutionRule(varInfo.varName, varInfo.refName)
+	}
 
-for p in opts.customPaths {
-runBuilder.addToPath(p.type, p.value)
-}
-
+	// Patch command's PATH env variable
+	for p in opts.customPaths {
+		runBuilder.addToPath(p.type, p.value)
+	}
 
-for name, value in opts.envs {
-runBuilder.envTyped(name, value.type, value.value)
-}
+	// Configure environment variables required for correct command run environment setup
+	for name, value in opts.envs {
+		runBuilder.envTyped(name, value.type, value.value)
+	}
 
-return runBuilder
+	return runBuilder
 }
 
 _activateRenv := func(wd, opts) {
-activateRenv := prepareCommandRun(wd, opts)
-activateRenv.
-cmd("R").
-arg("-e").arg("renv::activate()")
+	activateRenv := prepareCommandRun(wd, opts)
+	activateRenv.
+		cmd("R").
+		arg("-e").arg("renv::activate()")
 
-activateRenvRun := activateRenv.build()
+	activateRenvRun := activateRenv.build()
 
-return activateRenvRun
+	return activateRenvRun
 }
 
 prepareWDForRunEnvironment := func(wd, opts) {
-if (!maps.containsKey(opts, "runEnvType")) {
-return wd
-}
+	if (!maps.containsKey(opts, "runEnvType")) {
+		return wd
+	}
 
-if (opts.runEnvType == "R") {
-return _activateRenv(wd, opts).workdir
-}
+	if (opts.runEnvType == "R") {
+		return _activateRenv(wd, opts).workdir
+	}
 
-return wd
+	return wd
 }
 
 export {
-swToRunCmdOptions           : swToRunCmdOptions,
-binaryRunOptions			: binaryRunOptions,
+	swToRunCmdOptions           : swToRunCmdOptions,
+	binaryRunOptions			: binaryRunOptions,
 
-prepareWDForRunEnvironment	: prepareWDForRunEnvironment,
-prepareCommandRun			: prepareCommandRun
+	prepareWDForRunEnvironment	: prepareWDForRunEnvironment,
+	prepareCommandRun			: prepareCommandRun
 }