removing includeGroups param from recursively

Author: Jolanrensen

core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/ColumnsSelectionDsl.kt

@@ -3951,7 +3951,6 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
      *
      * {@includeArg [CommonRecursivelyDocs.Examples]}
      *
-     * @param [includeGroups\] Whether to include [column groups][ColumnGroup] in the result. `true` by default.
      * @param [includeTopLevel\] Whether to include the top-level columns in the result. `true` by default.
      */
     private interface CommonRecursivelyDocs {
@@ -3985,17 +3984,15 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
      *
      * `df.`[select][DataFrame.select]` { `[colsOf][ColumnSet.colsOf]`<`[String][String]`>().`[recursively][recursively]`() }`
      *
-     * `df.`[select][DataFrame.select]` { myColumnGroup.`[all][ColumnSet.all]`().`[rec][rec]`(includeGroups = false) }`
+     * `df.`[select][DataFrame.select]` { myColumnGroup.`[all][ColumnSet.all]`().`[rec][rec]`() }`
      *
      * `df.`[select][DataFrame.select]` { `[groups][ColumnSet.groups]`().`[recursively][recursively]`(includeTopLevel = false) }`
      *
-     * @param [includeGroups] Whether to include [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] in the result. `true` by default.
      * @param [includeTopLevel] Whether to include the top-level columns in the result. `true` by default.
      */
     public fun <C> TransformableColumnSet<C>.recursively(
-        includeGroups: Boolean = true,
         includeTopLevel: Boolean = true,
-    ): ColumnSet<C> = recursivelyImpl(includeTopLevel = includeTopLevel, includeGroups = includeGroups)
+    ): ColumnSet<C> = recursivelyImpl(includeTopLevel = includeTopLevel, includeGroups = true)
 
     /** ## Recursively / Rec
      *
@@ -4021,17 +4018,15 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
      *
      * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[colsOf][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.colsOf]`<`[String][String]`>().`[recursively][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.recursively]`() }`
      *
-     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[all][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.all]`().`[rec][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.rec]`(includeGroups = false) }`
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { myColumnGroup.`[all][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.all]`().`[rec][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.rec]`() }`
      *
      * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[groups][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.groups]`().`[recursively][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.recursively]`(includeTopLevel = false) }`
      *
-     * @param [includeGroups] Whether to include [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] in the result. `true` by default.
      * @param [includeTopLevel] Whether to include the top-level columns in the result. `true` by default.
      */
     public fun <C> TransformableColumnSet<C>.rec(
-        includeGroups: Boolean = true,
         includeTopLevel: Boolean = true,
-    ): ColumnSet<C> = recursively(includeTopLevel = includeTopLevel, includeGroups = includeGroups)
+    ): ColumnSet<C> = recursively(includeTopLevel = includeTopLevel)
 
     /**
      * ## Recursively / Rec
@@ -4058,15 +4053,13 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
      *
      * `df.`[select][DataFrame.select]` { `[first][ColumnSet.first]` { col -> col.`[any][DataColumn.any]` { it == "Alice" } }.`[recursively][recursively]`(includeTopLevel = false) }`
      *
-     * `df.`[select][DataFrame.select]` { `[single][ColumnSet.single]` { it.name == "myCol" }.`[rec][rec]`(includeGroups = false) }`
+     * `df.`[select][DataFrame.select]` { `[single][ColumnSet.single]` { it.name == "myCol" }.`[rec][rec]`() }`
      *
-     * @param [includeGroups] Whether to include [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] in the result. `true` by default.
      * @param [includeTopLevel] Whether to include the top-level columns in the result. `true` by default.
      */
     public fun TransformableSingleColumn<*>.recursively(
-        includeGroups: Boolean = true,
         includeTopLevel: Boolean = true,
-    ): SingleColumn<*> = recursivelyImpl(includeTopLevel = includeTopLevel, includeGroups = includeGroups)
+    ): SingleColumn<*> = recursivelyImpl(includeTopLevel = includeTopLevel, includeGroups = true)
 
     /** ## Recursively / Rec
      *
@@ -4092,15 +4085,13 @@ public interface ColumnsSelectionDsl<out T> : ColumnSelectionDsl<T>, SingleColum
      *
      * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[first][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.first]` { col -> col.`[any][org.jetbrains.kotlinx.dataframe.DataColumn.any]` { it == "Alice" } }.`[recursively][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.recursively]`(includeTopLevel = false) }`
      *
-     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[single][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.single]` { it.name == "myCol" }.`[rec][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.rec]`(includeGroups = false) }`
+     * `df.`[select][org.jetbrains.kotlinx.dataframe.DataFrame.select]` { `[single][org.jetbrains.kotlinx.dataframe.columns.ColumnSet.single]` { it.name == "myCol" }.`[rec][org.jetbrains.kotlinx.dataframe.api.ColumnsSelectionDsl.rec]`() }`
      *
-     * @param [includeGroups] Whether to include [column groups][org.jetbrains.kotlinx.dataframe.columns.ColumnGroup] in the result. `true` by default.
      * @param [includeTopLevel] Whether to include the top-level columns in the result. `true` by default.
      */
     public fun TransformableSingleColumn<*>.rec(
-        includeGroups: Boolean = true,
         includeTopLevel: Boolean = true,
-    ): SingleColumn<*> = recursively(includeTopLevel = includeTopLevel, includeGroups = includeGroups)
+    ): SingleColumn<*> = recursively(includeTopLevel = includeTopLevel)
 
     /**
      * ## All Recursively / All Rec

core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/cumSum.kt

@@ -53,7 +53,7 @@ public fun <T> DataFrame<T>.cumSum(vararg columns: KProperty<*>, skipNA: Boolean
     cumSum(skipNA) { columns.toColumnSet() }
 
 public fun <T> DataFrame<T>.cumSum(skipNA: Boolean = defaultCumSumSkipNA): DataFrame<T> = cumSum(skipNA) {
-    all().recursively(includeGroups = false)
+    allRecursively(includeGroups = false)
 }
 
 // endregion
@@ -80,6 +80,6 @@ public fun <T, G> GroupBy<T, G>.cumSum(
 ): GroupBy<T, G> = cumSum(skipNA) { columns.toColumnSet() }
 
 public fun <T, G> GroupBy<T, G>.cumSum(skipNA: Boolean = defaultCumSumSkipNA): GroupBy<T, G> =
-    cumSum(skipNA) { all().recursively(includeGroups = false) }
+    cumSum(skipNA) { allRecursively(includeGroups = false) }
 
 // endregion

core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/describe.kt

@@ -39,7 +39,7 @@ public fun <T> DataColumn<T>.describe(): DataFrame<ColumnDescription> = describe
 
 // region DataFrame
 
-public fun <T> DataFrame<T>.describe(): DataFrame<ColumnDescription> = describe { all().recursively(includeGroups = false) }
+public fun <T> DataFrame<T>.describe(): DataFrame<ColumnDescription> = describe { allRecursively(includeGroups = false) }
 
 public fun <T> DataFrame<T>.describe(columns: ColumnsSelector<T, *>): DataFrame<ColumnDescription> =
     describeImpl(getColumnsWithPaths(columns))

core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/inferType.kt

@@ -14,7 +14,7 @@ public fun AnyCol.inferType(): DataColumn<*> = guessColumnType(name, toList(), t
 
 // region DataFrame
 
-public fun <T> DataFrame<T>.inferType(): DataFrame<T> = inferType { all().recursively(includeGroups = false) }
+public fun <T> DataFrame<T>.inferType(): DataFrame<T> = inferType { allRecursively(includeGroups = false) }
 
 public fun <T> DataFrame<T>.inferType(columns: ColumnsSelector<T, *>): DataFrame<T> =
     replace(columns).with { it.inferType() }

core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/parse.kt

@@ -56,7 +56,7 @@ public data class ParserOptions(
 public fun DataColumn<String?>.tryParse(options: ParserOptions? = null): DataColumn<*> = tryParseImpl(options)
 
 public fun <T> DataFrame<T>.parse(options: ParserOptions? = null): DataFrame<T> = parse(options) {
-    all().recursively(includeGroups = false)
+    allRecursively(includeGroups = false)
 }
 
 public fun DataColumn<String?>.parse(options: ParserOptions? = null): DataColumn<*> =

core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/rename.kt

@@ -49,7 +49,7 @@ public fun <T> DataFrame<T>.renameToCamelCase(): DataFrame<T> = this
     }.toCamelCase()
 
     .rename {
-        cols { it.name() matches DELIMITED_STRING_REGEX }.recursively(includeGroups = false)
+        cols { !it.isColumnGroup() && it.name() matches DELIMITED_STRING_REGEX }.recursively()
     }.toCamelCase()
 
     .update {

core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/reorder.kt

@@ -45,7 +45,7 @@ public fun <T, V : Comparable<V>> DataFrame<T>.reorderColumnsBy(
 ): DataFrame<T> =
     Reorder(
         df = this,
-        columns = { if (recursively) all().recursively() else all() },
+        columns = { if (recursively) allRecursively() else all() },
         inFrameColumns = recursively,
     ).reorderImpl(desc, expression)
 

core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/xs.kt

@@ -7,7 +7,7 @@ import org.jetbrains.kotlinx.dataframe.impl.api.xsImpl
 // region DataFrame
 
 public fun <T> DataFrame<T>.xs(vararg keyValues: Any?): DataFrame<T> = xs(*keyValues) {
-    all().recursively(includeGroups = false).take(keyValues.size)
+    allRecursively(includeGroups = false).take(keyValues.size)
 }
 
 public fun <T, C> DataFrame<T>.xs(vararg keyValues: C, keyColumns: ColumnsSelector<T, C>): DataFrame<T> =
@@ -18,7 +18,7 @@ public fun <T, C> DataFrame<T>.xs(vararg keyValues: C, keyColumns: ColumnsSelect
 // region GroupBy
 
 public fun <T, G> GroupBy<T, G>.xs(vararg keyValues: Any?): GroupBy<T, G> = xs(*keyValues) {
-    all().recursively(includeGroups = false).take(keyValues.size)
+    allRecursively(includeGroups = false).take(keyValues.size)
 }
 
 public fun <T, G, C> GroupBy<T, G>.xs(vararg keyValues: C, keyColumns: ColumnsSelector<T, C>): GroupBy<T, G> =

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

@@ -95,7 +95,7 @@ internal fun <T, G, R> aggregateGroupBy(
 
     if (!removeColumns) removedNode.data.wasRemoved = false
 
-    val columnsToInsert = groupedFrame.getColumnsWithPaths { all().recursively(includeGroups = false) }.map {
+    val columnsToInsert = groupedFrame.getColumnsWithPaths { allRecursively(includeGroups = false) }.map {
         ColumnToInsert(insertPath + it.path, it, removedNode)
     }
     val src = if (removeColumns) removed.df else df

core/generated-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/flatten.kt

@@ -27,7 +27,7 @@ internal fun <T, C> DataFrame<T>.flattenImpl(
     fun getRootPrefix(path: ColumnPath) =
         (1 until path.size).asSequence().map { path.take(it) }.first { rootPrefixes.contains(it) }
 
-    val result = move { rootPrefixes.toColumnSet().all().recursively(includeGroups = false, includeTopLevel = false) }
+    val result = move { rootPrefixes.toColumnSet().allRecursively(includeGroups = false, includeTopLevel = false) }
         .into {
             val targetPath = getRootPrefix(it.path).dropLast(1)
             val nameGen = nameGenerators[targetPath]!!