DOPE-294: Bump kotlin to 2.1 and update linter

core/build.gradle.kts

@@ -1,6 +1,6 @@
 plugins {
-    kotlin("jvm") version "1.9.22"
-    id("org.jlleitschuh.gradle.ktlint") version "11.5.1"
+    kotlin("jvm") version "2.1.0"
+    id("org.jlleitschuh.gradle.ktlint") version "12.1.1"
     `maven-publish`
     idea
 }

core/src/main/kotlin/ch/ergon/dope/DopeParameters.kt

@@ -16,16 +16,19 @@ data class DopeParameters(
      * Merges multiple instances of DopeParameters, so that the receiver instance of [DopeParameters]
      * is the first in the order of merging.
      */
-    fun merge(vararg otherParameters: DopeParameters?) = this.copy(
-        namedParameters = otherParameters.filterNotNull()
-            .fold(this.namedParameters) { namedParams, additionalNamedParams ->
-                namedParams + additionalNamedParams.namedParameters
-            },
-        positionalParameters = otherParameters.filterNotNull()
-            .fold(this.positionalParameters) { positionalParams, additionalPositionalParams ->
-                positionalParams + additionalPositionalParams.positionalParameters
-            },
-    )
+    fun merge(vararg otherParameters: DopeParameters?) =
+        this.copy(
+            namedParameters =
+                otherParameters.filterNotNull()
+                    .fold(this.namedParameters) { namedParams, additionalNamedParams ->
+                        namedParams + additionalNamedParams.namedParameters
+                    },
+            positionalParameters =
+                otherParameters.filterNotNull()
+                    .fold(this.positionalParameters) { positionalParams, additionalPositionalParams ->
+                        positionalParams + additionalPositionalParams.positionalParameters
+                    },
+        )
 }
 
 fun List<DopeParameters>.merge(vararg otherParameters: DopeParameters?): DopeParameters =

core/src/main/kotlin/ch/ergon/dope/QueryBuilder.kt

