replaced Row typealias with delegate

Author: holgerbrandl

src/main/kotlin/kscript/KscriptUtil.kt

@@ -6,10 +6,21 @@ import kotlin.system.exitProcess
  * @author Holger Brandl
  */
 
+/**
+ * Just used interally to prevent [stopIfNot] to quit the process when running in unit-test mode.
+ * It throw an IllegalArgumentException instead.
+ */
+internal var isTestMode = false
+
+
 /** Similar to require but without a stacktrace which makes it more suited for CLIs. */
-inline fun stopIfNot(value: Boolean, lazyMessage: () -> Any) {
-    if (!value) {
-        System.err.println("[ERROR] " + lazyMessage().toString())
-        exitProcess(1)
-    }
+fun stopIfNot(value: Boolean, lazyMessage: () -> Any) {
+    if (value) return
+
+    val msg = "[ERROR] " + lazyMessage().toString()
+
+    if (isTestMode) throw  IllegalArgumentException(msg)
+
+    System.err.println(msg)
+    exitProcess(1)
 }

src/main/kotlin/kscript/text/OverloadHelper.kt

@@ -0,0 +1,5 @@
+package kscript.text
+
+/** Declare another extension on print to faciliate printing of more base split lines.*/
+
+fun Sequence<List<String>>.print(separator: String = "\t") = map { Row(it) }.print(separator)

src/main/kotlin/kscript/text/Tables.kt

@@ -23,7 +23,16 @@ import kscript.stopIfNot
 
 
 /** For sake of readability we refer to a list of strings as a row here. */
-typealias Row = List<String>
+//typealias Row = List<String>
+
+class Row(val data: List<String>) : List<String> by data {
+
+    constructor(vararg data: String) : this(data.asList())
+
+    override fun get(index: Int): String = data[index - 1]
+
+    override fun toString(): String = data.joinToString("\t")
+}
 
 //typealias RowSequence = Sequence<Row>
 //class RowSequence(input: Sequence<String>){
@@ -35,20 +44,20 @@ typealias Row = List<String>
  * @param separator The used separator character which defaults to tabs.
  */
 fun Sequence<String>.split(separator: String = "\t"): Sequence<Row> {
-    return this.map { it.split(separator) }
+    return this.map { Row(it.split(separator)) }
 }
 
 /** awk-like convenience wrapper around split->map->join->print */
 fun Sequence<String>.awk(separator: String = "\t", rule: (Row) -> String) = split(separator).map { rule(it) }.print()
 
 
 fun Sequence<Row>.map(vararg rules: (Row) -> String): Sequence<Row> {
-    return map { splitLine -> rules.map { it(splitLine) } }
+    return map { splitLine -> Row(rules.map { it(splitLine) }) }
 }
 
 /** Adds a new column to a row. */
 fun Sequence<Row>.add(rule: (Row) -> String): Sequence<Row> {
-    return map { row -> listOf(*row.toTypedArray(), rule(row)) }
+    return map { row -> Row(*row.toTypedArray(), rule(row)) }
 }
 
 
@@ -63,8 +72,7 @@ fun Sequence<Row>.join(separator: String = "\t") = map { it.joinToString(separat
 /** Joins rows with the provided `separator` and print them to `stdout`. */
 fun Sequence<Row>.print(separator: String = "\t") = join(separator).print()
 
-
-fun List<Row>.print() = forEach { println(it) }
+fun List<Row>.print(separator: String = "\t") = asSequence().print(separator)
 
 
 //
@@ -97,19 +105,15 @@ fun without(index: Int) = NegSelect(arrayOf(index))
 fun without(range: IntRange) = NegSelect(range.toList().toTypedArray())
 
 
-private fun retainColumn(selectIndex: ColSelect, colIndex: Int): Boolean {
-    val indexInRange = selectIndex.indices.contains(colIndex)
-
-    return if (selectIndex is PosSelect) indexInRange else !indexInRange
-}
-
 /**
  * Select or remove columns by providing an index-vector. Positive selections are done with [with] and  negative selections with [without]. Both methods implement a [builder][https://en.wikipedia.org/wiki/Builder_pattern] to construct more complex selectors.
  */
 fun Sequence<Row>.select(vararg colIndices: Int): Sequence<Row> {
     val isPositive = colIndices.all { it > 0 }
-    stopIfNot(isPositive || colIndices.all { it < 0 }) {
-        " Can not mix positive and negative selections"
+    val isNegative = colIndices.all { it < 0 }
+
+    stopIfNot(isPositive xor isNegative) {
+        "Can not mix positive and negative selections"
     }
 
     val selector = if (isPositive) PosSelect(arrayOf(*colIndices.toTypedArray())) else NegSelect(arrayOf(*colIndices.toTypedArray()))
@@ -121,12 +125,14 @@ fun Sequence<Row>.select(columns: ColSelect): Sequence<Row> {
     // more efficient but does not allow to change the order
     //    return map { it.filterIndexed { index, _ -> retainColumn(columns, index + 1) } }
 
+    stopIfNot(columns.indices.all { it != 0 }) { "kscript.text.* is using 1-based arrays to ease awk transition" }
+
     return if (columns is PosSelect) {
         // positive selection
-        map { row -> columns.indices.map { row[it - 1] } }
+        map { row -> Row(columns.indices.map { row[it] }) }
     } else {
         // negative selection
-        map { it.filterIndexed { index, _ -> !columns.indices.contains(index - 1) } }
+        map { Row(it.filterIndexed { index, _ -> !columns.indices.contains(index) }) }
     }
 }
 

…/kscript/experimental/OneLinerContext.kt …n/kotlin/kscript/util/OneLinerContext.ktsrc/main/kotlin/kscript/experimental/OneLinerContext.kt renamed to src/main/kotlin/kscript/util/OneLinerContext.kt src/main/kotlin/kscript/experimental/OneLinerContext.kt renamed to src/main/kotlin/kscript/util/OneLinerContext.kt

@@ -1,4 +1,4 @@
-package kscript.experimental
+package kscript.util
 
 import kscript.text.resolveArgFile
 

src/test/kotlin/kscript/examples/AwkComparison.kt

@@ -1,6 +1,6 @@
 package kscript.examples
 
-import kscript.experimental.OneLinerContext
+import kscript.util.OneLinerContext
 import kscript.text.*
 
 /**
@@ -29,7 +29,7 @@ object AwkExample : OneLinerContext(args) {
         lines.awk { it[3] }
 
         // http://stackoverflow.com/questions/15361632/delete-a-column-with-awk-or-sed
-        lines.split().map { it.toMutableList().apply { removeAt(3) } }.print()
+        //        lines.split().select((-3).print()
 
 
 
@@ -87,10 +87,14 @@ object AwkExample : OneLinerContext(args) {
         // Prints Record(line) number, and number of fields in that record
         // awk '{print NR,"->",NF}' file.txt
         lines.split().mapIndexed { index, row -> index.toString() + " -> " + row.size }.print()
+        lines.split().mapIndexed { index, row -> index.toString() + " -> " + row.size }.print()
 
 
         val arg by lazy { resolveArgFile(args) }
         arg.filter { true }.print()
+
+        lines.split().select(with(0).and(1)).print()
+
     }
 }
 //file:///Users/brandl/Desktop/awk_cheatsheets.pdf

src/test/kotlin/kscript/examples/OneLinerExample.kt

@@ -1,6 +1,6 @@
 package kscript.examples
 
-import kscript.experimental.OneLinerContext
+import kscript.util.OneLinerContext
 import kscript.text.add
 import kscript.text.print
 import kscript.text.split

src/test/kotlin/kscript/test/SupportApiTest.kt

@@ -1,37 +1,52 @@
 package kscript.test
 
-import io.kotlintest.matchers.should
-import io.kotlintest.matchers.shouldBe
-import io.kotlintest.matchers.shouldEqual
-import io.kotlintest.matchers.startWith
+import io.kotlintest.matchers.*
 import io.kotlintest.specs.StringSpec
-import kscript.text.linesFrom
-import kscript.text.print
-import kscript.text.resolveArgFile
-import kscript.text.split
-import java.io.File
+import kscript.isTestMode
+import kscript.text.*
 
 /**
  * @author Holger Brandl
  */
+
+
+fun someFlights() = resolveArgFile(arrayOf("src/test/resources/some_flights.tsv"))
+
+fun flightsZipped() = resolveArgFile(arrayOf("src/test/resources/flights.tsv.gz"))
+fun flights() = resolveArgFile(arrayOf("src/test/resources/flights.txt"))
+
+
 class SupportApiTest : StringSpec() { init {
 
-    //    "allow to use stdin for filtering and mapping" {
-    //        kscript.text.stdin.filter { "^de0[-0]*".toRegex().matches(it) }.map { it + "foo:" }.print()
-    //    }
+    isTestMode = true
+
 
     "extract field with column filter" {
-        linesFrom(File("src/test/resources/flights_head.txt")).split().
-                filter { it[8] == "N14228" }.
-                map { it[10] }.
+        someFlights().split().
+                filter { it[12] == "N14228" }.
+                map { it[13] }.
                 toList().
                 apply {
                     size shouldEqual 1
                     first() shouldEqual "EWR"
                 }
+    }
+
+
+    "allow to select columsn" {
+        someFlights().split()
+                .select(with(3).and(11..13).and(1))
+                .first() shouldBe listOf("day", "flight", "tailnum", "origin", "year")
+    }
+
 
+    "rejeced mixed select" {
+        shouldThrow<IllegalArgumentException> {
+            someFlights().split().select(1, -2)
+        }.message shouldBe "[ERROR] Can not mix positive and negative selections"
     }
 
+
     "compressed lines should be unzipped on the fly"{
         resolveArgFile(arrayOf("src/test/resources/flights.tsv.gz")).
                 drop(1).first() should startWith("2013")

src/test/kotlin/kscript/test/TestIncubator.kt

@@ -6,31 +6,36 @@ import kscript.text.*
  * @author Holger Brandl
  */
 
-fun flightsHead() = resolveArgFile(arrayOf("flights_head.txt"))
-
-fun flightsZipped() = resolveArgFile(arrayOf("flights.tsv.gz"))
-fun flights() = resolveArgFile(arrayOf("flights.txt"))
 
 // just used for testing and development
 fun linesFrom(vararg lines: String) = lines.asSequence()
 
 
 fun main(args: Array<String>) {
+    someFlights().split().map { listOf(it[1], it[2], "F11-" + it[7]) }.print()
+    someFlights().split().map { Row(it[1], it[2], "F11-" + it[7]) }.print()
+    //  kscript 'lines.split().map { listOf(it[1], it[2], "F11-"+ it[7]) }.print()' some_flights.tsv
+    //  kscript 'lines.split().map { Row(it[1], it[2], "F11-"+ it[7]) }.print()' some_flights.tsv
+
+    someFlights().split()
+            .select(with(3).and(11..13).and(1))
+            .first().print() //shouldBe listOf("day", "flight", "tailnum", "origin", "year")
+
     // remove header
-    flightsHead().drop(1).take(5)
+    someFlights().drop(1).take(5)
 
 
     // positive selection
     System.out.println("positive selection")
     //    flightsHead().split().select(with(1..3).and(3)).print()
-    flightsHead().split().select(1, 10, 12).print()
-    flightsHead().split().select(10, 1, 12).print()
+    someFlights().split().select(1, 10, 12).print()
+    someFlights().split().select(10, 1, 12).print()
 
     //create column
     //create column
-    flightsHead().split().map { listOf(it[1], it[2], "F11-" + it[7]) }.print()
+    someFlights().split().map { listOf(it[1], it[2], "F11-" + it[7]) }.print()
 
     // negative selection
     System.out.println("negative selection")
-    flightsHead().split().select(without(7).and(3..4)).print()
+    someFlights().split().select(without(7).and(3..4)).print()
 }