Execute commands in a Bash shell

.gitignore

@@ -7,6 +7,7 @@
 .idea/inspectionProfiles/
 .idea/kotlinc.xml
 .idea/libraries/
+.idea/markdown-exported-files.xml
 .idea/markdown-navigator.xml
 .idea/markdown-navigator/
 .idea/misc.xml

README.md

@@ -8,7 +8,7 @@ A simpler extension point than `Exec` for ad-hoc Gradle tasks that run shell com
 
 - [x] Specify entire command line in one string (instead of `List<CharSequence>`).
 - [x] Append/prepend to the current `PATH`.
-- [ ] Execute a command pipe or conditional command chain.
+- [X] Execute a command pipe or conditional command chain.
 - [ ] Easy access to `stdout` and `stderr`.
 
 ## Example `build.gradle`

build.gradle.kts

@@ -76,6 +76,7 @@ repositories {
 dependencies {
     compile(gradleKotlinDsl())
     compile(kotlin("stdlib", kotlinVersion))
+    compile("org.apache.commons:commons-exec:1.3")
 
     // Speck
     compile("org.jetbrains.kotlin:kotlin-reflect:$kotlinVersion")

buildSrc/build.gradle

@@ -12,6 +12,7 @@ buildscript {
 }
 
 apply plugin: 'kotlin'
+apply plugin: 'java'
 
 dependencies {
     compile gradleApi()

example/build.gradle

@@ -4,26 +4,45 @@
  */
 
 buildscript {
-    repositories {
-        jcenter()
-    }
-    dependencies {
-        classpath 'at.phatbl:simple-exec:+'
-    }
+    repositories.jcenter()
+    dependencies.classpath 'at.phatbl:simple-exec:+'
 }
 
-apply plugin: 'simple-exec'
-
 import at.phatbl.simple_exec.SimpleExec
 
 task helloWorld(type: SimpleExec) {
     group "Example"
     command "echo Hello World!"
 }
 
+task successfulCommand(type: SimpleExec) {
+    group "Example"
+    command "true"
+}
+
+task failingCommand(type: SimpleExec) {
+    group "Example"
+    command "false"
+}
+
+task emptyCommand(type: SimpleExec) {
+    group "Example"
+    command ""
+}
+
+task errorLogging(type: SimpleExec) {
+    group "Example"
+    command "cat missingfile"
+}
+
 task customPath(type: SimpleExec) {
     group "Example"
-    prePath = "/Library/Java/JavaVirtualMachines/jdk-9.jdk/Contents/Home/bin"
+    prePath = "/Library/Java/JavaVirtualMachines/jdk-9.0.1.jdk/Contents/Home/bin"
     postPath = ""
-    command "java -version"
+    command 'env | grep PATH= && java -version'
+}
+
+task lolCowFortune(type: SimpleExec) {
+    group "Example"
+    command "fortune | cowsay | lolcat"
 }

src/main/kotlin/at.phatbl.simple_exec/GradleExec.kt

@@ -0,0 +1,102 @@
+package at.phatbl.simple_exec
+
+import org.gradle.api.tasks.AbstractExecTask
+import org.gradle.api.tasks.Input
+import org.gradle.api.tasks.Internal
+import org.gradle.api.tasks.Optional
+import org.gradle.process.ExecResult
+import org.gradle.process.ExecSpec
+import org.gradle.process.ProcessForkOptions
+import org.gradle.process.internal.ExecAction
+import java.io.File
+import java.io.InputStream
+import java.io.OutputStream
+
+/**
+ * Interface for compatibility with the Gradle Exec task.
+ */
+interface GradleExec <T: Any> { //<T: AbstractExecTask>: ExecSpec {
+    fun commandLine(vararg arguments: Any): T
+
+    fun commandLine(args: Iterable<*>): T
+
+    fun args(vararg args: Any): T
+
+    fun args(args: Iterable<*>): T
+
+    fun setArgs(arguments: List<String>): T
+
+    fun setArgs(arguments: Iterable<*>): T
+
+    @Optional
+    @Input
+    fun getArgs(): List<String>
+
+    @Internal
+    fun getCommandLine(): List<String>
+
+    fun setCommandLine(args: List<String>)
+
+    fun setCommandLine(args: Iterable<*>)
+
+    fun setCommandLine(vararg args: Any)
+
+    @Optional
+    @Input
+    fun getExecutable(): String
+
+    fun setExecutable(executable: String)
+
+    fun setExecutable(executable: Any)
+
+    fun executable(executable: Any): T
+
+    @Internal
+    // TODO:LPTR Should be a content-less @InputDirectory
+    fun getWorkingDir(): File
+
+    fun setWorkingDir(dir: File)
+
+    fun setWorkingDir(dir: Any)
+
+    fun workingDir(dir: Any): T
+
+    @Internal
+    fun getEnvironment(): Map<String, Any>
+
+    fun setEnvironment(environmentVariables: Map<String, *>)
+
+    fun environment(name: String, value: Any): T
+
+    fun environment(environmentVariables: Map<String, *>): T
+
+    fun copyTo(target: ProcessForkOptions): T
+
+    fun setStandardInput(inputStream: InputStream): T
+
+    @Internal
+    fun getStandardInput(): InputStream
+
+    fun setStandardOutput(outputStream: OutputStream): T
+
+    @Internal
+    fun getStandardOutput(): OutputStream
+
+    fun setErrorOutput(outputStream: OutputStream): T
+
+    @Internal
+    fun getErrorOutput(): OutputStream
+
+    fun setIgnoreExitValue(ignoreExitValue: Boolean): T
+
+    @Input
+    fun isIgnoreExitValue(): Boolean
+
+    /**
+     * Returns the result for the command run by this task. Returns `null` if this task has not been executed yet.
+     *
+     * @return The result. Returns `null` if this task has not been executed yet.
+     */
+    @Internal
+    fun getExecResult(): ExecResult
+}

src/main/kotlin/at.phatbl.simple_exec/ShellCommand.kt

@@ -0,0 +1,85 @@
+package at.phatbl.simple_exec
+
+import java.io.*
+import java.util.concurrent.TimeUnit
+
+/**
+ * Wrapper for running several commands inside a Bash shell.
+ */
+data class ShellCommand(
+        val baseDir: File,
+        val command: String
+) {
+    lateinit var process: Process
+
+    var standardOutput: OutputStream? = null
+    var errorOutput: OutputStream? = null
+//    val standardInput: InputStream
+
+    val stdout: String
+        get() = stream2String(process.inputStream)
+
+    val stderr: String
+        get() = stream2String(process.errorStream)
+
+    var exitValue: Int = -999
+
+    val succeeded: Boolean
+        get() = exitValue == 0
+
+    val failed: Boolean
+        get() = !succeeded
+
+    /**
+     * Runs the command.
+     */
+    fun start() {
+        baseDir.mkdir()
+        val pb = ProcessBuilder("bash", "-c", "cd $baseDir && $command")
+        process = pb.start()
+
+        if (standardOutput != null) {
+            copy(input = process.inputStream, output = standardOutput!!)
+        }
+        if (errorOutput != null) {
+            copy(input = process.errorStream, output = errorOutput!!)
+        }
+
+        // 20m
+        process.waitFor(1200, TimeUnit.SECONDS)
+
+        exitValue = process.exitValue()
+    }
+
+    /**
+     * Utility function which converts an input stream into a string.
+     */
+    private fun stream2String(stream: InputStream): String {
+        val reader = BufferedReader(InputStreamReader(stream))
+        val builder = StringBuilder()
+        val lineSeparator = System.getProperty("line.separator")
+        reader.forEachLine { line ->
+            builder.append(line)
+            builder.append(lineSeparator)
+        }
+        return builder.toString()
+    }
+
+    private val BUFFER_SIZE = 2 * 1024 * 1024
+
+    @Throws(IOException::class)
+    private fun copy(input: InputStream, output: OutputStream) {
+        try {
+            val buffer = ByteArray(BUFFER_SIZE)
+            var bytesRead = input.read(buffer)
+            while (bytesRead != -1) {
+                output.write(buffer, 0, bytesRead)
+                bytesRead = input.read(buffer)
+            }
+            //If needed, close streams.
+        } finally {
+            input.close()
+            output.close()
+        }
+    }
+}