add pads and breakAsPairs extensions

hotfix due to deprecated annotation

CHANGELOG.md

@@ -1,5 +1,44 @@
 # Changelog
 
+## 0.22.8
+
+* `Common`:
+  * Add `List.breakAsPairs` extension
+  * Add `Sequence.padWith`/`Sequence.padStart`/`Sequence.padEnd` and `List.padWith`/`List.padStart`/`List.padEnd` extensions
+
+## 0.22.7
+
+* `Versions`:
+  * `Kotlin`: `2.0.20` -> `2.0.21`
+  * `Compose`: `1.7.0-rc01` -> `1.7.0`
+* `KSP`:
+  * `Sealed`:
+    * Change package of `GenerateSealedWorkaround`. Migration: replace `dev.inmo.microutils.kps.sealed.GenerateSealedWorkaround` -> `dev.inmo.micro_utils.ksp.sealed.GenerateSealedWorkaround`
+
+## 0.22.6
+
+* `KSP`:
+  * `Generator`:
+    * Add extension `KSClassDeclaration.buildSubFileName`
+    * Add extension `KSClassDeclaration.companion`
+    * Add extension `KSClassDeclaration.resolveSubclasses`
+  * `Sealed`:
+    * Improvements
+
+## 0.22.5
+
+* `Versions`:
+  * `Compose`: `1.7.0-beta02` -> `1.7.0-rc01`
+  * `SQLite`: `3.46.1.2` -> `3.46.1.3`
+  * `AndroidXFragment`: `1.8.3` -> `1.8.4`
+* `Common`:
+  * Add extension `withReplacedAt`/`withReplaced` ([#489](https://github.com/InsanusMokrassar/MicroUtils/issues/489))
+* `Coroutines`:
+  * Add extension `Flow.debouncedBy`
+* `Ktor`:
+  * `Server`:
+    * Add `KtorApplicationConfigurator.Routing.Static` as solution for [#488](https://github.com/InsanusMokrassar/MicroUtils/issues/488)
+
 ## 0.22.4
 
 * `Versions`:

common/src/commonMain/kotlin/dev/inmo/micro_utils/common/BreakAsPairs.kt

@@ -0,0 +1,13 @@
+package dev.inmo.micro_utils.common
+
+fun <T> List<T>.breakAsPairs(): List<Pair<T, T>> {
+    val result = mutableListOf<Pair<T, T>>()
+
+    for (i in 0 until size - 1) {
+        val first = get(i)
+        val second = get(i + 1)
+        result.add(first to second)
+    }
+
+    return result
+}

common/src/commonMain/kotlin/dev/inmo/micro_utils/common/PadExtensions.kt

@@ -0,0 +1,32 @@
+package dev.inmo.micro_utils.common
+
+inline fun <T> Sequence<T>.padWith(size: Int, inserter: (Sequence<T>) -> Sequence<T>): Sequence<T> {
+    var result = this
+    while (result.count() < size) {
+        result = inserter(result)
+    }
+    return result
+}
+
+inline fun <T> Sequence<T>.padEnd(size: Int, padBlock: (Int) -> T): Sequence<T> = padWith(size) { it + padBlock(it.count()) }
+
+inline fun <T> Sequence<T>.padEnd(size: Int, o: T) = padEnd(size) { o }
+
+inline fun <T> List<T>.padWith(size: Int, inserter: (List<T>) -> List<T>): List<T> {
+    var result = this
+    while (result.size < size) {
+        result = inserter(result)
+    }
+    return result
+}
+inline fun <T> List<T>.padEnd(size: Int, padBlock: (Int) -> T): List<T> = asSequence().padEnd(size, padBlock).toList()
+
+inline fun <T> List<T>.padEnd(size: Int, o: T): List<T> = asSequence().padEnd(size, o).toList()
+
+inline fun <T> Sequence<T>.padStart(size: Int, padBlock: (Int) -> T): Sequence<T> = padWith(size) { sequenceOf(padBlock(it.count())) + it }
+
+inline fun <T> Sequence<T>.padStart(size: Int, o: T) = padStart(size) { o }
+
+inline fun <T> List<T>.padStart(size: Int, padBlock: (Int) -> T): List<T> = asSequence().padStart(size, padBlock).toList()
+
+inline fun <T> List<T>.padStart(size: Int, o: T): List<T> = asSequence().padStart(size, o).toList()

common/src/commonMain/kotlin/dev/inmo/micro_utils/common/WithReplaced.kt

@@ -0,0 +1,5 @@
+package dev.inmo.micro_utils.common
+
+fun <T> Iterable<T>.withReplacedAt(i: Int, block: (T) -> T): List<T> = take(i) + block(elementAt(i)) + drop(i + 1)
+fun <T> Iterable<T>.withReplaced(t: T, block: (T) -> T): List<T> = withReplacedAt(indexOf(t), block)
+

common/src/commonTest/kotlin/dev/inmo/micro_utils/common/WithReplacedTest.kt

@@ -0,0 +1,21 @@
+package dev.inmo.micro_utils.common
+
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+class WithReplacedTest {
+    @Test
+    fun testReplaced() {
+        val data = 0 until 10
+        val testData = Int.MAX_VALUE
+
+        for (i in 0 until data.last) {
+            val withReplaced = data.withReplacedAt(i) {
+                testData
+            }
+            val dataAsMutableList = data.toMutableList()
+            dataAsMutableList[i] = testData
+            assertEquals(withReplaced, dataAsMutableList.toList())
+        }
+    }
+}

coroutines/src/commonMain/kotlin/dev/inmo/micro_utils/coroutines/FlowDebouncedBy.kt

@@ -0,0 +1,40 @@
+package dev.inmo.micro_utils.coroutines
+
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.async
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.*
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import kotlin.jvm.JvmInline
+import kotlin.time.Duration
+
+@JvmInline
+private value class DebouncedByData<T>(
+    val millisToData: Pair<Long, T>
+)
+
+fun <T> Flow<T>.debouncedBy(timeout: (T) -> Long, markerFactory: (T) -> Any?): Flow<T> = channelFlow {
+    val jobs = mutableMapOf<Any?, Job>()
+    val mutex = Mutex()
+    subscribe(this) {
+        mutex.withLock {
+            val marker = markerFactory(it)
+            lateinit var job: Job
+            job = async {
+                delay(timeout(it))
+                mutex.withLock {
+                    if (jobs[marker] === job) {
+                        this@channelFlow.send(it)
+                        jobs.remove(marker)
+                    }
+                }
+            }
+            jobs[marker] ?.cancel()
+            jobs[marker] = job
+        }
+    }
+}
+
+fun <T> Flow<T>.debouncedBy(timeout: Long, markerFactory: (T) -> Any?): Flow<T> = debouncedBy({ timeout }, markerFactory)
+fun <T> Flow<T>.debouncedBy(timeout: Duration, markerFactory: (T) -> Any?): Flow<T> = debouncedBy({ timeout.inWholeMilliseconds }, markerFactory)

coroutines/src/commonTest/kotlin/DebouncedByTests.kt

@@ -0,0 +1,42 @@
+import dev.inmo.micro_utils.coroutines.debouncedBy
+import kotlinx.coroutines.flow.asFlow
+import kotlinx.coroutines.test.runTest
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+
+class DebouncedByTests {
+    @Test
+    fun testThatParallelDebouncingWorksCorrectly() = runTest {
+        val dataToMarkerFactories = listOf(
+            1 to 0,
+            2 to 1,
+            3 to 2,
+            4 to 0,
+            5 to 1,
+            6 to 2,
+            7 to 0,
+            8 to 1,
+            9 to 2,
+        )
+
+        val collected = mutableListOf<Int>()
+
+        dataToMarkerFactories.asFlow().debouncedBy(10L) {
+            it.second
+        }.collect {
+            when (it.second) {
+                0 -> assertEquals(7, it.first)
+                1 -> assertEquals(8, it.first)
+                2 -> assertEquals(9, it.first)
+                else -> error("wtf")
+            }
+            collected.add(it.first)
+        }
+
+        val expectedList = listOf(7, 8, 9)
+        assertEquals(expectedList, collected)
+        assertTrue { collected.containsAll(expectedList) }
+        assertTrue { expectedList.containsAll(collected) }
+    }
+}

gradle.properties

@@ -15,5 +15,5 @@ crypto_js_version=4.1.1
 # Project data
 
 group=dev.inmo
-version=0.22.4
-android_code_version=270
+version=0.22.8
+android_code_version=274

gradle/libs.versions.toml

@@ -1,16 +1,16 @@
 [versions]
 
-kt = "2.0.20"
+kt = "2.0.21"
 kt-serialization = "1.7.3"
 kt-coroutines = "1.9.0"
 
 kslog = "1.3.6"
 
-jb-compose = "1.7.0-beta02"
+jb-compose = "1.7.0"
 jb-exposed = "0.55.0"
 jb-dokka = "1.9.20"
 
-sqlite = "3.46.1.2"
+sqlite = "3.46.1.3"
 
 korlibs = "5.4.0"
 uuid = "0.8.4"
@@ -23,7 +23,7 @@ koin = "4.0.0"
 
 okio = "3.9.1"
 
-ksp = "2.0.20-1.0.25"
+ksp = "2.0.21-1.0.25"
 kotlin-poet = "1.18.1"
 
 versions = "0.51.0"
@@ -34,7 +34,7 @@ dexcount = "4.0.0"
 android-coreKtx = "1.13.1"
 android-recyclerView = "1.3.2"
 android-appCompat = "1.7.0"
-android-fragment = "1.8.3"
+android-fragment = "1.8.4"
 android-espresso = "3.6.1"
 android-test = "1.2.1"
 android-compose-material3 = "1.3.0"

ksp/generator/src/main/kotlin/KSClassDeclarationBuildSubFileName.kt

@@ -0,0 +1,13 @@
+package dev.inmo.micro_ksp.generator
+
+import com.google.devtools.ksp.symbol.KSClassDeclaration
+
+val KSClassDeclaration.buildSubFileName: String
+    get() {
+        val parentDeclarationCaptured = parentDeclaration
+        val simpleNameString = simpleName.asString()
+        return when (parentDeclarationCaptured) {
+            is KSClassDeclaration -> parentDeclarationCaptured.buildSubFileName
+            else -> ""
+        } + simpleNameString
+    }

ksp/generator/src/main/kotlin/KSClassDeclarationCompanion.kt

@@ -0,0 +1,8 @@
+package dev.inmo.micro_ksp.generator
+
+import com.google.devtools.ksp.symbol.KSClassDeclaration
+
+val KSClassDeclaration.companion
+    get() = declarations.firstNotNullOfOrNull {
+        (it as? KSClassDeclaration)?.takeIf { it.isCompanionObject }
+    }

ksp/generator/src/main/kotlin/ResolveSubclasses.kt

@@ -0,0 +1,11 @@
+package dev.inmo.micro_ksp.generator
+
+import com.google.devtools.ksp.symbol.KSClassDeclaration
+
+fun KSClassDeclaration.resolveSubclasses(): List<KSClassDeclaration> {
+    return (getSealedSubclasses().flatMap {
+        it.resolveSubclasses()
+    }.ifEmpty {
+        sequenceOf(this)
+    }).toList()
+}

ksp/sealed/generator/src/main/kotlin/KSClassDeclarationGetGenerateSealedWorkaroundAnnotation.kt

@@ -0,0 +1,11 @@
+package dev.inmo.micro_utils.ksp.sealed.generator
+
+import com.google.devtools.ksp.KspExperimental
+import com.google.devtools.ksp.getAnnotationsByType
+import com.google.devtools.ksp.symbol.KSClassDeclaration
+import dev.inmo.micro_utils.ksp.sealed.GenerateSealedWorkaround
+import dev.inmo.microutils.kps.sealed.GenerateSealedWorkaround as OldGenerateSealedWorkaround
+
+@OptIn(KspExperimental::class)
+val KSClassDeclaration.getGenerateSealedWorkaroundAnnotation
+    get() = (getAnnotationsByType(GenerateSealedWorkaround::class).firstOrNull() ?: getAnnotationsByType(OldGenerateSealedWorkaround::class).firstOrNull())

ksp/sealed/generator/src/main/kotlin/Processor.kt

@@ -15,9 +15,11 @@ import com.squareup.kotlinpoet.ParameterizedTypeName.Companion.parameterizedBy
 import com.squareup.kotlinpoet.PropertySpec
 import com.squareup.kotlinpoet.asTypeName
 import com.squareup.kotlinpoet.ksp.toClassName
+import dev.inmo.micro_ksp.generator.buildSubFileName
+import dev.inmo.micro_ksp.generator.companion
 import dev.inmo.micro_ksp.generator.findSubClasses
 import dev.inmo.micro_ksp.generator.writeFile
-import dev.inmo.microutils.kps.sealed.GenerateSealedWorkaround
+import dev.inmo.micro_utils.ksp.sealed.GenerateSealedWorkaround
 import java.io.File
 
 class Processor(
@@ -51,10 +53,10 @@ class Processor(
         ksClassDeclaration: KSClassDeclaration,
         resolver: Resolver
     ) {
-        val annotation = ksClassDeclaration.getAnnotationsByType(GenerateSealedWorkaround::class).first()
+        val annotation = ksClassDeclaration.getGenerateSealedWorkaroundAnnotation
         val subClasses = ksClassDeclaration.resolveSubclasses(
             searchIn = resolver.getAllFiles(),
-            allowNonSealed = annotation.includeNonSealedSubTypes
+            allowNonSealed = annotation ?.includeNonSealedSubTypes ?: false
         ).distinct()
         val subClassesNames = subClasses.filter {
             when (it.classKind) {
@@ -93,7 +95,10 @@ class Processor(
         )
         addFunction(
             FunSpec.builder("values").apply {
-                receiver(ClassName(className.packageName, *className.simpleNames.toTypedArray(), "Companion"))
+                val companion = ksClassDeclaration.takeIf { it.isCompanionObject } ?.toClassName()
+                    ?: ksClassDeclaration.companion ?.toClassName()
+                    ?: ClassName(className.packageName, *className.simpleNames.toTypedArray(), "Companion")
+                receiver(companion)
                 returns(setType)
                 addCode(
                     CodeBlock.of(
@@ -107,7 +112,9 @@ class Processor(
     @OptIn(KspExperimental::class)
     override fun process(resolver: Resolver): List<KSAnnotated> {
         (resolver.getSymbolsWithAnnotation(GenerateSealedWorkaround::class.qualifiedName!!)).filterIsInstance<KSClassDeclaration>().forEach {
-            val prefix = it.getAnnotationsByType(GenerateSealedWorkaround::class).first().prefix
+            val prefix = (it.getGenerateSealedWorkaroundAnnotation) ?.prefix ?.takeIf {
+                it.isNotEmpty()
+            } ?: it.buildSubFileName.replaceFirst(it.simpleName.asString(), "")
             it.writeFile(prefix = prefix, suffix = "SealedWorkaround") {
                 FileSpec.builder(
                     it.packageName.asString(),

ksp/sealed/generator/test/src/commonMain/kotlin/Test.kt

@@ -1,6 +1,6 @@
 package dev.inmo.micro_utils.ksp.sealed.generator.test
 
-import dev.inmo.microutils.kps.sealed.GenerateSealedWorkaround
+import dev.inmo.micro_utils.ksp.sealed.GenerateSealedWorkaround
 
 @GenerateSealedWorkaround
 sealed interface Test {

ksp/sealed/src/commonMain/kotlin/GenerateSealedWorkaround.kt

@@ -1,4 +1,4 @@
-package dev.inmo.microutils.kps.sealed
+package dev.inmo.micro_utils.ksp.sealed
 
 @Retention(AnnotationRetention.BINARY)
 @Target(AnnotationTarget.CLASS)

ksp/sealed/src/commonMain/kotlin/OldGenerateSealedWorkaround.kt

@@ -0,0 +1,6 @@
+package dev.inmo.microutils.kps.sealed
+
+import dev.inmo.micro_utils.ksp.sealed.GenerateSealedWorkaround
+
+@Deprecated("Replaced", ReplaceWith("GenerateSealedWorkaround", "dev.inmo.micro_utils.ksp.sealed.GenerateSealedWorkaround"))
+typealias GenerateSealedWorkaround = GenerateSealedWorkaround

ktor/server/src/jvmMain/kotlin/dev/inmo/micro_utils/ktor/server/configurators/KtorApplicationConfigurator.kt

@@ -1,7 +1,101 @@
 package dev.inmo.micro_utils.ktor.server.configurators
 
-import io.ktor.server.application.Application
+import io.ktor.server.application.*
+import io.ktor.server.http.content.*
+import io.ktor.server.plugins.cachingheaders.*
+import io.ktor.server.plugins.statuspages.*
+import io.ktor.server.routing.*
+import io.ktor.server.sessions.*
+import kotlinx.serialization.Contextual
+import kotlinx.serialization.Serializable
+import java.io.File
 
 interface KtorApplicationConfigurator {
+    @Serializable
+    class Routing(
+        private val elements: List<@Contextual Element>
+    ) : KtorApplicationConfigurator {
+        fun interface Element { operator fun Route.invoke() }
+        private val rootInstaller = Element {
+            elements.forEach {
+                it.apply { invoke() }
+            }
+        }
+
+        override fun Application.configure() {
+            pluginOrNull(io.ktor.server.routing.Routing) ?.apply {
+                rootInstaller.apply { invoke() }
+            } ?: install(io.ktor.server.routing.Routing) {
+                rootInstaller.apply { invoke() }
+            }
+        }
+
+        /**
+         * @param pathToFolder Contains [Pair]s where firsts are paths in urls and seconds are folders file paths
+         * @param pathToResource Contains [Pair]s where firsts are paths in urls and seconds are packages in resources
+         */
+        class Static(
+            private val pathToFolder: List<Pair<String, String>> = emptyList(),
+            private val pathToResource: List<Pair<String, String>> = emptyList(),
+        ) : Element {
+            override fun Route.invoke() {
+                pathToFolder.forEach {
+                    staticFiles(
+                        it.first,
+                        File(it.second)
+                    )
+                }
+                pathToResource.forEach {
+                    staticResources(
+                        it.first,
+                        it.second
+                    )
+                }
+            }
+        }
+    }
+
+    class StatusPages(
+        private val elements: List<@Contextual Element>
+    ) : KtorApplicationConfigurator {
+        fun interface Element { operator fun StatusPagesConfig.invoke() }
+
+        override fun Application.configure() {
+            install(StatusPages) {
+                elements.forEach {
+                    it.apply { invoke() }
+                }
+            }
+        }
+    }
+
+    class Sessions(
+        private val elements: List<@Contextual Element>
+    ) : KtorApplicationConfigurator {
+        fun interface Element { operator fun SessionsConfig.invoke() }
+
+        override fun Application.configure() {
+            install(Sessions) {
+                elements.forEach {
+                    it.apply { invoke() }
+                }
+            }
+        }
+    }
+
+    class CachingHeaders(
+        private val elements: List<@Contextual Element>
+    ) : KtorApplicationConfigurator {
+        fun interface Element { operator fun CachingHeadersConfig.invoke() }
+
+        override fun Application.configure() {
+            install(CachingHeaders) {
+                elements.forEach {
+                    it.apply { invoke() }
+                }
+            }
+        }
+    }
+
     fun Application.configure()
 }