add regular build workflow

0.5.7

.github/workflows/build.yml

@@ -0,0 +1,12 @@
+name: Regular build
+on: [push]
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-java@v1
+        with:
+          java-version: 1.8
+      - name: Build
+        run: ./gradlew build

CHANGELOG.md

@@ -1,5 +1,33 @@
 # Changelog
 
+## 0.5.8
+
+* `Common`:
+    * New extension `Iterable#firstNotNull`
+* `Coroutines`
+    * New extension `Flow#firstNotNull`
+    * New extensions `CoroutineContext#LinkedSupervisorJob`, `CoroutineScope#LinkedSupervisorJob` and
+      `CoroutineScope#LinkedSupervisorScope`
+
+## 0.5.7
+
+* `Pagination`
+    * `Ktor`
+        * `Server`
+            * Fixes in extension `extractPagination`
+* `Repos`
+    * `Cache`
+        * All standard cache repos have been separated to read and read/write repos
+
+## 0.5.6
+
+* `Versions`
+    * `Exposed`: `0.31.1` -> `0.32.1`
+* `Coroutines`
+    * `JVM`
+        * `launchSynchronously` and subsequent functions got improved mechanism
+    * New method `safelyWithResult`
+
 ## 0.5.5
 
 * `Versions`

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

@@ -0,0 +1,3 @@
+package dev.inmo.micro_utils.common
+
+fun <T> Iterable<T?>.firstNotNull() = first { it != null }!!

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

@@ -0,0 +1,6 @@
+package dev.inmo.micro_utils.coroutines
+
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.first
+
+suspend fun <T> Flow<T?>.firstNotNull() = first { it != null }!!

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

@@ -115,6 +115,10 @@ suspend inline fun <T> runCatchingSafely(
     safely(onException, block)
 }
 