@@ -16,16 +16,22 @@ import ch.ergon.dope.resolvable.expression.type.DopeVariable
 import ch.ergon.dope.validtype.ValidType
 
 object QueryBuilder : QueryProvider {
-    fun with(variable: DopeVariable<out ValidType>, vararg additionalVariables: DopeVariable<out ValidType>) =
-        WithClause(variable, additionalVariables.toList())
+    fun with(
+        variable: DopeVariable<out ValidType>,
+        vararg additionalVariables: DopeVariable<out ValidType>,
+    ) = WithClause(variable, additionalVariables.toList())
 
-    override fun select(expression: Selectable, vararg expressions: Selectable) =
-        SelectClause(expression, expressions.toList())
+    override fun select(
+        expression: Selectable,
+        vararg expressions: Selectable,
+    ) = SelectClause(expression, expressions.toList())
 
     override fun selectAsterisk() = SelectClause(asterisk())
 
-    override fun selectDistinct(expression: Selectable, vararg expressions: Selectable) =
-        SelectDistinctClause(expression, expressions.toList())
+    override fun selectDistinct(
+        expression: Selectable,
+        vararg expressions: Selectable,
+    ) = SelectDistinctClause(expression, expressions.toList())
 
     override fun <T : ValidType> selectRaw(expression: Expression<T>) = SelectRawClause(expression)
 

core/src/main/kotlin/ch/ergon/dope/QueryProvider.kt

@@ -11,11 +11,17 @@ import ch.ergon.dope.validtype.ObjectType
 import ch.ergon.dope.validtype.ValidType
 
 interface QueryProvider {
-    fun select(expression: Selectable, vararg expressions: Selectable): SelectClause
+    fun select(
+        expression: Selectable,
+        vararg expressions: Selectable,
+    ): SelectClause
 
     fun selectAsterisk(): SelectClause
 
-    fun selectDistinct(expression: Selectable, vararg expressions: Selectable): SelectDistinctClause
+    fun selectDistinct(
+        expression: Selectable,
+        vararg expressions: Selectable,
+    ): SelectDistinctClause
 
     fun <T : ValidType> selectRaw(expression: Expression<T>): SelectRawClause<T>
 

core/src/main/kotlin/ch/ergon/dope/resolvable/bucket/Bucket.kt

@@ -16,6 +16,7 @@ interface Bucket : Fromable, Joinable, Nestable, Deletable, Updatable, SingleExp
 
 data class BucketScope(val name: String, val collection: ScopeCollection? = null) {
     fun withCollection(collectionName: String) = copy(collection = ScopeCollection(collectionName))
+
     fun withCollection(collection: ScopeCollection) = copy(collection = collection)
 }
 
@@ -30,8 +31,11 @@ data class UnaliasedBucket(
     fun withScope(scopeName: String) = copy(scope = BucketScope(scopeName))
 
     fun withScope(scope: BucketScope) = copy(scope = scope)
-    fun withScopeAndCollection(scopeName: String, collectionName: String) =
-        copy(scope = BucketScope(scopeName, ScopeCollection(collectionName)))
+
+    fun withScopeAndCollection(
+        scopeName: String,
+        collectionName: String,
+    ) = copy(scope = BucketScope(scopeName, ScopeCollection(collectionName)))
 }
 
 open class AliasedBucket(

core/src/main/kotlin/ch/ergon/dope/resolvable/bucket/UseKeys.kt

@@ -13,18 +13,23 @@ import ch.ergon.dope.validtype.StringType
 import ch.ergon.dope.validtype.ValidType
 import kotlin.collections.Collection
 
+@Suppress("ktlint:standard:function-naming")
 data class UseKeysClass private constructor(
     val useKeys: TypeExpression<out ValidType>,
     val bucket: Bucket,
 ) : Joinable, Deletable, Updatable, Fromable {
     companion object {
         @JvmName("singleUseKeysClauseConstructor")
-        fun UseKeys(key: TypeExpression<StringType>, bucket: Bucket) =
-            UseKeysClass(key, bucket)
+        fun UseKeys(
+            key: TypeExpression<StringType>,
+            bucket: Bucket,
+        ) = UseKeysClass(key, bucket)
 
         @JvmName("multipleUseKeysClauseConstructor")
-        fun UseKeys(keys: TypeExpression<ArrayType<StringType>>, bucket: Bucket) =
-            UseKeysClass(keys, bucket)
+        fun UseKeys(
+            keys: TypeExpression<ArrayType<StringType>>,
+            bucket: Bucket,
+        ) = UseKeysClass(keys, bucket)
     }
 }
 
@@ -42,11 +47,14 @@ fun Bucket.useKeys(keys: Collection<TypeExpression<StringType>>) = useKeys(keys.
 @JvmName("useKeysStringCollection")
 fun Bucket.useKeys(keys: Collection<String>) = useKeys(keys.toDopeType())
 
-fun Bucket.useKeys(firstKey: String, secondKey: String, vararg additionalKeys: String) =
-    useKeys(
-        listOf(
-            firstKey.toDopeType(),
-            secondKey.toDopeType(),
-            *additionalKeys.map { it.toDopeType() }.toTypedArray(),
-        ).toDopeType(),
-    )
+fun Bucket.useKeys(
+    firstKey: String,
+    secondKey: String,
+    vararg additionalKeys: String,
+) = useKeys(
+    listOf(
+        firstKey.toDopeType(),
+        secondKey.toDopeType(),
+        *additionalKeys.map { it.toDopeType() }.toTypedArray(),
+    ).toDopeType(),
+)

core/src/main/kotlin/ch/ergon/dope/resolvable/clause/IDeleteClause.kt

@@ -21,8 +21,10 @@ import ch.ergon.dope.validtype.ValidType
 interface IDeleteReturningClause : Clause
 
 interface IDeleteOffsetClause : IDeleteReturningClause {
-    fun returning(returningExpression: Returnable, vararg additionalReturningExpressions: Returnable) =
-        DeleteReturningClause(returningExpression, additionalReturningExpressions.toList(), parentClause = this)
+    fun returning(
+        returningExpression: Returnable,
+        vararg additionalReturningExpressions: Returnable,
+    ) = DeleteReturningClause(returningExpression, additionalReturningExpressions.toList(), parentClause = this)
 
     fun returningAsterisk(bucket: Bucket? = null) = DeleteReturningClause(asterisk(bucket), parentClause = this)
 
@@ -38,11 +40,13 @@ interface IDeleteOffsetClause : IDeleteReturningClause {
 
 interface IDeleteLimitClause : IDeleteOffsetClause {
     fun offset(numberExpression: TypeExpression<NumberType>) = DeleteOffsetClause(numberExpression, this)
+
     fun offset(number: Number) = offset(number.toDopeType())
 }
 
 interface IDeleteWhereClause : IDeleteLimitClause {
     fun limit(numberExpression: TypeExpression<NumberType>) = DeleteLimitClause(numberExpression, this)
+
     fun limit(number: Number) = limit(number.toDopeType())
 }