relaxing toDataFrame properties DSL to allow for getter functions too. If no memberProperties are available, fall back to getter-like memberFunctions. Also, it now tries to sort by any constructor if there are multiple (common in java with a no-arg constructor)

Jolanrensen · Jolanrensen · commit b82d08bce2bc · 2024-04-06T14:14:51.000+02:00
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/toDataFrame.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/toDataFrame.kt
@@ -13,6 +13,7 @@ import org.jetbrains.kotlinx.dataframe.impl.asList
 import org.jetbrains.kotlinx.dataframe.impl.columnName
 import org.jetbrains.kotlinx.dataframe.impl.columns.guessColumnType
 import org.jetbrains.kotlinx.dataframe.index
+import kotlin.reflect.KCallable
 import kotlin.reflect.KClass
 import kotlin.reflect.KProperty
 
@@ -115,24 +116,26 @@ public fun Iterable<Pair<String, Iterable<Any?>>>.toDataFrameFromPairs(): AnyFra
 public interface TraversePropertiesDsl {
 
     /**
-     * Skip given [classes] during recursive (dfs) traversal
+     * Skip given [classes] during recursive (dfs) traversal.
      */
     public fun exclude(vararg classes: KClass<*>)
 
     /**
-     * Skip given [properties] during recursive (dfs) traversal
+     * Skip given [properties] during recursive (dfs) traversal.
+     * These can also be getter-like functions.
      */
-    public fun exclude(vararg properties: KProperty<*>)
+    public fun exclude(vararg properties: KCallable<*>)
 
     /**
-     * Store given [classes] in ValueColumns without transformation into ColumnGroups or FrameColumns
+     * Store given [classes] in ValueColumns without transformation into ColumnGroups or FrameColumns.
      */
     public fun preserve(vararg classes: KClass<*>)
 
     /**
-     * Store given [properties] in ValueColumns without transformation into ColumnGroups or FrameColumns
+     * Store given [properties] in ValueColumns without transformation into ColumnGroups or FrameColumns.
+     * These can also be getter-like functions.
      */
-    public fun preserve(vararg properties: KProperty<*>)
+    public fun preserve(vararg properties: KCallable<*>)
 }
 
 public inline fun <reified T> TraversePropertiesDsl.preserve(): Unit = preserve(T::class)
