Format colgroups

core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/format.kt

@@ -1,7 +1,6 @@
 package org.jetbrains.kotlinx.dataframe.api
 
 import org.jetbrains.kotlinx.dataframe.ColumnsSelector
-import org.jetbrains.kotlinx.dataframe.DataColumn
 import org.jetbrains.kotlinx.dataframe.DataFrame
 import org.jetbrains.kotlinx.dataframe.DataRow
 import org.jetbrains.kotlinx.dataframe.RowColumnExpression
@@ -15,7 +14,10 @@ import org.jetbrains.kotlinx.dataframe.api.FormattingDsl.linear
 import org.jetbrains.kotlinx.dataframe.api.FormattingDsl.linearBg
 import org.jetbrains.kotlinx.dataframe.api.FormattingDsl.rgb
 import org.jetbrains.kotlinx.dataframe.api.FormattingDsl.textColor
+import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
 import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
+import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
+import org.jetbrains.kotlinx.dataframe.columns.FrameColumn
 import org.jetbrains.kotlinx.dataframe.columns.toColumnSet
 import org.jetbrains.kotlinx.dataframe.dataTypes.IFRAME
 import org.jetbrains.kotlinx.dataframe.dataTypes.IMG
@@ -66,6 +68,21 @@ import kotlin.reflect.KProperty
  *
  * You can continue formatting the [FormattedFrame] by calling [format][FormattedFrame.format] on it again.
  *
