Merge pull request #50 from icerockdev/develop

Release 0.7.0

Author: Alex009

errors/build.gradle.kts

@@ -2,6 +2,8 @@
  * Copyright 2020 IceRock MAG Inc. Use of this source code is governed by the Apache 2.0 license.
  */
 
+import dev.icerock.gradle.tasks.GenerateMultiplatformResourcesTask
+
 plugins {
     id("dev.icerock.moko.gradle.multiplatform.mobile")
     id("kotlin-parcelize")
@@ -14,6 +16,10 @@ plugins {
 group = "dev.icerock.moko"
 version = libs.versions.mokoErrorsVersion.get()
 
+android {
+    namespace = "dev.icerock.moko.errors"
+}
+
 dependencies {
     commonMainImplementation(libs.coroutines)
 
@@ -28,3 +34,6 @@ multiplatformResources {
     multiplatformResourcesPackage = "dev.icerock.moko.errors"
 }
 
+tasks.withType<GenerateMultiplatformResourcesTask>().configureEach {
+    tasks.getByName("sourcesJar").dependsOn(this)
+}

errors/src/androidMain/AndroidManifest.xml

@@ -28,7 +28,7 @@ class AlertDialogFragment : DialogFragment() {
                 .setMessage(settings.messageText)
                 .setPositiveButton(settings.positiveButtonText) { _, _ -> }
                 .create()
-        } ?: throw IllegalStateException("Activity can't be null.")
+        } ?: error("Activity can't be null.")
     }
 
     @Parcelize

errors/src/androidMain/kotlin/dev/icerock/moko/errors/presenters/AlertDialogFragment.kt

@@ -39,13 +39,14 @@ internal class ExceptionHandlerContextImpl<T : Any, R>(
     override suspend fun execute(): HandlerResult<R, Throwable> {
         return try {
             HandlerResult.Success(block())
-        } catch (e: Exception) {
+        } catch (e: CancellationException) {
             // Don't handle coroutines CancellationException
-            if (e is CancellationException) throw e
+            throw e
+        } catch (e: Exception) {
             onCatch?.invoke(e)
-            val isHandled = isHandledByCustomCatcher(e)
+            val isHandled: Boolean = isHandledByCustomCatcher(e)
             if (!isHandled) { // If not handled by a custom catcher
-                val errorValue = exceptionMapper(e)
+                val errorValue: T = exceptionMapper(e)
                 eventsDispatcher.dispatchEvent {
                     showError(e, errorValue)
                 }

errors/src/commonMain/kotlin/dev/icerock/moko/errors/handler/ExceptionHandlerContextImpl.kt

@@ -10,20 +10,35 @@ import dev.icerock.moko.resources.desc.desc
 import kotlin.native.concurrent.ThreadLocal
 import kotlin.reflect.KClass
 
-internal typealias ThrowableMapper = (Throwable) -> Any
-
 @Suppress("TooManyFunctions")
 @ThreadLocal
 object ExceptionMappersStorage {
 
-    private val fallbackValuesMap: MutableMap<KClass<out Any>, Any> = mutableMapOf(
-        StringDesc::class to MR.strings.moko_errors_unknownError.desc()
+    private val containers: MutableMap<KClass<*>, MappersContainer<*>> = mutableMapOf(
+        StringDesc::class to MappersContainer<StringDesc>(
+            mappers = emptyList(),
+            fallback = { MR.strings.moko_errors_unknownError.desc() }
+        )
     )
+    private val notifiers: MutableList<(Throwable, KClass<*>, Any) -> Unit> = mutableListOf()
+
+    private fun <T : Any> getOrCreateContainer(resultClass: KClass<T>): MappersContainer<T> {
+        val existContainer: MappersContainer<*>? = containers[resultClass]
+        if (existContainer != null) return existContainer as MappersContainer<T>
 
-    private val mappersMap: MutableMap<KClass<out Any>, MutableMap<KClass<out Throwable>, ThrowableMapper>> =
-        mutableMapOf()
-    private val conditionMappers: MutableMap<KClass<out Any>, MutableList<ConditionPair>> =
-        mutableMapOf()
+        return MappersContainer<T>(
+            mappers = emptyList(),
+            fallback = { throw FallbackValueNotFoundException(resultClass) }
+        ).also { containers[resultClass] = it }
+    }
+
+    private fun <T : Any> updateContainer(
+        resultClass: KClass<T>,
+        block: (MappersContainer<T>) -> MappersContainer<T>
+    ) {
+        val container: MappersContainer<T> = getOrCreateContainer(resultClass)
+        containers[resultClass] = block(container)
+    }
 
     /**
      * Register simple mapper (E) -> T.
@@ -33,11 +48,16 @@ object ExceptionMappersStorage {
         exceptionClass: KClass<E>,
         mapper: (E) -> T
     ): ExceptionMappersStorage {
-        if (!mappersMap.containsKey(resultClass)) {
-            mappersMap[resultClass] = mutableMapOf()
+        updateContainer(
+            resultClass
+        ) { container ->
+            container.copy(
+                mappers = container.mappers + ThrowableMapperItem(
+                    mapper = { mapper(it as E) },
+                    isApplied = { it::class == exceptionClass }
+                )
+            )
         }
-        @Suppress("UNCHECKED_CAST")
-        mappersMap[resultClass]?.put(exceptionClass, mapper as ThrowableMapper)
         return this
     }
 
@@ -46,12 +66,19 @@ object ExceptionMappersStorage {
      */
     fun <T : Any> register(
         resultClass: KClass<T>,
-        conditionPair: ConditionPair
+        isApplied: (Throwable) -> Boolean,
+        mapper: (Throwable) -> T
     ): ExceptionMappersStorage {
-        if (!conditionMappers.containsKey(resultClass)) {
-            conditionMappers[resultClass] = mutableListOf()
+        updateContainer(
+            resultClass
+        ) { container ->
+            container.copy(
+                mappers = container.mappers + ThrowableMapperItem(
+                    mapper = mapper,
+                    isApplied = isApplied
+                )
+            )
         }
-        conditionMappers[resultClass]?.add(conditionPair)
         return this
     }
 
@@ -76,10 +103,8 @@ object ExceptionMappersStorage {
         noinline mapper: (Throwable) -> T
     ): ExceptionMappersStorage = register(
         resultClass = T::class,
-        conditionPair = ConditionPair(
-            condition,
-            mapper as ThrowableMapper
-        )
+        isApplied = condition,
+        mapper = mapper
     )
 
     /**
@@ -91,19 +116,27 @@ object ExceptionMappersStorage {
      */
     fun <E : Throwable, T : Any> find(
         resultClass: KClass<T>,
-        throwable: E,
-        exceptionClass: KClass<out E>
+        throwable: E
     ): ((E) -> T)? {
-        @Suppress("UNCHECKED_CAST")
-        val mapper = conditionMappers[resultClass]
-            ?.find { it.condition(throwable) }
-            ?.mapper as? ((E) -> T)
-            ?: mappersMap[resultClass]?.get(exceptionClass) as? ((E) -> T)
+        val container: MappersContainer<T>? = containers[resultClass] as MappersContainer<T>?
 
-        return if (mapper == null && throwable !is Exception) {
+        if (container == null && throwable !is Exception) {
             throw throwable
-        } else {
-            mapper
+        } else if (container == null) {
+            return null
+        }
+
+        val mapper: (Throwable) -> T = container.mappers
+            .firstOrNull { it.isApplied(throwable) }
+            ?.mapper
+            ?: container.fallback
+
+        return { exception ->
+            val result: T = mapper(exception)
+            notifiers.forEach { notifier ->
+                notifier(exception, resultClass, result)
+            }
+            result
         }
     }
 
@@ -116,16 +149,21 @@ object ExceptionMappersStorage {
      */
     inline fun <E : Throwable, reified T : Any> find(throwable: E): ((E) -> T)? = find(
         resultClass = T::class,
-        throwable = throwable,
-        exceptionClass = throwable::class
+        throwable = throwable
     )
 
     /**
      * Sets fallback (default) value for [T] errors type.
      */
     fun <T : Any> setFallbackValue(clazz: KClass<T>, value: T): ExceptionMappersStorage {
-        fallbackValuesMap[clazz] = value
-        return ExceptionMappersStorage
+        updateContainer(
+            clazz
+        ) { container ->
+            container.copy(
+                fallback = { value }
+            )
+        }
+        return this
     }
 
     /**
@@ -135,37 +173,51 @@ object ExceptionMappersStorage {
         setFallbackValue(T::class, value)
 
     /**
-     * Returns fallback (default) value for [T] errors type.
-     * If there is no default value for the class [T], then [FallbackValueNotFoundException]
-     * exception will be thrown.
+     * Sets fallback (default) factory for [T] errors type.
      */
-    fun <T : Any> getFallbackValue(clazz: KClass<T>): T {
-        @Suppress("UNCHECKED_CAST")
-        return fallbackValuesMap[clazz] as? T
-            ?: throw FallbackValueNotFoundException(clazz)
+    fun <T : Any> setFallbackFactory(
+        clazz: KClass<T>,
+        factory: (Throwable) -> T
+    ): ExceptionMappersStorage {
+        updateContainer(
+            clazz
+        ) { container ->
+            container.copy(
+                fallback = factory
+            )
+        }
+        return this
     }
 
-    /**
-     * Returns fallback (default) value for [T] errors type.
-     * If there is no default value for the class [T], then [FallbackValueNotFoundException]
-     * exception will be thrown.
-     */
-    inline fun <reified T : Any> getFallbackValue(): T = getFallbackValue(T::class)
+    inline fun <reified T : Any> setFallbackFactory(
+        noinline factory: (Throwable) -> T
+    ): ExceptionMappersStorage = setFallbackFactory(T::class, factory)
 
     /**
      * Factory method that creates mappers (Throwable) -> T with a registered fallback value for
      * class [T].
      */
     fun <E : Throwable, T : Any> throwableMapper(clazz: KClass<T>): (e: E) -> T {
-        val fallback = getFallbackValue(clazz)
         return { e ->
-            find(clazz, e, e::class)?.invoke(e) ?: fallback
+            find(clazz, e)?.invoke(e) ?: throw FallbackValueNotFoundException(clazz)
         }
     }
 
     inline fun <E : Throwable, reified T : Any> throwableMapper(): (e: E) -> T {
         return dev.icerock.moko.errors.mappers.throwableMapper()
     }
+
+    /**
+     * Listen all mappers calls. Useful for logging
+     *
+     * @param block - lambda that will be called when exception map to some class
+     */
+    fun onEach(
+        block: (Throwable, KClass<*>, Any) -> Unit
+    ): ExceptionMappersStorage {
+        notifiers.add(block)
+        return this
+    }
 }
 
 /**

errors/src/commonMain/kotlin/dev/icerock/moko/errors/mappers/ConditionPair.kt

@@ -0,0 +1,10 @@
+/*
+ * Copyright 2023 IceRock MAG Inc. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+package dev.icerock.moko.errors.mappers
+
+internal data class MappersContainer<T>(
+    val mappers: List<ThrowableMapperItem<T>>,
+    val fallback: ThrowableMapper<T>
+)

errors/src/commonMain/kotlin/dev/icerock/moko/errors/mappers/ExceptionMappersStorage.kt

@@ -0,0 +1,12 @@
+/*
+ * Copyright 2023 IceRock MAG Inc. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+package dev.icerock.moko.errors.mappers
+
+internal typealias ThrowableMapper<T> = (Throwable) -> T
+
+internal data class ThrowableMapperItem<T>(
+    val mapper: ThrowableMapper<T>,
+    val isApplied: (Throwable) -> Boolean
+)

errors/src/commonMain/kotlin/dev/icerock/moko/errors/mappers/MappersContainer.kt

@@ -4,9 +4,9 @@
 
 package dev.icerock.moko.errors.presenters
 
+import dev.icerock.moko.errors.MR
 import dev.icerock.moko.resources.desc.StringDesc
 import dev.icerock.moko.resources.desc.desc
-import dev.icerock.moko.errors.MR
 
 /**
  * In iOS there is no such thing as snackbar, so it shows [AlertErrorPresenter].

errors/src/commonMain/kotlin/dev/icerock/moko/errors/mappers/ThrowableMapperItem.kt

@@ -3,14 +3,12 @@ org.gradle.configureondemand=false
 org.gradle.parallel=true
 
 kotlin.code.style=official
-kotlin.native.enableDependencyPropagation=false
-kotlin.mpp.enableGranularSourceSetsMetadata=true
-kotlin.mpp.enableCompatibilityMetadataVariant=true
+kotlin.mpp.androidSourceSetLayoutVersion=2
 
 android.useAndroidX=true
 
-moko.android.targetSdk=30
-moko.android.compileSdk=30
+moko.android.targetSdk=33
+moko.android.compileSdk=33
 moko.android.minSdk=16
 
 moko.publish.name=MOKO errors