+suspend inline fun <T> safelyWithResult(
+    noinline block: suspend CoroutineScope.() -> T
+): Result<T> = runCatchingSafely(defaultSafelyExceptionHandler, block)
+
 /**
  * Use this handler in cases you wish to include handling of exceptions by [defaultSafelyWithoutExceptionHandler] and
  * returning null at one time

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

@@ -0,0 +1,17 @@
+package dev.inmo.micro_utils.coroutines
+
+import kotlinx.coroutines.*
+import kotlin.coroutines.CoroutineContext
+
+fun CoroutineContext.LinkedSupervisorJob(
+    additionalContext: CoroutineContext? = null
+) = SupervisorJob(job).let { if (additionalContext != null) it + additionalContext else it }
+fun CoroutineScope.LinkedSupervisorJob(
+    additionalContext: CoroutineContext? = null
+) = coroutineContext.LinkedSupervisorJob(additionalContext)
+
+fun CoroutineScope.LinkedSupervisorScope(
+    additionalContext: CoroutineContext? = null
+) = CoroutineScope(
+    coroutineContext + LinkedSupervisorJob(additionalContext)
+)

coroutines/src/jvmMain/kotlin/dev/inmo/micro_utils/coroutines/LaunchSynchronously.kt

@@ -3,27 +3,21 @@ package dev.inmo.micro_utils.coroutines
 import kotlinx.coroutines.*
 
 fun <T> CoroutineScope.launchSynchronously(block: suspend CoroutineScope.() -> T): T {
-    val deferred = CompletableDeferred<T>()
+    var result: Result<T>? = null
-    val objectToSynchronize = java.lang.Object()
+    val objectToSynchronize = Object()
-    val launchCallback = {
+    synchronized(objectToSynchronize) {
         launch {
-            safely(
+            result = safelyWithResult(block)
-                {
+        }.invokeOnCompletion {
-                    deferred.completeExceptionally(it)
-                }
-            ) {
-                deferred.complete(block())
-            }
             synchronized(objectToSynchronize) {
                 objectToSynchronize.notifyAll()
             }
         }
+        while (result == null) {
+            objectToSynchronize.wait()
+        }
     }
-    synchronized(objectToSynchronize) {
+    return result!!.getOrThrow()
-        launchCallback()
-        objectToSynchronize.wait()
-    }
-    return deferred.getCompleted()
 }
 
 fun <T> launchSynchronously(block: suspend CoroutineScope.() -> T): T = CoroutineScope(Dispatchers.Default).launchSynchronously(block)

gradle.properties

@@ -10,7 +10,7 @@ org.gradle.jvmargs=-Xmx2g
 kotlin_version=1.5.10
 kotlin_coroutines_version=1.5.0
 kotlin_serialisation_core_version=1.2.1
-kotlin_exposed_version=0.31.1
+kotlin_exposed_version=0.32.1
 
 ktor_version=1.6.0
 
@@ -45,5 +45,5 @@ dokka_version=1.4.32
 # Project data
 
 group=dev.inmo
-version=0.5.5
+version=0.5.8
-android_code_version=46
+android_code_version=49

pagination/ktor/server/src/jvmMain/kotlin/dev/inmo/micro_utils/pagination/ServerPaginationHelpers.kt

@@ -5,8 +5,8 @@ import io.ktor.http.Parameters
 
 val Parameters.extractPagination: Pagination
     get() = SimplePagination(
-        get("page") ?.toIntOrNull() ?: 0,
+        get(paginationPageKey) ?.toIntOrNull() ?: 0,
-        get("size") ?.toIntOrNull() ?: defaultPaginationPageSize
+        get(paginationSizeKey) ?.toIntOrNull() ?: defaultPaginationPageSize
     )
 
 val ApplicationCall.extractPagination: Pagination

repos/cache/src/commonMain/kotlin/dev/inmo/micro_utils/repos/cache/CRUDCacheRepo.kt

@@ -6,19 +6,29 @@ import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.launchIn
 import kotlinx.coroutines.flow.onEach
 
-open class CRUDCacheRepo<ObjectType, IdType, InputValueType>(
+open class ReadCRUDCacheRepo<ObjectType, IdType>(
-    protected val parentRepo: CRUDRepo<ObjectType, IdType, InputValueType>,
+    protected val parentRepo: ReadCRUDRepo<ObjectType, IdType>,
     protected val kvCache: KVCache<IdType, ObjectType>,
-    scope: CoroutineScope = CoroutineScope(Dispatchers.Default),
     protected val idGetter: (ObjectType) -> IdType
-) : CRUDRepo<ObjectType, IdType, InputValueType> by parentRepo {
+) : ReadCRUDRepo<ObjectType, IdType> by parentRepo {
-    protected val onNewJob = parentRepo.newObjectsFlow.onEach { kvCache.set(idGetter(it), it) }.launchIn(scope)
-    protected val onUpdatedJob = parentRepo.updatedObjectsFlow.onEach { kvCache.set(idGetter(it), it) }.launchIn(scope)
-    protected val onRemoveJob = parentRepo.deletedObjectsIdsFlow.onEach { kvCache.unset(it) }.launchIn(scope)
-
     override suspend fun getById(id: IdType): ObjectType? = kvCache.get(id) ?: (parentRepo.getById(id) ?.also {
         kvCache.set(id, it)
     })
 
     override suspend fun contains(id: IdType): Boolean = kvCache.contains(id) || parentRepo.contains(id)
 }
+
+open class CRUDCacheRepo<ObjectType, IdType, InputValueType>(
+    parentRepo: CRUDRepo<ObjectType, IdType, InputValueType>,
+    kvCache: KVCache<IdType, ObjectType>,
+    scope: CoroutineScope = CoroutineScope(Dispatchers.Default),
+    idGetter: (ObjectType) -> IdType
+) : ReadCRUDCacheRepo<ObjectType, IdType>(
+    parentRepo,
+    kvCache,
+    idGetter
+), CRUDRepo<ObjectType, IdType, InputValueType>, WriteCRUDRepo<ObjectType, IdType, InputValueType> by parentRepo {
+    protected val onNewJob = parentRepo.newObjectsFlow.onEach { kvCache.set(idGetter(it), it) }.launchIn(scope)
+    protected val onUpdatedJob = parentRepo.updatedObjectsFlow.onEach { kvCache.set(idGetter(it), it) }.launchIn(scope)
+    protected val onRemoveJob = parentRepo.deletedObjectsIdsFlow.onEach { kvCache.unset(it) }.launchIn(scope)
+}

repos/cache/src/commonMain/kotlin/dev/inmo/micro_utils/repos/cache/KeyValueCacheRepo.kt

@@ -7,14 +7,19 @@ import kotlinx.coroutines.flow.*
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
 
-open class KeyValueCacheRepo<Key,Value>(
+open class ReadKeyValueCacheRepo<Key,Value>(
-    protected val parentRepo: KeyValueRepo<Key, Value>,
+    protected val parentRepo: ReadKeyValueRepo<Key, Value>,
     protected val kvCache: KVCache<Key, Value>,
-    scope: CoroutineScope = CoroutineScope(Dispatchers.Default)
+) : ReadKeyValueRepo<Key,Value> by parentRepo {
-) : KeyValueRepo<Key,Value> by parentRepo {
-    protected val onNewJob = parentRepo.onNewValue.onEach { kvCache.set(it.first, it.second) }.launchIn(scope)
-    protected val onRemoveJob = parentRepo.onValueRemoved.onEach { kvCache.unset(it) }.launchIn(scope)
-
     override suspend fun get(k: Key): Value? = kvCache.get(k) ?: parentRepo.get(k) ?.also { kvCache.set(k, it) }
     override suspend fun contains(key: Key): Boolean = kvCache.contains(key) || parentRepo.contains(key)
 }
+
+open class KeyValueCacheRepo<Key,Value>(
+    parentRepo: KeyValueRepo<Key, Value>,
+    kvCache: KVCache<Key, Value>,
+    scope: CoroutineScope = CoroutineScope(Dispatchers.Default)
+) : ReadKeyValueCacheRepo<Key,Value>(parentRepo, kvCache), KeyValueRepo<Key,Value>, WriteKeyValueRepo<Key, Value> by parentRepo {
+    protected val onNewJob = parentRepo.onNewValue.onEach { kvCache.set(it.first, it.second) }.launchIn(scope)
+    protected val onRemoveJob = parentRepo.onValueRemoved.onEach { kvCache.unset(it) }.launchIn(scope)
+}

repos/cache/src/commonMain/kotlin/dev/inmo/micro_utils/repos/cache/KeyValuesCacheRepo.kt

@@ -11,15 +11,10 @@ import kotlinx.coroutines.flow.*
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
 
-open class KeyValuesCacheRepo<Key,Value>(
+open class ReadKeyValuesCacheRepo<Key,Value>(
-    protected val parentRepo: KeyValuesRepo<Key, Value>,
+    protected val parentRepo: ReadKeyValuesRepo<Key, Value>,
-    protected val kvCache: KVCache<Key, List<Value>>,
+    protected val kvCache: KVCache<Key, List<Value>>
-    scope: CoroutineScope = CoroutineScope(Dispatchers.Default)
+) : ReadKeyValuesRepo<Key,Value> by parentRepo {
-) : KeyValuesRepo<Key,Value> by parentRepo {
-    protected val onNewJob = parentRepo.onNewValue.onEach { kvCache.set(it.first, kvCache.get(it.first) ?.plus(it.second) ?: listOf(it.second)) }.launchIn(scope)
-    protected val onRemoveJob = parentRepo.onValueRemoved.onEach { kvCache.set(it.first, kvCache.get(it.first) ?.minus(it.second) ?: return@onEach) }.launchIn(scope)
-    protected val onDataClearedJob = parentRepo.onDataCleared.onEach { kvCache.unset(it) }.launchIn(scope)
-
     override suspend fun get(k: Key, pagination: Pagination, reversed: Boolean): PaginationResult<Value> {
         return kvCache.get(k) ?.paginate(
             pagination.let { if (reversed) it.reverse(count(k)) else it }
@@ -35,3 +30,13 @@ open class KeyValuesCacheRepo<Key,Value>(
     override suspend fun contains(k: Key, v: Value): Boolean = kvCache.get(k) ?.contains(v) ?: parentRepo.contains(k, v)
     override suspend fun contains(k: Key): Boolean = kvCache.contains(k) || parentRepo.contains(k)
 }
+
+open class KeyValuesCacheRepo<Key,Value>(
+    parentRepo: KeyValuesRepo<Key, Value>,
+    kvCache: KVCache<Key, List<Value>>,
+    scope: CoroutineScope = CoroutineScope(Dispatchers.Default)
+) : ReadKeyValuesCacheRepo<Key,Value>(parentRepo, kvCache), KeyValuesRepo<Key,Value>, WriteKeyValuesRepo<Key,Value> by parentRepo {
+    protected val onNewJob = parentRepo.onNewValue.onEach { kvCache.set(it.first, kvCache.get(it.first) ?.plus(it.second) ?: listOf(it.second)) }.launchIn(scope)
+    protected val onRemoveJob = parentRepo.onValueRemoved.onEach { kvCache.set(it.first, kvCache.get(it.first) ?.minus(it.second) ?: return@onEach) }.launchIn(scope)
+    protected val onDataClearedJob = parentRepo.onDataCleared.onEach { kvCache.unset(it) }.launchIn(scope)
+}