new static table renderer including fold-out tables in FrameColumns and flattened ColGroups for static tables in ipynb files

Author: Jolanrensen

core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/Utils.kt

@@ -57,7 +57,7 @@ internal fun <T> ColumnWithPath<T>.changePath(path: ColumnPath): ColumnWithPath<
 
 internal fun <T> BaseColumn<T>.addParentPath(path: ColumnPath) = addPath(path + name)
 
-internal fun <T> BaseColumn<T>.addPath(): ColumnWithPath<T> = addPath(pathOf(name))
+/* TODO internal */ public fun <T> BaseColumn<T>.addPath(): ColumnWithPath<T> = addPath(pathOf(name))
 
 internal fun ColumnPath.depth() = size - 1
 

core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/io/html.kt

@@ -5,15 +5,12 @@ import org.jetbrains.kotlinx.dataframe.AnyCol
 import org.jetbrains.kotlinx.dataframe.AnyFrame
 import org.jetbrains.kotlinx.dataframe.AnyRow
 import org.jetbrains.kotlinx.dataframe.DataFrame
-import org.jetbrains.kotlinx.dataframe.api.FormattingDSL
-import org.jetbrains.kotlinx.dataframe.api.RowColFormatter
-import org.jetbrains.kotlinx.dataframe.api.asNumbers
-import org.jetbrains.kotlinx.dataframe.api.isEmpty
-import org.jetbrains.kotlinx.dataframe.api.isNumber
-import org.jetbrains.kotlinx.dataframe.api.isSubtypeOf
-import org.jetbrains.kotlinx.dataframe.api.rows
+import org.jetbrains.kotlinx.dataframe.api.*
+import org.jetbrains.kotlinx.dataframe.columns.BaseColumn
 import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
+import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
 import org.jetbrains.kotlinx.dataframe.impl.DataFrameSize
+import org.jetbrains.kotlinx.dataframe.impl.columns.addPath
 import org.jetbrains.kotlinx.dataframe.impl.renderType
 import org.jetbrains.kotlinx.dataframe.impl.scale
 import org.jetbrains.kotlinx.dataframe.impl.truncate
@@ -175,13 +172,21 @@ internal fun AnyFrame.toHtmlData(
     return DataFrameHtmlData("", body, script)
 }
 