+ * Specifying a [column group][ColumnGroup] makes all of its inner columns be formatted in the same way unless
+ * overridden.
+ *
+ * Formatting is done additively, meaning you can add more formatting to a cell that's already formatted or
+ * override certain attributes inherited from its outer group.
+ *
+ * Specifying a [frame column][FrameColumn] at the moment does nothing
+ * ([Issue #1375](https://github.com/Kotlin/dataframe/issues/1375)),
+ * convert each nested [DataFrame] to a [FormattedFrame] instead:
+ * ```kt
+ * df.convert { myFrameCol }.with {
+ *     it.format { someCol }.with { background(green) }
+ * }.toStandaloneHtml()
+ * ```
+ *
  * Check out the [Grammar].
  *
  * For more information: {@include [DocumentationUrls.Format]}
@@ -169,7 +186,7 @@ internal interface FormatDocs {
         interface CellFormatterDef
 
         /**
-         * `rowColFormatter: `{@include [FormattingDslGrammarRef]}`.(row: `[DataRow][DataRow]`<T>, col: `[DataColumn][DataColumn]`<C>) -> `[CellAttributes][CellAttributes]`?`
+         * `rowColFormatter: `{@include [FormattingDslGrammarRef]}`.(row: `[DataRow][DataRow]`<T>, col: `[ColumnWithPath][ColumnWithPath]`<C>) -> `[CellAttributes][CellAttributes]`?`
          */
         interface RowColFormatterDef
 
@@ -348,7 +365,7 @@ public fun <T> FormattedFrame<T>.format(vararg columns: String): FormatClause<T,
  *   .toStandaloneHtml().openInBrowser()
  * ```
  */
-public fun <T> FormattedFrame<T>.format(): FormatClause<T, Any?> = FormatClause(df, null, formatter)
+public fun <T> FormattedFrame<T>.format(): FormatClause<T, Any?> = FormatClause(df = df, oldFormatter = formatter)
 
 // endregion
 
@@ -470,7 +487,7 @@ public fun <T, C> FormatClause<T, C>.perRowCol(formatter: RowColFormatter<T, C>)
  */
 @Suppress("UNCHECKED_CAST")
 public fun <T, C> FormatClause<T, C>.with(formatter: CellFormatter<C>): FormattedFrame<T> =
-    formatImpl { row, col -> formatter(row[col.name] as C) }
+    formatImpl { row, col -> formatter(col[row] as C) }
 
 /**
  * Creates a new [FormattedFrame] that uses the specified [CellFormatter] to format selected non-null cells of the dataframe.
@@ -734,14 +751,14 @@ public object FormattingDsl {
 
 /**
  * A lambda function expecting a [CellAttributes] or `null` given an instance of
- * [DataRow][DataRow]`<`[T][T]`>` and [DataColumn][DataColumn]`<`[C][C]`>`.
+ * [DataRow][DataRow]`<`[T][T]`>` and [ColumnWithPath][ColumnWithPath]`<`[C][C]`>`.
  *
  * This is similar to a [RowColumnExpression], except that you also have access
  * to the [FormattingDsl] in the context.
  *
  * @include [FormattingDsl]
  */
-public typealias RowColFormatter<T, C> = FormattingDsl.(row: DataRow<T>, col: DataColumn<C>) -> CellAttributes?
+public typealias RowColFormatter<T, C> = FormattingDsl.(row: DataRow<T>, col: ColumnWithPath<C>) -> CellAttributes?
 
 /**
  * A lambda function expecting a [CellAttributes] or `null` given an instance of a cell: [C] of the dataframe.
@@ -838,7 +855,7 @@ public class FormattedFrame<T>(internal val df: DataFrame<T>, internal val forma
  */
 public class FormatClause<T, C>(
     internal val df: DataFrame<T>,
-    internal val columns: ColumnsSelector<T, C>? = null,
+    internal val columns: ColumnsSelector<T, C> = { all().cast() },
     internal val oldFormatter: RowColFormatter<T, C>? = null,
     internal val filter: RowValueFilter<T, C> = { true },
 ) {

core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/format.kt

@@ -8,9 +8,10 @@ import org.jetbrains.kotlinx.dataframe.api.RgbColor
 import org.jetbrains.kotlinx.dataframe.api.RowColFormatter
 import org.jetbrains.kotlinx.dataframe.api.and
 import org.jetbrains.kotlinx.dataframe.api.cast
-import org.jetbrains.kotlinx.dataframe.api.getColumnsWithPaths
-import org.jetbrains.kotlinx.dataframe.api.name
-import org.jetbrains.kotlinx.dataframe.columns.depth
+import org.jetbrains.kotlinx.dataframe.api.getColumnPaths
+import org.jetbrains.kotlinx.dataframe.columns.UnresolvedColumnsPolicy
+import org.jetbrains.kotlinx.dataframe.impl.getColumnPaths
+import org.jetbrains.kotlinx.dataframe.path
 
 internal class SingleAttribute(val key: String, val value: String) : CellAttributes {
     override fun attributes() = listOf(key to value)
@@ -53,25 +54,17 @@ internal inline fun <T, C> FormatClause<T, C>.formatImpl(
     crossinline formatter: RowColFormatter<T, C>,
 ): FormattedFrame<T> {
     val clause = this
-    val columns =
-        if (clause.columns != null) {
-            clause.df.getColumnsWithPaths(clause.columns)
-                .mapNotNull { if (it.depth == 0) it.name else null } // TODO Causes #1356
-                .toSet()
-        } else {
-            null
-        }
+    val columns = clause.df.getColumnPaths(UnresolvedColumnsPolicy.Skip, clause.columns).toSet()
+
     return FormattedFrame(clause.df) { row, col ->
         val oldAttributes = clause.oldFormatter?.invoke(FormattingDsl, row, col.cast())
-        if (columns == null || columns.contains(col.name())) {
-            val value = row[col.name] as C
+        if (col.path in columns) {
+            val value = col[row] as C
             if (clause.filter(row, value)) {
-                oldAttributes and formatter(FormattingDsl, row.cast(), col.cast())
-            } else {
-                oldAttributes
+                return@FormattedFrame oldAttributes and formatter(FormattingDsl, row.cast(), col.cast())
             }
-        } else {
-            oldAttributes
         }
+
+        oldAttributes
     }
 }

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

@@ -5,9 +5,11 @@ 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.CellAttributes
 import org.jetbrains.kotlinx.dataframe.api.FormattedFrame
 import org.jetbrains.kotlinx.dataframe.api.FormattingDsl
 import org.jetbrains.kotlinx.dataframe.api.RowColFormatter
+import org.jetbrains.kotlinx.dataframe.api.and
 import org.jetbrains.kotlinx.dataframe.api.asColumnGroup
 import org.jetbrains.kotlinx.dataframe.api.asNumbers
 import org.jetbrains.kotlinx.dataframe.api.format
@@ -24,6 +26,7 @@ import org.jetbrains.kotlinx.dataframe.columns.FrameColumn
 import org.jetbrains.kotlinx.dataframe.dataTypes.IFRAME
 import org.jetbrains.kotlinx.dataframe.dataTypes.IMG
 import org.jetbrains.kotlinx.dataframe.impl.DataFrameSize
+import org.jetbrains.kotlinx.dataframe.impl.columns.addParentPath
 import org.jetbrains.kotlinx.dataframe.impl.columns.addPath
 import org.jetbrains.kotlinx.dataframe.impl.io.resizeKeepingAspectRatio
 import org.jetbrains.kotlinx.dataframe.impl.renderType
@@ -161,7 +164,11 @@ internal fun AnyFrame.toHtmlData(
     val scripts = mutableListOf<String>()
     val queue = LinkedList<RenderingQueueItem>()
 
-    fun AnyFrame.columnToJs(col: AnyCol, rowsLimit: Int?, configuration: DisplayConfiguration): ColumnDataForJs {
+    fun AnyFrame.columnToJs(
+        col: ColumnWithPath<*>,
+        rowsLimit: Int?,
+        configuration: DisplayConfiguration,
+    ): ColumnDataForJs {
         val values = if (rowsLimit != null) rows().take(rowsLimit) else rows()
         val scale = if (col.isNumber()) col.asNumbers().scale() else 1
         val format = if (scale > 0) {
@@ -170,23 +177,40 @@ internal fun AnyFrame.toHtmlData(
             RendererDecimalFormat.of("%e")
         }
         val renderConfig = configuration.copy(decimalFormat = format)
-        val contents = values.map {
-            val value = col[it]
-            val content = value.toDataFrameLikeOrNull()
-            if (content != null) {
-                val df = content.df()
+        val contents = values.map { row ->
+            val value = col[row]
+            val dfLikeContent = value.toDataFrameLikeOrNull()
+            if (dfLikeContent != null) {
+                val df = dfLikeContent.df()
                 if (df.isEmpty()) {
                     HtmlContent("", null)
                 } else {
                     val id = nextTableId()
-                    queue += RenderingQueueItem(df, id, content.configuration(defaultConfiguration))
+                    queue += RenderingQueueItem(df, id, dfLikeContent.configuration(defaultConfiguration))
                     DataFrameReference(id, df.size)
                 }
             } else {
-                val html =
-                    formatter.format(downsizeBufferedImageIfNeeded(value, renderConfig), cellRenderer, renderConfig)
-                val style = renderConfig.cellFormatter
-                    ?.invoke(FormattingDsl, it, col)
+                val html = formatter.format(
+                    value = downsizeBufferedImageIfNeeded(value, renderConfig),
+                    renderer = cellRenderer,
+                    configuration = renderConfig,
+                )
+
+                val formatter = renderConfig.cellFormatter
+                    ?: return@map HtmlContent(html, null)
+
+                // ask formatter for all attributes defined for this cell or any of its parents (outer column groups)
+                val parentCols = col.path.indices
+                    .map { i -> col.path.take(i + 1) }
+                    .dropLast(1)
+                    .map { ColumnWithPath(this@toHtmlData[it], it) }
+                val parentAttributes = parentCols
+                    .map { formatter(FormattingDsl, row, it) }
+                    .reduceOrNull(CellAttributes?::and)
+
+                val cellAttributes = formatter(FormattingDsl, row, col)
+
+                val style = (parentAttributes and cellAttributes)
                     ?.attributes()
                     ?.ifEmpty { null }
                     ?.flatMap {
@@ -204,12 +228,16 @@ internal fun AnyFrame.toHtmlData(
                             listOf(it)
                         }
                     }
-                    ?.joinToString(";") { "${it.first}:${it.second}" }
+                    ?.toMap() // removing duplicate keys, allowing only the final one to be applied
+                    ?.entries
+                    ?.joinToString(";") { "${it.key}:${it.value}" }
                 HtmlContent(html, style)
             }
         }
         val nested = if (col is ColumnGroup<*>) {
-            col.columns().map { col.columnToJs(it, rowsLimit, configuration) }
+            col.columns().map {
+                col.columnToJs(it.addParentPath(col.path), rowsLimit, configuration)
+            }
         } else {
             emptyList()
         }
@@ -226,7 +254,9 @@ internal fun AnyFrame.toHtmlData(
     while (!queue.isEmpty()) {
         val (nextDf, nextId, configuration) = queue.pop()
         val rowsLimit = if (nextId == rootId) configuration.rowsLimit else configuration.nestedRowsLimit
-        val preparedColumns = nextDf.columns().map { nextDf.columnToJs(it, rowsLimit, configuration) }
+        val preparedColumns = nextDf.columns().map {
+            nextDf.columnToJs(it.addPath(), rowsLimit, configuration)
+        }
         val js = tableJs(preparedColumns, nextId, rootId, nextDf.nrow)
         scripts.add(js)
     }