@@ -148,7 +151,7 @@ public abstract class CreateDataFrameDsl<T> : TraversePropertiesDsl {
     public infix fun AnyBaseCol.into(path: ColumnPath): Unit = add(this, path)
 
     public abstract fun properties(
-        vararg roots: KProperty<*>,
+        vararg roots: KCallable<*>,
         maxDepth: Int = 0,
         body: (TraversePropertiesDsl.() -> Unit)? = null,
     )
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/MarkersExtractor.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/codeGen/MarkersExtractor.kt
@@ -4,7 +4,7 @@ import org.jetbrains.kotlinx.dataframe.DataFrame
 import org.jetbrains.kotlinx.dataframe.DataRow
 import org.jetbrains.kotlinx.dataframe.annotations.ColumnName
 import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
-import org.jetbrains.kotlinx.dataframe.impl.schema.getPropertiesOrder
+import org.jetbrains.kotlinx.dataframe.impl.schema.getPropertyOrderFromPrimaryConstructor
 import org.jetbrains.kotlinx.dataframe.schema.ColumnSchema
 import kotlin.reflect.KClass
 import kotlin.reflect.KType
@@ -53,7 +53,7 @@ internal object MarkersExtractor {
         }
 
     private fun getFields(markerClass: KClass<*>, nullableProperties: Boolean): List<GeneratedField> {
-        val order = getPropertiesOrder(markerClass)
+        val order = getPropertyOrderFromPrimaryConstructor(markerClass) ?: emptyMap()
         return markerClass.memberProperties.sortedBy { order[it.name] ?: Int.MAX_VALUE }.mapIndexed { _, it ->
             val fieldName = ValidFieldName.of(it.name)
             val columnName = it.findAnnotation<ColumnName>()?.name ?: fieldName.unquoted
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/Utils.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/Utils.kt
@@ -14,8 +14,9 @@ import org.jetbrains.kotlinx.dataframe.impl.columns.toColumnSet
 import org.jetbrains.kotlinx.dataframe.nrow
 import java.math.BigDecimal
 import java.math.BigInteger
+import kotlin.reflect.KCallable
 import kotlin.reflect.KClass
-import kotlin.reflect.KProperty
+import kotlin.reflect.KFunction
 import kotlin.reflect.KType
 import kotlin.reflect.KTypeProjection
 import kotlin.reflect.KVariance
@@ -338,4 +339,15 @@ internal fun List<String>.joinToCamelCaseString(): String {
 }
 
 @PublishedApi
-internal val <T> KProperty<T>.columnName: String get() = findAnnotation<ColumnName>()?.name ?: name
+internal val <T> KCallable<T>.columnName: String
+    get() = findAnnotation<ColumnName>()?.name
+        ?: when (this) {
+            // for defining the column names based on a getter-function, we use the function name minus the get/is prefix
+            is KFunction<*> ->
+                name
+                    .removePrefix("get")
+                    .removePrefix("is")
+                    .replaceFirstChar { it.lowercase() }
+
+            else -> name
+        }
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/toDataFrame.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/toDataFrame.kt
@@ -19,16 +19,20 @@ import org.jetbrains.kotlinx.dataframe.impl.columnName
 import org.jetbrains.kotlinx.dataframe.impl.emptyPath
 import org.jetbrains.kotlinx.dataframe.impl.getListType
 import org.jetbrains.kotlinx.dataframe.impl.projectUpTo
-import org.jetbrains.kotlinx.dataframe.impl.schema.getPropertiesOrder
+import org.jetbrains.kotlinx.dataframe.impl.schema.getPropertyOrderFromAnyConstructor
+import org.jetbrains.kotlinx.dataframe.impl.schema.getPropertyOrderFromPrimaryConstructor
 import java.lang.reflect.InvocationTargetException
 import java.lang.reflect.Method
 import java.time.temporal.Temporal
+import kotlin.reflect.KCallable
 import kotlin.reflect.KClass
 import kotlin.reflect.KProperty
 import kotlin.reflect.KVisibility
 import kotlin.reflect.full.isSubclassOf
+import kotlin.reflect.full.memberFunctions
 import kotlin.reflect.full.memberProperties
 import kotlin.reflect.full.primaryConstructor
+import kotlin.reflect.full.valueParameters
 import kotlin.reflect.full.withNullability
 import kotlin.reflect.jvm.isAccessible
 import kotlin.reflect.jvm.javaField
@@ -72,13 +76,13 @@ internal class CreateDataFrameDslImpl<T>(
 
     internal class TraverseConfiguration : TraversePropertiesDsl {
 
-        val excludeProperties = mutableSetOf<KProperty<*>>()
+        val excludeProperties = mutableSetOf<KCallable<*>>()
 
         val excludeClasses = mutableSetOf<KClass<*>>()
 
         val preserveClasses = mutableSetOf<KClass<*>>()
 
-        val preserveProperties = mutableSetOf<KProperty<*>>()
+        val preserveProperties = mutableSetOf<KCallable<*>>()
 
         fun clone(): TraverseConfiguration = TraverseConfiguration().also {
             it.excludeClasses.addAll(excludeClasses)
@@ -87,7 +91,7 @@ internal class CreateDataFrameDslImpl<T>(
             it.preserveClasses.addAll(preserveClasses)
         }
 
-        override fun exclude(vararg properties: KProperty<*>) {
+        override fun exclude(vararg properties: KCallable<*>) {
             excludeProperties.addAll(properties)
         }
 
@@ -99,12 +103,12 @@ internal class CreateDataFrameDslImpl<T>(
             preserveClasses.addAll(classes)
         }
 
-        override fun preserve(vararg properties: KProperty<*>) {
+        override fun preserve(vararg properties: KCallable<*>) {
             preserveProperties.addAll(properties)
         }
     }
 
-    override fun properties(vararg roots: KProperty<*>, maxDepth: Int, body: (TraversePropertiesDsl.() -> Unit)?) {
+    override fun properties(vararg roots: KCallable<*>, maxDepth: Int, body: (TraversePropertiesDsl.() -> Unit)?) {
         val dsl = configuration.clone()
         if (body != null) {
             body(dsl)
@@ -127,18 +131,47 @@ internal fun <T> Iterable<T>.createDataFrameImpl(clazz: KClass<*>, body: CreateD
 internal fun convertToDataFrame(
     data: Iterable<*>,
     clazz: KClass<*>,
-    roots: List<KProperty<*>>,
-    excludes: Set<KProperty<*>>,
+    roots: List<KCallable<*>>,
+    excludes: Set<KCallable<*>>,
     preserveClasses: Set<KClass<*>>,
-    preserveProperties: Set<KProperty<*>>,
-    maxDepth: Int
+    preserveProperties: Set<KCallable<*>>,
+    maxDepth: Int,
 ): AnyFrame {
-    val order = getPropertiesOrder(clazz)
+    val primaryConstructorOrder = getPropertyOrderFromPrimaryConstructor(clazz)
+    val anyConstructorOrder = getPropertyOrderFromAnyConstructor(clazz)
 
-    val properties = roots.ifEmpty {
-        clazz.memberProperties
-            .filter { it.visibility == KVisibility.PUBLIC && it.parameters.toList().size == 1 }
-    }.sortedBy { order[it.name] ?: Int.MAX_VALUE }
+    val properties: List<KCallable<*>> = roots
+        .ifEmpty {
+            clazz.memberProperties
+                .filter { it.visibility == KVisibility.PUBLIC && it.valueParameters.isEmpty() }
+        }
+
+        // fall back to getter functions for pojo-like classes
+        .ifEmpty {
+            clazz.memberFunctions
+                .filter {
+                    it.visibility == KVisibility.PUBLIC &&
+                        it.valueParameters.isEmpty() &&
+                        (it.name.startsWith("get") || it.name.startsWith("is"))
+                }
+        }
+
+        // sort properties by order of primary-ish constructor
+        .let {
+            val names = it.map { it.columnName }.toSet()
+
+            // use the primary constructor order if it's available,
+            // else try to find a constructor that matches all properties
+            val order = primaryConstructorOrder
+                ?: anyConstructorOrder.firstOrNull { map ->
+                    names.all { it in map.keys }
+                }
+            if (order != null) {
+                it.sortedBy { order[it.columnName] ?: Int.MAX_VALUE }
+            } else {
+                it
+            }
+        }
 
     val columns = properties.mapNotNull {
         val property = it
@@ -162,7 +195,7 @@ internal fun convertToDataFrame(
                 valueClassConverter
             }
         }
-        property.javaField?.isAccessible = true
+        (property as? KProperty<*>)?.javaField?.isAccessible = true
         property.isAccessible = true
 
         var nullable = false
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/schema/Utils.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/schema/Utils.kt
@@ -141,5 +141,18 @@ internal fun DataFrameSchema.createEmptyDataFrame(numberOfRows: Int): AnyFrame =
 internal fun createEmptyDataFrameOf(clazz: KClass<*>): AnyFrame =
     MarkersExtractor.get(clazz).schema.createEmptyDataFrame()
 
-internal fun getPropertiesOrder(clazz: KClass<*>): Map<String, Int> =
-    clazz.primaryConstructor?.parameters?.mapNotNull { it.name }?.mapIndexed { i, v -> v to i }?.toMap() ?: emptyMap()
+internal fun getPropertyOrderFromPrimaryConstructor(clazz: KClass<*>): Map<String, Int>? =
+    clazz.primaryConstructor
+        ?.parameters
+        ?.mapNotNull { it.name }
+        ?.mapIndexed { i, v -> v to i }
+        ?.toMap()
+
+internal fun getPropertyOrderFromAnyConstructor(clazz: KClass<*>): List<Map<String, Int>> =
+    clazz.constructors
+        .map { constructor ->
+            constructor.parameters
+                .mapNotNull { it.name }
+                .mapIndexed { i, v -> v to i }
+                .toMap()
+        }
