change fun name + linting + improve logic

Author: CarloMariaProietti

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

@@ -22,6 +22,7 @@ import org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns
 import org.jetbrains.kotlinx.dataframe.impl.api.afterOrBefore
 import org.jetbrains.kotlinx.dataframe.impl.api.moveImpl
 import org.jetbrains.kotlinx.dataframe.impl.api.moveTo
+import org.jetbrains.kotlinx.dataframe.impl.api.moveToImpl
 import org.jetbrains.kotlinx.dataframe.ncol
 import org.jetbrains.kotlinx.dataframe.util.DEPRECATED_ACCESS_API
 import org.jetbrains.kotlinx.dataframe.util.MOVE_TO_LEFT
@@ -560,7 +561,8 @@ public fun <T, C> MoveClause<T, C>.to(columnIndex: Int): DataFrame<T> = moveTo(c
  */
 @Refine
 @Interpretable("MoveTo")
-public fun <T, C> MoveClause<T, C>.to(columnIndex: Int, insideGroup: Boolean): DataFrame<T> = moveTo(columnIndex, insideGroup)
+public fun <T, C> MoveClause<T, C>.to(columnIndex: Int, insideGroup: Boolean): DataFrame<T> =
+    moveToImpl(columnIndex, insideGroup)
 
 /**
  * Moves columns, previously selected with [move] to the top-level within the [DataFrame].

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

@@ -129,7 +129,11 @@ internal fun <T, C> MoveClause<T, C>.moveTo(columnIndex: Int): DataFrame<T> {
     return newColumnList.toDataFrame().cast()
 }
 
-internal fun <T, C> MoveClause<T, C>.moveTo(columnIndex: Int, insideGroup: Boolean): DataFrame<T> {
+internal fun <T, C> MoveClause<T, C>.moveToImpl(columnIndex: Int, insideGroup: Boolean): DataFrame<T> {
+    if (!insideGroup) {
+        return moveTo(columnIndex)
+    }
+
     val columnsToMove = df.getColumns(columns)
 
     // check if columns to move have the same parent
@@ -142,7 +146,7 @@ internal fun <T, C> MoveClause<T, C>.moveTo(columnIndex: Int, insideGroup: Boole
     }
 
     // if columns will be moved to top level or columns to move are at top level
-    if (!insideGroup || parentOfFirst.isEmpty()) {
+    if (parentOfFirst.isEmpty()) {
         return moveTo(columnIndex)
     }
 
@@ -151,10 +155,10 @@ internal fun <T, C> MoveClause<T, C>.moveTo(columnIndex: Int, insideGroup: Boole
     val parentPath = df[parentOfFirst].path
     val referenceAndSiblings = df[parentOfFirst].asColumnGroup().columns()
     val referenceAndSiblingsPaths = referenceAndSiblings.map { parentPath + it.path }
-    val reference = if (columnIndex >= referenceAndSiblingsPaths.size){
+    val reference = if (columnIndex >= referenceAndSiblingsPaths.size) {
         referenceAndSiblingsPaths.last()
     } else {
-        referenceAndSiblingsPaths.get(columnIndex)
+        referenceAndSiblingsPaths[columnIndex]
     }
 
     // two cases : columns to move are before, or after, the reference
@@ -163,14 +167,15 @@ internal fun <T, C> MoveClause<T, C>.moveTo(columnIndex: Int, insideGroup: Boole
     val columnsToMovePath = columnsToMove.map { it.path }
     var referenceWasIterated = false
     referenceAndSiblingsPaths.forEach {
-        if (it.path.last() == reference.path.last())
+        if (it.path.last() == reference.path.last()) {
             referenceWasIterated = true
-        else {
-            if (columnsToMovePath.contains(it)){
-                if (referenceWasIterated)
+        } else {
+            if (columnsToMovePath.contains(it)) {
+                if (referenceWasIterated) {
                     columnsAfterReferenceToMove.add(it)
-                else
+                } else {
                     columnsBeforeReferenceToMove.add(it)
+                }
             }
         }
     }
@@ -182,10 +187,12 @@ internal fun <T, C> MoveClause<T, C>.moveTo(columnIndex: Int, insideGroup: Boole
         val finalDf = intermediateDf.move { columnsAfterReferenceToMove.toColumnSet() }.after { newReference }
         return finalDf
     }
-    if (columnsBeforeReferenceToMove.isNotEmpty())
+    if (columnsBeforeReferenceToMove.isNotEmpty()) {
         return df.move { columnsBeforeReferenceToMove.toColumnSet() }.after { reference }
-    if (columnsAfterReferenceToMove.isNotEmpty())
+    }
+    if (columnsAfterReferenceToMove.isNotEmpty()) {
         return df.move { columnsAfterReferenceToMove.toColumnSet() }.before { reference }
+    }
 
     // if it is not needed to move any of the nested columns
     return df

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

@@ -235,7 +235,7 @@ class MoveTests {
         df["b"].asColumnGroup().columnNames() shouldBe listOf("d", "c")
     }
 
-    //not working
+    // not working
     @Test
     fun `move single nested column between columns remaining inside the group`() {
         // creating an appropriate df for the test
@@ -275,7 +275,7 @@ class MoveTests {
     @Test
     fun `move multiple non bordering nested columns`() {
         // creating an appropriate df for the test
-        val groupedModified = grouped.move("r" , "q").before { "b"["c"] }
+        val groupedModified = grouped.move("r", "q").before { "b"["c"] }
         groupedModified["b"].asColumnGroup().columnNames() shouldBe listOf("r", "q", "c", "d")
         // test itself
         val df = groupedModified.move { "b"["r"] and "b"["d"] }.to(1, true)