[KMM] Add Support for Fuse Kotlin Multiplatform (KMM)

.github/workflows/PR.yml

@@ -24,11 +24,11 @@ jobs:
         if: failure()
         with:
           name: testDebugUnitTest
-          path: ./**/build/reports/tests/testDebugUnitTest
+          path: ./**/build/reports/tests/testDebugUnitTest/*
 
       - name: Upload allTests results
         uses: actions/upload-artifact@v2.2.3
         if: failure()
         with:
           name: allTests
-          path: ./**/build/reports/test/allTests
+          path: ./**/build/reports/tests/allTests/*

fuse-core/.gitignore

@@ -0,0 +1 @@
+/build

fuse-core/build.gradle.kts

@@ -0,0 +1,167 @@
+plugins {
+    kotlin("multiplatform")
+    kotlin("plugin.serialization")
+
+    id("com.android.library")
+//    java
+    jacoco
+
+
+    id("publication")
+}
+
+val artifactGroupId: String by project
+group = artifactGroupId
+
+val gitSha = "git rev-parse --short HEAD".runCommand(project.rootDir)?.trim().orEmpty()
+
+val isReleaseBuild: Boolean
+    get() = properties.containsKey("release")
+
+val artifactPublishVersion: String by project
+version = if (isReleaseBuild) artifactPublishVersion else "master-$gitSha-SNAPSHOT"
+
+kotlin {
+    jvm()
+    ios()
+    iosSimulatorArm64()
+    android()
+
+    sourceSets {
+        all {
+            languageSettings {
+                optIn("kotlin.RequiresOptIn")
+            }
+        }
+
+        val commonMain by getting {
+            dependencies {
+                implementation(libs.kotlin.stdlib)
+                implementation(libs.kotlinx.serialization.json)
+                implementation(libs.kotlinx.time)
+                api(libs.result)
+            }
+        }
+
+        val commonTest by getting {
+            dependencies {
+                implementation(libs.bundles.kotlin.test)
+            }
+        }
+
+        val jvmMain by getting {
+            dependencies {
+            }
+        }
+
+        val jvmTest by getting {
+            dependencies {
+                implementation(libs.kotlin.test.junit)
+            }
+        }
+
+        val iosMain by getting {
+            dependencies {
+            }
+        }
+
+        val iosSimulatorArm64Main by getting {
+            dependsOn(iosMain)
+        }
+
+        val iosSimulatorArm64Test by getting {
+            val iosTest by getting
+            dependsOn(iosTest)
+        }
+
+        val androidMain by getting {
+            dependsOn(jvmMain)
+        }
+
+        val androidTest by getting {
+            dependencies {
+                implementation(libs.bundles.android.test)
+                implementation(libs.kotlin.test.junit)
+            }
+        }
+    }
+}
+
+android {
+    compileSdk = libs.versions.compileSdk.get().toInt()
+
+    sourceSets {
+        getByName("main") {
+            manifest.srcFile("src/androidMain/AndroidManifest.xml")
+            java.srcDirs("src/androidMain/kotlin")
+            res.srcDirs("src/androidMain/res")
+        }
+
+        getByName("androidTest") {
+            manifest.srcFile("src/androidTest/AndroidManifest.xml")
+            java.srcDirs("src/androidTest/kotlin")
+            res.srcDirs("src/androidTest/res")
+        }
+    }
+
+    defaultConfig {
+        testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
+
+        minSdk = libs.versions.minSdk.get().toInt()
+        targetSdk = libs.versions.targetSdk.get().toInt()
+    }
+
+    buildTypes {
+        getByName("release") {
+            isMinifyEnabled = false
+        }
+    }
+
+    testOptions {
+        unitTests.isReturnDefaultValues = true
+    }
+}
+
+jacoco {
+    toolVersion = libs.versions.jacoco.get()
+}
+
+tasks {
+    withType<JacocoReport> {
+        group = "Reporting"
+        description = "Generate Jacoco coverage reports."
+
+        val jvmTest by getting
+        dependsOn(jvmTest)
+
+        val classFiles = File("$buildDir/classes/kotlin/jvm/main").walkBottomUp().toSet()
+        classDirectories.setFrom(classFiles)
+        sourceDirectories.setFrom(files(arrayOf("$projectDir/src/commonMain")))
+        executionData.setFrom(files("$buildDir/jacoco/jvmTest.exec"))
+
+        reports {
+            xml.required.set(true)
+
+            html.required.set(true)
+            html.outputLocation.set(buildDir.resolve("reports"))
+
+            csv.required.set(false)
+        }
+    }
+
+    val tests = listOfNotNull(findByName("iosSimulatorArm64Test"), findByName("iosX64Test"))
+
+    val copyIOSTestResources by creating(Copy::class) {
+        val spec = copySpec {
+            from("src/commonTest/resources")
+            duplicatesStrategy = DuplicatesStrategy.INCLUDE
+        }
+        into("$buildDir/bin")
+
+        tests.forEach {
+            into("/${it.name.substringBefore("Test")}/debugTest/resources") { with(spec) }
+        }
+    }
+
+    tests.forEach { it.dependsOn(copyIOSTestResources) }
+}

fuse-core/src/androidMain/AndroidManifest.xml

@@ -0,0 +1 @@
+<manifest package="com.github.kittinunf.fuse" />

fuse-core/src/androidMain/kotlin/com/github/kittinunf/fuse/core/AndroidConfig.kt

@@ -0,0 +1,29 @@
+package com.github.kittinunf.fuse.core
+
+import android.content.Context
+import com.github.kittinunf.fuse.core.formatter.JsonBinaryConverter
+import com.github.kittinunf.fuse.core.persistence.JvmDiskPersistence
+import com.github.kittinunf.fuse.core.persistence.MemPersistence
+import com.github.kittinunf.fuse.core.persistence.Persistence
+import kotlinx.serialization.BinaryFormat
+import kotlinx.serialization.KSerializer
+
+fun <T : Any> AndroidConfig(
+    name: String,
+    context: Context,
+    serializer: KSerializer<T>,
+    formatter: BinaryFormat = JsonBinaryConverter(),
+    diskCapacity: Long = 1024 * 1024 * 20,
+    transformer: (key: String, value: T) -> T = { _, value -> value },
+    memCache: Persistence<T> = MemPersistence(),
+    diskCache: Persistence<ByteArray> = JvmDiskPersistence(name, context.cacheDir)
+) = JvmConfig(
+    name,
+    path = context.cacheDir,
+    serializer = serializer,
+    formatter = formatter,
+    diskCapacity = diskCapacity,
+    transformer = transformer,
+    memCache = memCache,
+    diskCache = diskCache
+)

fuse-core/src/androidMain/kotlin/com/github/kittinunf/fuse/core/AndroidDiskPersistence.kt

@@ -0,0 +1,6 @@
+package com.github.kittinunf.fuse.core
+
+import android.content.Context
+import com.github.kittinunf.fuse.core.persistence.JvmDiskPersistence
+
+fun AndroidDiskPersistence(name: String, context: Context) = JvmDiskPersistence(name, context.cacheDir)

fuse-core/src/androidTest/kotlin/com/github/kittinunf/fuse/core/BaseTest.kt

@@ -0,0 +1,17 @@
+package com.github.kittinunf.fuse.core
+
+import androidx.test.core.app.ApplicationProvider
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import org.junit.Before
+import org.junit.runner.RunWith
+
+@RunWith(AndroidJUnit4::class)
+actual abstract class BaseTest {
+
+    @Before
+    internal actual fun before() {
+        setUp(ApplicationProvider.getApplicationContext())
+    }
+
+    actual abstract fun setUp(any: Any)
+}

fuse-core/src/androidTest/kotlin/com/github/kittinunf/fuse/core/CreateByteTestCache.kt

@@ -0,0 +1,9 @@
+package com.github.kittinunf.fuse.core
+
+import android.content.Context
+import kotlinx.serialization.builtins.ByteArraySerializer
+
+internal actual fun createByteTestCache(name: String, context: Any): Cache<ByteArray> {
+    val context = context as Context
+    return JvmConfig(name, path = context.cacheDir, serializer = ByteArraySerializer()).build()
+}

fuse-core/src/androidTest/kotlin/com/github/kittinunf/fuse/core/CreateJsonTestCache.kt

@@ -0,0 +1,8 @@
+package com.github.kittinunf.fuse.core
+
+import kotlinx.serialization.builtins.serializer
+import com.github.kittinunf.fuse.core.model.Product
+
+internal actual fun createJsonTestCache(name: String, context: Any): Cache<Product> {
+    return JvmConfig(name, path = createTempDir(suffix = "").parentFile, serializer = Product.serializer()).build()
+}

fuse-core/src/androidTest/kotlin/com/github/kittinunf/fuse/core/CreateStringTestCache.kt

@@ -0,0 +1,7 @@
+package com.github.kittinunf.fuse.core
+
+import kotlinx.serialization.builtins.serializer
+
+internal actual fun createStringTestCache(name: String, context: Any): Cache<String> {
+    return JvmConfig(name, path = createTempDir(suffix = "").parentFile, serializer = String.serializer()).build()
+}

fuse-core/src/androidTest/kotlin/com/github/kittinunf/fuse/core/CreateTestPersistence.kt

@@ -0,0 +1,9 @@
+package com.github.kittinunf.fuse.core
+
+import android.content.Context
+import com.github.kittinunf.fuse.core.persistence.Persistence
+
+actual fun createTestDiskPersistence(context: Any): Persistence<ByteArray> {
+    val context = context as Context
+    return AndroidDiskPersistence("test-cache", context)
+}

fuse-core/src/androidTest/kotlin/com/github/kittinunf/fuse/core/ReadResource.kt

@@ -0,0 +1,5 @@
+package com.github.kittinunf.fuse.core
+
+actual fun readResource(name: String): ByteArray {
+    return ClassLoader.getSystemResourceAsStream(name).readBytes()
+}

fuse-core/src/androidTest/resources/another_sample.json

@@ -0,0 +1,26 @@
+{
+  "name": "Another Product",
+  "properties": {
+    "id": {
+      "type": "number",
+      "description": "Another Product Identifier",
+      "required": true
+    },
+    "name": {
+      "type": "string",
+      "description": "Name of the another product",
+      "required": true
+    },
+    "price": {
+      "type": "number",
+      "minimum": 42,
+      "required": true
+    },
+    "tags": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    }
+  }
+}

fuse-core/src/androidTest/resources/sample.json

@@ -0,0 +1,26 @@
+{
+  "name": "Product",
+  "properties": {
+    "id": {
+      "type": "number",
+      "description": "Product Identifier",
+      "required": true
+    },
+    "name": {
+      "type": "string",
+      "description": "Name of the product",
+      "required": true
+    },
+    "price": {
+      "type": "number",
+      "minimum": 10,
+      "required": true
+    },
+    "tags": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    }
+  }
+}