including test sources to doc processor to enable cross-references

Author: Jolanrensen

core/build.gradle.kts

@@ -69,10 +69,12 @@ val addGeneratedSourcesToGit by tasks.creating(GitTask::class) {
 
 // Backup the kotlin source files location
 val kotlinMainSources = kotlin.sourceSets.main.get().kotlin.sourceDirectories
+val kotlinTestSources = kotlin.sourceSets.test.get().kotlin.sourceDirectories
 
 // Task to generate the processed documentation
 val processKDocsMain by creatingProcessDocTask(
-    sources = kotlinMainSources.filterNot { "build/generated" in it.path }, // Exclude generated sources
+    sources = (kotlinMainSources + kotlinTestSources) // Include both test and main sources for cross-referencing
+        .filterNot { "build/generated" in it.path }, // Exclude generated sources
 ) {
     target = file(generatedSourcesFolderName)
     processors = listOf(
@@ -107,8 +109,9 @@ tasks.withType<Jar> {
     doFirst {
         kotlin.sourceSets.main {
             kotlin.setSrcDirs(
-                processKDocsMain.targets +
-                    kotlinMainSources.filter { "build/generated" in it.path } // Include generated sources (which were excluded above)
+                processKDocsMain.targets
+                    .filterNot { "src/test/kotlin" in it.path || "src/test/java" in it.path } // filter out test sources again
+                    .plus(kotlinMainSources.filter { "build/generated" in it.path }) // Include generated sources (which were excluded above)
             )
         }
     }

core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/AccessApi.kt

@@ -1,7 +1,6 @@
 package org.jetbrains.kotlinx.dataframe.documentation
 
 import org.jetbrains.kotlinx.dataframe.documentation.AccessApi.*
-import org.jetbrains.kotlinx.dataframe.documentation.samples.ApiLevels as ApiLevelsSample
 
 /**
  * ## Access APIs
@@ -123,9 +122,7 @@ internal interface AccessApi {
      *
      * For example:
      * ```kotlin
-     * fun extensionProperties1() {
-     *     val df = DataFrame.read("titanic.csv")
-     * }
+     * val df = DataFrame.read("titanic.csv")
      * ```
      */
     interface ExtensionPropertiesApi

core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/Utils.kt

@@ -0,0 +1,23 @@
+package org.jetbrains.kotlinx.dataframe
+
+import org.jetbrains.kotlinx.dataframe.api.print
+import org.jetbrains.kotlinx.dataframe.api.schema
+import org.jetbrains.kotlinx.dataframe.io.renderToString
+import org.jetbrains.kotlinx.dataframe.types.UtilTests
+import java.net.URL
+
+fun testResource(resourcePath: String): URL = UtilTests::class.java.classLoader.getResource(resourcePath)!!
+fun testCsv(csvName: String) = testResource("$csvName.csv")
+fun testJson(jsonName: String) = testResource("$jsonName.json")
+
+fun <T : DataFrame<*>> T.toDebugString(rowsLimit: Int = 20) = """
+    ${renderToString(borders = true, title = true, columnTypes = true, valueLimit = -1, rowsLimit = rowsLimit)}
+    
+    ${schema()}
+""".trimIndent()
+
+fun <T : DataFrame<*>> T.alsoDebug(println: String? = null, rowsLimit: Int = 20): T = apply {
+    println?.let { println(it) }
+    print(borders = true, title = true, columnTypes = true, valueLimit = -1, rowsLimit = rowsLimit)
+    schema().print()
+}

core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/add.kt

@@ -0,0 +1,36 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.assertions.throwables.shouldThrow
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.AnyFrame
+import org.junit.Test
+import kotlin.reflect.typeOf
+
+class AddTests {
+
+    @Test
+    fun `add with new`() {
+        val x by columnOf(7, 2, 0, 3, 4, 2, 5, 0, 3, 4)
+        val df = dataFrameOf(x)
+        val added = df.add("Y") { if (x() == 0) 0 else (prev()?.newValue() ?: 0) + 1 }
+        val expected = listOf(1, 2, 0, 1, 2, 3, 4, 0, 1, 2)
+        added["Y"].values() shouldBe expected
+    }
+
+    @Test
+    fun `throw for newValue at the next row`() {
+        val x by columnOf(7, 2, 0, 3, 4, 2, 5, 0, 3, 4)
+        val df = dataFrameOf(x)
+        shouldThrow<IndexOutOfBoundsException> {
+            df.add("y") { next()?.newValue() ?: 1 }
+        }
+    }
+
+    private fun <T> AnyFrame.addValue(value: T) = add("value") { listOf(value) }
+
+    @Test
+    fun `add with generic function`() {
+        val df = dataFrameOf("a")(1).addValue(2)
+        df["value"].type() shouldBe typeOf<List<Any?>>()
+    }
+}

core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/cast.kt

@@ -0,0 +1,26 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.assertions.throwables.shouldThrow
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
+import org.junit.Test
+import java.lang.IllegalArgumentException
+
+class CastTests {
+
+    @Test
+    fun safeUnsafeCast() {
+        @DataSchema
+        data class Data(val a: Int, val b: String)
+
+        val df = dataFrameOf("a", "b", "c")(1, "s", 2)
+        df.cast<Data>(verify = true) shouldBe df
+
+        shouldThrow<IllegalArgumentException> {
+            df.convert("a").toDouble().cast<Data>(verify = true)
+        }
+        val converted = df.convert("a").toDouble()
+        converted.cast<Data>(verify = false) shouldBe converted
+        converted.cast<Data>() shouldBe converted
+    }
+}

core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/chunked.kt

@@ -0,0 +1,17 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.size
+import org.junit.Test
+
+class ChunkedTests {
+
+    @Test
+    fun chunkedColumnGroup() {
+        val a by columnOf(listOf(1, 2, 3).toColumn("b"), listOf(4, 5, 6).toColumn("c"))
+        val chunked = a.asColumnGroup().chunked(2)
+        chunked.size shouldBe 2
+        chunked.name() shouldBe "a"
+        chunked[1].rowsCount() shouldBe 1
+    }
+}

core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/concat.kt

@@ -0,0 +1,14 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.matchers.shouldBe
+import org.junit.Test
+
+class ConcatTests {
+
+    @Test
+    fun `different types`() {
+        val a by columnOf(1, 2)
+        val b by columnOf(3.0, null)
+        a.concat(b) shouldBe columnOf(1, 2, 3.0, null).named("a")
+    }
+}

core/generated-sources/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/contains.kt

@@ -0,0 +1,64 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.matchers.shouldBe
+import org.junit.Test
+
+class ContainsTests {
+
+    @Test
+    fun `column contains`() {
+        val col by columnOf(1, 3, 5)
+        col.contains(3) shouldBe true
+        col.contains(2) shouldBe false
+    }
+
+    @Test
+    fun `column group contains`() {
+        val df = dataFrameOf("a", "b")(1, 2, 3, 4)
+        val col = df.asColumnGroup("col")
+        col.contains(df[0]) shouldBe true
+        col.contains(df.update("b").withValue(0)[0]) shouldBe false
+    }
+
+    @Test
+    fun `contains column`() {
+        val a by column<Int>()
+        val df = dataFrameOf("a")(1, 2)
+        (a in df) shouldBe true
+        df.containsColumn(a) shouldBe true
+        df.containsColumn("a") shouldBe true
+        df.containsColumn(df["a"]) shouldBe true
+        val b by column<Int>()
+        (b in df) shouldBe false
+        df.containsColumn(b) shouldBe false
+    }
+
+    @Test
+    fun `contains nested column`() {
+        val g by columnGroup()
+        val a by g.column<Int>()
+
+        val df = dataFrameOf("a")(1, 2).group("a").into("g")
+        (a in df) shouldBe true
+    }
+
+    @Test
+    fun `row contains key`() {
+        val a by column<Int>()
+        val b by column<Int>()
+        data class A(val a: Int, val b: Int)
+
+        val df = dataFrameOf("a")(1, 2)
+        val row = df[0]
+
+        row.containsKey("a") shouldBe true
+        row.containsKey(a) shouldBe true
+        row.containsKey(A::a) shouldBe true
+        (A::a in row) shouldBe true
+        (a in row) shouldBe true
+
+        row.containsKey("b") shouldBe false
+        row.containsKey(b) shouldBe false
+        row.containsKey(A::b) shouldBe false
+    }
+}