-internal fun AnyFrame.toStaticHtml(
+/**
+ * Renders [this] [DataFrame] as static HTML (meaning no JS is used).
+ * CSS rendering is enabled by default but can be turned off using [includeCss]
+ */
+public fun AnyFrame.toStaticHtml(
     configuration: DisplayConfiguration = DisplayConfiguration.DEFAULT,
-    cellRenderer: CellRenderer,
+    cellRenderer: CellRenderer = DefaultCellRenderer,
+    includeCss: Boolean = true,
 ): DataFrameHtmlData {
     val df = this
     val id = "static_df_${nextTableId()}"
-    val columnsToRender = columns()
+    val flattenedCols = getColumnsWithPaths { cols { !it.isColumnGroup() }.recursively() }
+    val colGrid = getColumnsHeaderGrid()
+    val borders = colGrid.last().map { it.borders }
+    val nestedRowsLimit = configuration.nestedRowsLimit
 
     fun StringBuilder.emitTag(tag: String, attributes: String = "", tagContents: StringBuilder.() -> Unit) {
         append("<")
@@ -200,22 +205,57 @@ internal fun AnyFrame.toStaticHtml(
     }
 
     fun StringBuilder.emitHeader() = emitTag("thead") {
-        emitTag("tr") {
-            columnsToRender.forEach { col ->
-                emitTag("th") {
-                    append(col.name())
+        for (row in colGrid) {
+            emitTag("tr") {
+                for ((j, col) in row.withIndex()) {
+                    var borders = col.borders
+                    if (row.getOrNull(j + 1)?.borders?.contains(Border.LEFT) == true) {
+                        // because left does not work unless at first column
+                        borders += Border.RIGHT
+                    }
+                    emitTag("th", borders.toClass()) {
+                        append(col.columnWithPath?.name ?: "")
+                    }
                 }
             }
         }
     }
 
-    fun StringBuilder.emitCell(cellValue: Any?) = emitTag("td") {
-        append(cellRenderer.content(cellValue, configuration).truncatedContent)
+    fun StringBuilder.emitCell(cellValue: Any?, borders: Set<Border>): Unit = emitTag("td", borders.toClass()) {
+        when (cellValue) {
+            is AnyFrame ->
+                emitTag("details") {
+                    emitTag("summary") {
+                        append("DataFrame ")
+                        append(cellRenderer.content(cellValue, configuration).truncatedContent)
+                    }
+                    append(
+                        cellValue.take(nestedRowsLimit ?: Int.MAX_VALUE)
+                            .toStaticHtml(configuration, cellRenderer, includeCss = false)
+                            .toString()
+                    )
+                    val size = cellValue.rowsCount()
+                    if (size > nestedRowsLimit ?: Int.MAX_VALUE) {
+                        emitTag("p") {
+                            append("... showing only top $nestedRowsLimit of $size rows")
+                        }
+                    }
+                }
+
+            else ->
+                append(cellRenderer.content(cellValue, configuration).truncatedContent)
+        }
     }
 
     fun StringBuilder.emitRow(row: AnyRow) = emitTag("tr") {
-        columnsToRender.forEach { col ->
-            emitCell(row[col.path()])
+        for ((i, col) in flattenedCols.withIndex()) {
+            var border = borders[i]
+            if (borders.getOrNull(i + 1)?.contains(Border.LEFT) == true) {
+                // because left does not work unless at first column
+                border += Border.RIGHT
+            }
+            val cell = row[col.path()]
+            emitCell(cell, border)
         }
     }
 
@@ -231,12 +271,79 @@ internal fun AnyFrame.toStaticHtml(
         emitBody()
     }
 
-    return DataFrameHtmlData(
-        body = buildString { emitTable() },
-        script = """
-            document.getElementById("$id").style.display = "none";
-        """.trimIndent()
-    )
+    return DataFrameHtmlData(body = buildString { emitTable() }) +
+        DataFrameHtmlData.tableDefinitions(includeJs = false, includeCss = includeCss)
+}
+
+private enum class Border(val className: String) {
+    // NOTE: these don't render unless at leftmost; add rightborder to the previous cell.
+    LEFT("leftBorder"),
+    RIGHT("rightBorder"),
+    BOTTOM("bottomBorder");
+}
+
+private fun Set<Border>.toClass(): String = "class=\"${joinToString(" ") { it.className }}\""
+
+private data class ColumnWithPathWithBorder<T>(
+    val columnWithPath: ColumnWithPath<T>? = null,
+    val borders: Set<Border> = emptySet(),
+)
+
+/** Returns the depth of the most-nested column in this group, starting at 0 */
+private fun ColumnGroup<*>.maxDepth(): Int = getColumnsWithPaths { all().recursively() }.maxOf { it.depth() }
+
+/** Returns the max number of columns needed to display this column flattened */
+private fun BaseColumn<*>.maxWidth(): Int =
+    if (this is ColumnGroup<*>) columns().sumOf { it.maxWidth() }.coerceAtLeast(1)
+    else 1
+
+/**
+ * Given a [DataFrame], this function returns a depth-first "matrix" containing all columns
+ * layed out in such a way that they can be used to render the header of a table. The
+ * [ColumnWithPathWithBorder.columnWithPath] is `null` when nothing should be rendered in that cell.
+ * Borders are included too, also for `null` cells.
+ *
+ * For example:
+ * ```
+ * `colGroup` `    |` `|colD` `colC`
+ * `colA    ` `colB|` `|    ` `    `
+ *  ----       ----   ----    ----
+ * ```
+ */
+private fun AnyFrame.getColumnsHeaderGrid(): List<List<ColumnWithPathWithBorder<*>>> {
+    val colGroup = asColumnGroup("")
+    val maxDepth = colGroup.maxDepth()
+    val maxWidth = colGroup.maxWidth()
+    val map =
+        MutableList(maxDepth + 1) { MutableList(maxWidth) { ColumnWithPathWithBorder<Any?>() } }
+
+    fun ColumnWithPath<*>.addChildren(depth: Int = 0, breadth: Int = 0) {
+        var breadth = breadth
+        val children = children()
+        val lastIndex = children.lastIndex
+        for ((i, child) in children().withIndex()) {
+            map[depth][breadth] = map[depth][breadth].copy(columnWithPath = child)
+
+            // draw colGroup borders unless at start/end of table
+            val borders = mutableSetOf<Border>()
+            if (i == 0 && breadth != 0) borders += Border.LEFT
+            if (i == lastIndex && breadth != maxWidth - 1) borders += Border.RIGHT
+            if (depth == maxDepth) borders += Border.BOTTOM
+
+            if (borders.isNotEmpty()) {
+                for (j in (depth - 1).coerceAtLeast(0)..maxDepth) {
+                    map[j][breadth] = map[j][breadth].let { it.copy(borders = it.borders + borders) }
+                }
+            }
+
+            if (child is ColumnGroup<*>) {
+                child.addChildren(depth + 1, breadth)
+            }
+            breadth += child.maxWidth()
+        }
+    }
+    colGroup.addPath().addChildren()
+    return map
 }
 
 internal fun DataFrameHtmlData.print() = println(this)
@@ -305,28 +412,45 @@ public data class DataFrameHtmlData(
     @Language("html", prefix = "<body>", suffix = "</body>") val body: String = "",
     @Language("js") val script: String = ""
 ) {
-    @Language("html")
-    override fun toString(): String = """
-        <html>
-        <head>
-            <style type="text/css">
-                $style
-            </style>
-        </head>
-        <body>
-            $body
-        </body>
-        <script>
-            $script
-        </script>
-        </html>
-    """.trimIndent()
+    override fun toString(): String = buildString {
+        appendLine("<html>")
+        if (style.isNotBlank()) {
+            appendLine("<head>")
+            appendLine("<style type=\"text/css\">")
+            appendLine(style)
+            appendLine("</style>")
+            appendLine("</head>")
+        }
+        if (body.isNotBlank()) {
+            appendLine("<body>")
+            appendLine(body)
+            appendLine("</body>")
+        }
+        if (script.isNotBlank()) {
+            appendLine("<script>")
+            appendLine(script)
+            appendLine("</script>")
+        }
+        appendLine("</html>")
+    }
 
     public operator fun plus(other: DataFrameHtmlData): DataFrameHtmlData =
         DataFrameHtmlData(
-            style + "\n" + other.style,
-            body + "\n" + other.body,
-            script + "\n" + other.script,
+            style = when {
+                style.isBlank() -> other.style
+                other.style.isBlank() -> style
+                else -> style + "\n" + other.style
+            },
+            body = when {
+                body.isBlank() -> other.body
+                other.body.isBlank() -> body
+                else -> body + "\n" + other.body
+            },
+            script = when {
+                script.isBlank() -> other.script
+                other.script.isBlank() -> script
+                else -> script + "\n" + other.script
+            },
         )
 
     public fun writeHTML(destination: File) {