Merge branch 'master' into mean

# Conflicts:
#	core/api/core.api

Author: Jolanrensen

CONTRIBUTING.md

@@ -90,9 +90,6 @@ so do familiarize yourself with the following guidelines.
   * Note, any version above 21 should work in theory, but JDK 21 is the only version we test with,
   so it is the recommended version.
 
-* JDK == 11 referred to by the `JDK_11_0` environment variable or `gradle.properties`/`local.properties`.
-  * This is used for testing our compiler plugins.
-
 * We recommend using [IntelliJ IDEA](https://www.jetbrains.com/idea/download/) as the IDE. This
 has the best support for Kotlin, compiler plugins, Gradle, and [Kotlin Notebook](https://kotlinlang.org/docs/kotlin-notebook-overview.html) of course.
 

build.gradle.kts

@@ -136,22 +136,46 @@ tasks.named<DependencyUpdatesTask>("dependencyUpdates").configure {
 kotlin {
     jvmToolchain(21)
     compilerOptions {
-        jvmTarget = JvmTarget.JVM_11
+        jvmTarget = JvmTarget.JVM_1_8
     }
 }
 
+// DataFrame targets Java 8 for maximum compatibility.
+// This is, however, not always possible thanks to external dependencies.
+// In those cases, we default to Java 11.
+val modulesUsingJava11 = with(projects) {
+    setOf(
+        dataframeJupyter,
+        dataframeGeo,
+        examples.ideaExamples.titanic,
+    )
+}.map { it.path }
+
 allprojects {
-    tasks.withType<KotlinCompile> {
-        compilerOptions {
-            jvmTarget = JvmTarget.JVM_11
-            freeCompilerArgs.add("-Xjdk-release=11")
+    if (path in modulesUsingJava11) {
+        tasks.withType<KotlinCompile> {
+            compilerOptions {
+                jvmTarget = JvmTarget.JVM_11
+                freeCompilerArgs.add("-Xjdk-release=11")
+            }
+        }
+        tasks.withType<JavaCompile> {
+            sourceCompatibility = JavaVersion.VERSION_11.toString()
+            targetCompatibility = JavaVersion.VERSION_11.toString()
+            options.release.set(11)
+        }
+    } else {
+        tasks.withType<KotlinCompile> {
+            compilerOptions {
+                jvmTarget = JvmTarget.JVM_1_8
+                freeCompilerArgs.add("-Xjdk-release=8")
+            }
+        }
+        tasks.withType<JavaCompile> {
+            sourceCompatibility = JavaVersion.VERSION_1_8.toString()
+            targetCompatibility = JavaVersion.VERSION_1_8.toString()
+            options.release.set(8)
         }
-    }
-
-    tasks.withType<JavaCompile> {
-        sourceCompatibility = JavaVersion.VERSION_11.toString()
-        targetCompatibility = JavaVersion.VERSION_11.toString()
-        options.release.set(11)
     }
 
     // Attempts to configure ktlint for each sub-project that uses the plugin

core/api/core.api

@@ -1777,13 +1777,12 @@ public final class org/jetbrains/kotlinx/dataframe/api/DataColumnArithmeticsKt {
 }
 
 public final class org/jetbrains/kotlinx/dataframe/api/DataColumnTypeKt {
+	public static final fun isBigNumber (Lorg/jetbrains/kotlinx/dataframe/DataColumn;)Z
 	public static final fun isColumnGroup (Lorg/jetbrains/kotlinx/dataframe/DataColumn;)Z
 	public static final fun isComparable (Lorg/jetbrains/kotlinx/dataframe/DataColumn;)Z
 	public static final fun isFrameColumn (Lorg/jetbrains/kotlinx/dataframe/DataColumn;)Z
 	public static final fun isList (Lorg/jetbrains/kotlinx/dataframe/DataColumn;)Z
 	public static final fun isNumber (Lorg/jetbrains/kotlinx/dataframe/DataColumn;)Z
-	public static final fun isPrimitive (Lorg/jetbrains/kotlinx/dataframe/DataColumn;)Z
-	public static final fun isPrimitiveNumber (Lorg/jetbrains/kotlinx/dataframe/DataColumn;)Z
 	public static final fun isSubtypeOf (Lorg/jetbrains/kotlinx/dataframe/DataColumn;Lkotlin/reflect/KType;)Z
 	public static final fun isValueColumn (Lorg/jetbrains/kotlinx/dataframe/DataColumn;)Z
 	public static final fun valuesAreComparable (Lorg/jetbrains/kotlinx/dataframe/DataColumn;)Z
@@ -2843,6 +2842,8 @@ public final class org/jetbrains/kotlinx/dataframe/api/MeanKt {
 	public static synthetic fun meanFor$default (Lorg/jetbrains/kotlinx/dataframe/api/PivotGroupBy;[Ljava/lang/String;ZZILjava/lang/Object;)Lorg/jetbrains/kotlinx/dataframe/DataFrame;
 	public static synthetic fun meanFor$default (Lorg/jetbrains/kotlinx/dataframe/api/PivotGroupBy;[Lkotlin/reflect/KProperty;ZZILjava/lang/Object;)Lorg/jetbrains/kotlinx/dataframe/DataFrame;
 	public static synthetic fun meanFor$default (Lorg/jetbrains/kotlinx/dataframe/api/PivotGroupBy;[Lorg/jetbrains/kotlinx/dataframe/columns/ColumnReference;ZZILjava/lang/Object;)Lorg/jetbrains/kotlinx/dataframe/DataFrame;
+	public static final fun meanOrNull (Lorg/jetbrains/kotlinx/dataframe/DataColumn;Z)Ljava/lang/Double;
+	public static synthetic fun meanOrNull$default (Lorg/jetbrains/kotlinx/dataframe/DataColumn;ZILjava/lang/Object;)Ljava/lang/Double;
 	public static final fun rowMean (Lorg/jetbrains/kotlinx/dataframe/DataRow;Z)D
 	public static synthetic fun rowMean$default (Lorg/jetbrains/kotlinx/dataframe/DataRow;ZILjava/lang/Object;)D
 }
@@ -3966,7 +3967,6 @@ public final class org/jetbrains/kotlinx/dataframe/api/TypeConversionsKt {
 	public static final fun asComparable (Lorg/jetbrains/kotlinx/dataframe/DataColumn;)Lorg/jetbrains/kotlinx/dataframe/DataColumn;
 	public static final fun asComparable (Lorg/jetbrains/kotlinx/dataframe/columns/ColumnSet;)Lorg/jetbrains/kotlinx/dataframe/columns/ColumnSet;
 	public static final fun asComparable (Lorg/jetbrains/kotlinx/dataframe/columns/SingleColumn;)Lorg/jetbrains/kotlinx/dataframe/columns/SingleColumn;
-	public static final fun asComparableNullable (Lorg/jetbrains/kotlinx/dataframe/DataColumn;)Lorg/jetbrains/kotlinx/dataframe/DataColumn;
 	public static final fun asDataColumn (Lorg/jetbrains/kotlinx/dataframe/columns/ColumnGroup;)Lorg/jetbrains/kotlinx/dataframe/DataColumn;
 	public static final fun asDataColumn (Lorg/jetbrains/kotlinx/dataframe/columns/FrameColumn;)Lorg/jetbrains/kotlinx/dataframe/DataColumn;
 	public static final fun asDataFrame (Lorg/jetbrains/kotlinx/dataframe/DataColumn;)Lorg/jetbrains/kotlinx/dataframe/DataFrame;
@@ -5103,10 +5103,6 @@ public final class org/jetbrains/kotlinx/dataframe/impl/ExceptionUtilsKt {
 	public static final fun suggestIfNull (Ljava/lang/Object;Ljava/lang/String;)Ljava/lang/Object;
 }
 
-public final class org/jetbrains/kotlinx/dataframe/impl/NumberTypeUtilsKt {
-	public static final fun getPrimitiveNumberTypes ()Ljava/util/Set;
-}
-
 public final class org/jetbrains/kotlinx/dataframe/impl/TypeUtilsKt {
 	public static final fun getValuesType (Ljava/util/List;Lkotlin/reflect/KType;Lorg/jetbrains/kotlinx/dataframe/api/Infer;)Lkotlin/reflect/KType;
 	public static final synthetic fun guessValueType (Lkotlin/sequences/Sequence;Lkotlin/reflect/KType;Z)Lkotlin/reflect/KType;
@@ -5214,10 +5210,6 @@ public final class org/jetbrains/kotlinx/dataframe/impl/aggregation/modes/OfRowE
 	public static final fun aggregateOfDelegated (Lorg/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/Aggregator;Lorg/jetbrains/kotlinx/dataframe/api/Grouped;Ljava/lang/String;Lkotlin/jvm/functions/Function2;)Lorg/jetbrains/kotlinx/dataframe/DataFrame;
 }
 
-public final class org/jetbrains/kotlinx/dataframe/impl/aggregation/modes/RowKt {
-	public static final fun aggregateOfRow (Lorg/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/Aggregator;Lorg/jetbrains/kotlinx/dataframe/DataRow;Lkotlin/jvm/functions/Function2;)Ljava/lang/Object;
-}
-
 public final class org/jetbrains/kotlinx/dataframe/impl/aggregation/modes/WithinAllColumnsKt {
 	public static final fun aggregateAll (Lorg/jetbrains/kotlinx/dataframe/impl/aggregation/aggregators/Aggregator;Lorg/jetbrains/kotlinx/dataframe/DataFrame;Lkotlin/jvm/functions/Function2;)Ljava/lang/Object;
 }
@@ -5261,6 +5253,7 @@ public final class org/jetbrains/kotlinx/dataframe/impl/api/SchemaKt {
 public final class org/jetbrains/kotlinx/dataframe/impl/api/ToDataFrameKt {
 	public static final fun convertToDataFrame (Ljava/lang/Iterable;Lkotlin/reflect/KClass;Ljava/util/List;Ljava/util/Set;Ljava/util/Set;Ljava/util/Set;I)Lorg/jetbrains/kotlinx/dataframe/DataFrame;
 	public static final fun createDataFrameImpl (Ljava/lang/Iterable;Lkotlin/reflect/KClass;Lkotlin/jvm/functions/Function1;)Lorg/jetbrains/kotlinx/dataframe/DataFrame;
+	public static final fun getCanBeUnfolded (Lkotlin/reflect/KClass;)Z
 	public static final fun getHasProperties (Lkotlin/reflect/KClass;)Z
 	public static final fun isValueType (Lkotlin/reflect/KClass;)Z
 }

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

@@ -15,12 +15,10 @@ import org.jetbrains.kotlinx.dataframe.util.IS_COMPARABLE_REPLACE
 import org.jetbrains.kotlinx.dataframe.util.IS_INTER_COMPARABLE_IMPORT
 import kotlin.contracts.ExperimentalContracts
 import kotlin.contracts.contract
-import kotlin.reflect.KClass
 import kotlin.reflect.KType
 import kotlin.reflect.KTypeProjection
 import kotlin.reflect.KVariance
 import kotlin.reflect.full.createType
-import kotlin.reflect.full.isSubclassOf
 import kotlin.reflect.full.isSubtypeOf
 import kotlin.reflect.full.withNullability
 import kotlin.reflect.typeOf
@@ -91,13 +89,3 @@ public fun AnyCol.valuesAreComparable(): Boolean =
                 nullable = hasNulls(),
             ),
         )
-
-@PublishedApi
-internal fun AnyCol.isPrimitive(): Boolean = typeClass.isPrimitive()
-
-internal fun KClass<*>.isPrimitive(): Boolean =
-    isSubclassOf(Number::class) ||
-        this == String::class ||
-        this == Char::class ||
-        this == Array::class ||
-        isSubclassOf(Collection::class)

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

@@ -79,6 +79,8 @@ public fun <T> InsertClause<T>.under(column: String): DataFrame<T> = under(pathO
 
 // region after
 
+@Refine
+@Interpretable("InsertAfter0")
 public fun <T> InsertClause<T>.after(column: ColumnSelector<T, *>): DataFrame<T> = after(df.getColumnPath(column))
 
 public fun <T> InsertClause<T>.after(column: String): DataFrame<T> = df.add(this.column).move(this.column).after(column)

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

@@ -11,9 +11,8 @@ import org.jetbrains.kotlinx.dataframe.annotations.Interpretable
 import org.jetbrains.kotlinx.dataframe.annotations.Refine
 import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
 import org.jetbrains.kotlinx.dataframe.impl.ColumnNameGenerator
+import org.jetbrains.kotlinx.dataframe.impl.api.canBeUnfolded
 import org.jetbrains.kotlinx.dataframe.impl.api.createDataFrameImpl
-import org.jetbrains.kotlinx.dataframe.impl.api.hasProperties
-import org.jetbrains.kotlinx.dataframe.impl.api.isValueType
 import org.jetbrains.kotlinx.dataframe.impl.asList
 import org.jetbrains.kotlinx.dataframe.impl.columnName
 import org.jetbrains.kotlinx.dataframe.impl.columns.createColumnGuessingType
@@ -30,7 +29,7 @@ public inline fun <reified T> Iterable<T>.toDataFrame(): DataFrame<T> =
     toDataFrame {
         // check if type is value: primitives, primitive arrays, datetime types etc.,
         // or has no properties
-        if (T::class.isValueType || !T::class.hasProperties) {
+        if (!T::class.canBeUnfolded) {
             // create a single `value` column
             ValueProperty<T>::value from { it }
         } else {

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

@@ -8,6 +8,7 @@ import org.jetbrains.kotlinx.dataframe.DataFrame
 import org.jetbrains.kotlinx.dataframe.annotations.AccessApiOverload
 import org.jetbrains.kotlinx.dataframe.columns.ColumnKind
 import org.jetbrains.kotlinx.dataframe.columns.toColumnSet
+import org.jetbrains.kotlinx.dataframe.impl.api.canBeUnfolded
 import org.jetbrains.kotlinx.dataframe.impl.api.createDataFrameImpl
 import org.jetbrains.kotlinx.dataframe.typeClass
 import kotlin.reflect.KProperty
@@ -17,7 +18,7 @@ public inline fun <reified T> DataColumn<T>.unfold(): AnyCol =
         ColumnKind.Group, ColumnKind.Frame -> this
 
         else -> when {
-            isPrimitive() -> this
+            !typeClass.canBeUnfolded -> this
 
             else -> values()
                 .createDataFrameImpl(typeClass) { (this as CreateDataFrameDsl<T>).properties() }

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

@@ -11,9 +11,11 @@ import org.jetbrains.kotlinx.dataframe.api.getColumn
 import org.jetbrains.kotlinx.dataframe.api.getColumnGroup
 import org.jetbrains.kotlinx.dataframe.api.getColumnWithPath
 import org.jetbrains.kotlinx.dataframe.api.toDataFrame
+import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
 import org.jetbrains.kotlinx.dataframe.columns.ColumnWithPath
 import org.jetbrains.kotlinx.dataframe.columns.UnresolvedColumnsPolicy
 import org.jetbrains.kotlinx.dataframe.impl.DataFrameReceiver
+import org.jetbrains.kotlinx.dataframe.impl.asList
 import org.jetbrains.kotlinx.dataframe.impl.columns.toColumnWithPath
 import org.jetbrains.kotlinx.dataframe.impl.columns.tree.ColumnPosition
 import org.jetbrains.kotlinx.dataframe.impl.columns.tree.getOrPut
@@ -23,20 +25,58 @@ internal fun <T, C> MoveClause<T, C>.afterOrBefore(column: ColumnSelector<T, *>,
     val removeResult = df.removeImpl(columns = columns)
 
     val targetPath = df.getColumnWithPath(column).path
+    val sourcePaths = removeResult.removedColumns.map { it.toColumnWithPath<C>().path }
+
+    // Check if any source path is a prefix of the target path
+    sourcePaths.forEach { sourcePath ->
+        val sourceSegments = sourcePath.toList()
+        val targetSegments = targetPath.toList()
+
+        if (sourceSegments.size <= targetSegments.size &&
+            sourceSegments.indices.all { targetSegments[it] == sourceSegments[it] }
+        ) {
+            throw IllegalArgumentException(
+                "Cannot move column '${sourcePath.joinToString()}' after its own child column '${targetPath.joinToString()}'",
+            )
+        }
+    }
+
     val removeRoot = removeResult.removedColumns.first().getRoot()
 
     val refNode = removeRoot.getOrPut(targetPath) {
-        val parentPath = it.dropLast(1)
-        val parent = if (parentPath.isEmpty()) df else df.getColumnGroup(parentPath)
-        val index = parent.getColumnIndex(it.last())
-        val col = df.getColumn(index)
+        val path = it.asList()
+
+        // Get parent of a target path
+        val effectivePath = path.dropLast(1)
+
+        // Get column name (last segment)
+        val columnName = path.last()
+
+        // Get the parent
+        val parent = if (effectivePath.isEmpty()) {
+            df
+        } else {
+            df.getColumnGroup(ColumnPath(effectivePath))
+        }
+
+        // Get the column index and the column itself
+        val index = parent.getColumnIndex(columnName)
+        val col = parent.getColumn(index)
+
         ColumnPosition(index, false, col)
     }
 
     val parentPath = targetPath.dropLast(1)
     val toInsert = removeResult.removedColumns.map {
-        val path = parentPath + it.name
-        ColumnToInsert(path, it.toColumnWithPath<C>().data, refNode)
+        val sourceCol = it.toColumnWithPath<C>()
+        val sourcePath = sourceCol.path
+        val path = if (sourcePath.size > 1) {
+            // If source is nested, preserve its structure under the target parent
+            parentPath + sourcePath.last()
+        } else {
+            parentPath + sourceCol.name()
+        }
+        ColumnToInsert(path, sourceCol.data, refNode)
     }
     return removeResult.df.insertImpl(toInsert)
 }

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

@@ -56,8 +56,24 @@ private val valueTypes = setOf(
     kotlinx.datetime.TimeZone::class,
     kotlinx.datetime.DateTimePeriod::class,
     kotlinx.datetime.DateTimeUnit::class,
+    Map::class,
+    MutableMap::class,
 )
 
+/**
+ * Determines whether a class can be unfolded into its properties.
+ *
+ * A class is considered **unfoldable** if it has at least one public property
+ * or getter-like function. This excludes:
+ * - **Value types** such as primitives, enums, and date-time types.
+ * - **Classes without properties**, including empty or marker classes.
+ *
+ * @return `true` if the class has unfoldable properties, `false` otherwise.
+ */
+@PublishedApi
+internal val KClass<*>.canBeUnfolded: Boolean
+    get() = (!this.isValueType) && this.hasProperties
+
 /**
  * Checks if `KClass` is a value type (number, datetime, string, etc.)
  * Should be aligned with `ConeKotlinType.isValueType()` in

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

@@ -1,6 +1,7 @@
 package org.jetbrains.kotlinx.dataframe.api
 
 import io.kotest.assertions.throwables.shouldNotThrowAny
+import io.kotest.assertions.throwables.shouldThrow
 import io.kotest.matchers.shouldBe
 import org.jetbrains.kotlinx.dataframe.columns.toColumnSet
 import org.junit.Test
@@ -91,4 +92,64 @@ class MoveTests {
             df.move("1").after("2") shouldBe dataFrameOf("2", "1")(2, 1)
         }
     }
+
+    @Test
+    fun `move after in nested structure`() {
+        val df = grouped.move { "a"["b"] }
+            .after { "a"["c"]["d"] }
+        df.columnNames() shouldBe listOf("q", "a", "b", "w", "e", "r")
+        df["a"].asColumnGroup().columnNames() shouldBe listOf("c")
+        df["a"]["c"].asColumnGroup().columnNames() shouldBe listOf("d", "b")
+    }
+
+    @Test
+    fun `move after multiple columns`() {
+        val df = grouped.move { "a"["b"] and "b"["c"] }
+            .after { "a"["c"]["d"] }
+        df.columnNames() shouldBe listOf("q", "a", "b", "w", "e", "r")
+        df["a"].asColumnGroup().columnNames() shouldBe listOf("c")
+        df["a"]["c"].asColumnGroup().columnNames() shouldBe listOf("d", "b", "c")
+        df["b"].asColumnGroup().columnNames() shouldBe listOf("d")
+    }
+
+    @Test
+    fun `move after with column selector`() {
+        val df = grouped.move { colsAtAnyDepth { it.name == "r" || it.name == "w" } }
+            .after { "a"["c"]["d"] }
+        df.columnNames() shouldBe listOf("q", "a", "b", "e")
+        df["a"]["c"].asColumnGroup().columnNames() shouldBe listOf("d", "w", "r")
+    }
+
+    @Test
+    fun `move after between groups`() {
+        val df = grouped.move { "a"["b"] }.after { "b"["c"] }
+        df.columnNames() shouldBe listOf("q", "a", "b", "w", "e", "r")
+        df["a"].asColumnGroup().columnNames() shouldBe listOf("c")
+        df["b"].asColumnGroup().columnNames() shouldBe listOf("c", "b", "d")
+    }
+
+    @Test
+    fun `should throw when moving parent after child`() {
+        // Simple case: direct parent-child relationship
+        shouldThrow<IllegalArgumentException> {
+            grouped.move("a").after { "a"["b"] }
+        }.message shouldBe "Cannot move column 'a' after its own child column 'a/b'"
+
+        // Nested case: deeper parent-child relationship
+        shouldThrow<IllegalArgumentException> {
+            grouped.move("a").after { "a"["c"]["d"] }
+        }.message shouldBe "Cannot move column 'a' after its own child column 'a/c/d'"
+
+        // Group case: moving group after its nested column
+        shouldThrow<IllegalArgumentException> {
+            grouped.move { "a"["c"] }.after { "a"["c"]["d"] }
+        }.message shouldBe "Cannot move column 'a/c' after its own child column 'a/c/d'"
+    }
+
+    @Test
+    fun `should throw when moving column after itself`() {
+        shouldThrow<IllegalArgumentException> {
+            grouped.move { "a"["b"] }.after { "a"["b"] }
+        }.message shouldBe "Cannot move column 'a/b' after its own child column 'a/b'"
+    }
 }