wip deserialization

Signed-off-by: Adam Ratzman <[email protected]>

Author: adamint

build.gradle.kts

@@ -146,17 +146,30 @@ kotlin {
         }
     }
 
+    val hostOs = System.getProperty("os.name")
+    val isMingwX64 = hostOs.startsWith("Windows")
+    val nativeTarget = when {
+        hostOs == "Mac OS X" -> macosX64("native")
+        hostOs == "Linux" -> linuxX64("native")
+        isMingwX64 -> mingwX64("native")
+        else -> throw GradleException("Host OS is not supported in Kotlin/Native.")
+    }
+
+
     targets {
         sourceSets {
-            val coroutineVersion = "1.4.2"
+            val coroutineVersion = "1.4.2-native-mt"
             val serializationVersion = "1.0.1"
             val ktorVersion = "1.4.1"
+            val kotlinxDatetimeVersion = "0.1.1"
 
             val commonMain by getting {
                 dependencies {
                     implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:$coroutineVersion")
                     implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:$serializationVersion")
                     implementation("io.ktor:ktor-client-core:$ktorVersion")
+                    implementation("org.jetbrains.kotlinx:kotlinx-datetime:$kotlinxDatetimeVersion")
+                    implementation("com.autodesk:coroutineworker:0.6.2")
                 }
             }
             val commonTest by getting {
@@ -221,6 +234,17 @@ kotlin {
                 }
             }
 
+            val nativeMain by getting {
+                dependencies {
+                    implementation("io.ktor:ktor-client-curl:$ktorVersion")
+                }
+            }
+            val nativeTest by getting {
+                dependencies {
+
+                }
+            }
+
             all {
                 languageSettings.useExperimentalAnnotation("kotlin.Experimental")
             }
@@ -260,8 +284,9 @@ publishing {
 
 signing {
     if (project.hasProperty("signing.keyId")
-            && project.hasProperty("signing.password")
-            && project.hasProperty("signing.secretKeyRingFile")) {
+        && project.hasProperty("signing.password")
+        && project.hasProperty("signing.secretKeyRingFile")
+    ) {
         sign(publishing.publications)
     }
 }

src/androidMain/kotlin/com/adamratzman/spotify/http/Endpoints.kt

@@ -6,6 +6,8 @@ import android.os.Build.VERSION_CODES
 import android.util.Base64
 import java.net.URLEncoder
 
+actual fun SpotifyCache.f() {}
+
 internal actual fun String.encodeUrl() = URLEncoder.encode(this, "UTF-8")!!
 
 internal actual fun String.base64ByteEncode(): String {

src/androidMain/kotlin/com/adamratzman/spotify/utils/Concurrency.kt

@@ -1,4 +1,4 @@
 /* Spotify Web API, Kotlin Wrapper; MIT License, 2017-2021; Original author: Adam Ratzman */
 package com.adamratzman.spotify.utils
 
-public actual typealias TimeUnit = java.util.concurrent.TimeUnit
+public actual typealias TimeUnit = java.util.concurrent.TimeUnit

src/androidMain/kotlin/com/adamratzman/spotify/utils/Misc.kt

@@ -1,13 +1,4 @@
 /* Spotify Web API, Kotlin Wrapper; MIT License, 2017-2021; Original author: Adam Ratzman */
 package com.adamratzman.spotify.utils
 
-import android.annotation.SuppressLint
-import java.text.SimpleDateFormat
-import java.util.Date
-
 public actual fun getCurrentTimeMs(): Long = System.currentTimeMillis()
-
-@SuppressLint("SimpleDateFormat")
-internal actual fun formatDate(format: String, date: Long): String {
-        return SimpleDateFormat(format).format(Date(date))
-}

src/commonMain/kotlin/com.adamratzman.spotify/endpoints/public/BrowseApi.kt

@@ -101,9 +101,7 @@ public class BrowseApi(api: GenericSpotifyApi) : SpotifyEndpoint(api) {
         endpointBuilder("/browse/featured-playlists").with("limit", limit).with("offset", offset).with(
             "market",
             market?.name
-        ).with("locale", locale).with("timestamp", timestamp?.let {
-            formatDate("yyyy-MM-dd'T'HH:mm:ss", it)
-        }).toString()
+        ).with("locale", locale).with("timestamp", timestamp?.let { formatDate(it) }).toString()
     ).toObject(FeaturedPlaylists.serializer(), api, json)
 
     /**
@@ -182,8 +180,8 @@ public class BrowseApi(api: GenericSpotifyApi) : SpotifyEndpoint(api) {
             "limit",
             limit
         ).with("offset", offset)
-            .with("market", market?.name).toString()
-    ).toPagingObject(SimplePlaylist.serializer(), "playlists", endpoint = this, json = json)
+            .with("market", market?.name).toString().apply { println("here1") }
+    ).toPagingObject(SimplePlaylist.serializer(), "playlists", endpoint = this, json = json).apply { println("heref") }
 
     /**
      * Create a playlist-style listening experience based on seed artists, tracks and genres.

src/commonMain/kotlin/com.adamratzman.spotify/http/Endpoints.kt

@@ -16,10 +16,16 @@ import kotlinx.coroutines.withTimeout
 import kotlinx.serialization.Serializable
 import kotlinx.serialization.Transient
 
+expect fun SpotifyCache.f()
+
 public abstract class SpotifyEndpoint(public val api: GenericSpotifyApi) {
     public val cache: SpotifyCache = SpotifyCache()
     internal val json get() = api.spotifyApiOptions.json
 
+    init {
+        cache.f()
+    }
+
     internal fun endpointBuilder(path: String) = EndpointBuilder(path, api)
 
     protected fun checkBulkRequesting(maxSize: Int, itemSize: Int) {

src/commonMain/kotlin/com.adamratzman.spotify/models/serialization/SerializationUtils.kt

@@ -14,6 +14,8 @@ import kotlin.reflect.KClass
 import kotlinx.serialization.KSerializer
 import kotlinx.serialization.builtins.MapSerializer
 import kotlinx.serialization.builtins.serializer
+import kotlinx.serialization.decodeFromString
+import kotlinx.serialization.encodeToString
 import kotlinx.serialization.json.Json
 import kotlinx.serialization.json.JsonElement
 import kotlinx.serialization.json.JsonObject
@@ -57,7 +59,7 @@ internal inline fun <reified T> String.toList(serializer: KSerializer<List<T>>,
     }
 }
 
-internal fun <T : Any> String.toPagingObject(
+internal inline fun <reified T : Any> String.toPagingObject(
     tClazz: KClass<T>,
     tSerializer: KSerializer<T>,
     innerObjectName: String? = null,
@@ -66,11 +68,21 @@ internal fun <T : Any> String.toPagingObject(
     arbitraryInnerNameAllowed: Boolean = false,
     skipInnerNameFirstIfPossible: Boolean = true
 ): NullablePagingObject<T> {
+    println("here2")
     if (innerObjectName != null || (arbitraryInnerNameAllowed && !skipInnerNameFirstIfPossible)) {
+        println("here3 $tClazz")
         val map = this.parseJson {
-            val t = (String.serializer() to NullablePagingObject.serializer(tSerializer))
-            json.decodeFromString(MapSerializer(t.first, t.second), this)
+            val t = (String.serializer() to NullablePagingObject.serializer(tSerializer)).apply { println("serializer done") }
+                val jsonObjectRoot = (json.parseToJsonElement(this) as JsonObject)
+                val jsonElement = innerObjectName?.let { jsonObjectRoot[it] } ?: jsonObjectRoot.keys.firstOrNull()?.let { jsonObjectRoot[it] }
+                ?: throw SpotifyException.ParseException("Json element was null for class $tClazz (json $this)")
+            val objectString = json.encodeToString(jsonElement)
+
+            println(objectString)
+            println(json.decodeFromString<NullablePagingObject<T>>(objectString))
+            json.decodeFromString(MapSerializer(t.first, t.second), this).apply { println("decoded") }
         }
+        println("here4")
         return (map[innerObjectName] ?: if (arbitraryInnerNameAllowed) map.keys.firstOrNull()?.let { map[it] }
                 ?: error("") else error(""))
                 .apply {
@@ -82,6 +94,7 @@ internal fun <T : Any> String.toPagingObject(
                     }
                 }
     }
+    println("here5")
 
     return try {
         val pagingObject = this.parseJson { json.decodeFromString(NullablePagingObject.serializer(tSerializer), this) }

src/commonMain/kotlin/com.adamratzman.spotify/utils/Platform.kt

@@ -7,7 +7,8 @@ package com.adamratzman.spotify.utils
 public enum class Platform {
     JVM,
     ANDROID,
-    JS
+    JS,
+    NATIVE
 }
 
 public expect val platform: Platform

src/commonMain/kotlin/com.adamratzman.spotify/utils/Utils.kt

@@ -3,6 +3,9 @@ package com.adamratzman.spotify.utils
 
 import com.adamratzman.spotify.SpotifyException
 import com.adamratzman.spotify.models.ResultEnum
+import kotlinx.datetime.Instant
+import kotlinx.datetime.TimeZone
+import kotlinx.datetime.toLocalDateTime
 import kotlinx.serialization.json.JsonElement
 
 public expect fun getCurrentTimeMs(): Long
@@ -22,4 +25,5 @@ internal suspend inline fun <T> catch(crossinline function: suspend () -> T): T?
 internal fun <T : ResultEnum> Array<T>.match(identifier: String) =
     firstOrNull { it.retrieveIdentifier().toString().equals(identifier, true) }
 
-internal expect fun formatDate(format: String, date: Long): String
+internal fun formatDate(date: Long): String =
+    Instant.fromEpochMilliseconds(date).toLocalDateTime(TimeZone.currentSystemDefault()).toString()

src/commonTest/kotlin/com.adamratzman/spotify/Common.kt

@@ -1,60 +1,65 @@
 /* Spotify Web API, Kotlin Wrapper; MIT License, 2017-2021; Original author: Adam Ratzman */
 package com.adamratzman.spotify
 
+import com.autodesk.coroutineworker.CoroutineWorker
 import kotlin.coroutines.CoroutineContext
 import kotlin.test.assertTrue
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.CoroutineStart.LAZY
 import kotlinx.coroutines.Deferred
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.GlobalScope
+import kotlinx.coroutines.MainScope
 import kotlinx.coroutines.async
+import kotlin.native.concurrent.ThreadLocal
 
 val clientId = getEnvironmentVariable("SPOTIFY_CLIENT_ID")
 val clientSecret = getEnvironmentVariable("SPOTIFY_CLIENT_SECRET")
 val redirectUri = getEnvironmentVariable("SPOTIFY_REDIRECT_URI")
 val tokenString = getEnvironmentVariable("SPOTIFY_TOKEN_STRING")
 
+
+// https://github.com/Kotlin/kotlinx.coroutines/issues/1996#issuecomment-728562784
+expect fun runBlockingTest(block: suspend CoroutineScope.() -> Unit)
+expect val testCoroutineContext: CoroutineContext
+
+@ThreadLocal
 var instantiationCompleted: Boolean = false
+@ThreadLocal
 private lateinit var apiBacking: GenericSpotifyApi
 
 // https://github.com/Kotlin/kotlinx.coroutines/issues/706#issuecomment-429922811
-val spotifyApi: Deferred<GenericSpotifyApi?>
-    get() = GlobalScope.async(Dispatchers.Unconfined, start = LAZY) {
-        if (::apiBacking.isInitialized) return@async apiBacking
-        when {
-            tokenString?.isNotBlank() == true -> {
-                spotifyClientApi {
-                    credentials {
-                        clientId = com.adamratzman.spotify.clientId
-                        clientSecret = com.adamratzman.spotify.clientSecret
-                        redirectUri = com.adamratzman.spotify.redirectUri
-                    }
-                    authorization {
-                        tokenString = com.adamratzman.spotify.tokenString
-                    }
-                }.build().also { instantiationCompleted = true; apiBacking = it }
+suspend fun buildSpotifyApi() = when {
+    tokenString?.isNotBlank() == true -> {
+        spotifyClientApi {
+            credentials {
+                clientId = com.adamratzman.spotify.clientId
+                clientSecret = com.adamratzman.spotify.clientSecret
+                redirectUri = com.adamratzman.spotify.redirectUri
             }
-            clientId?.isNotBlank() == true -> {
-                spotifyAppApi {
-                    credentials {
-                        clientId = com.adamratzman.spotify.clientId
-                        clientSecret = com.adamratzman.spotify.clientSecret
-                    }
-                }.build().also { instantiationCompleted = true; apiBacking = it }
+            authorization {
+                tokenString = com.adamratzman.spotify.tokenString
             }
-            else -> null.also { instantiationCompleted = true }
+        }.build().also { instantiationCompleted = true; apiBacking = it }
+    }
+    clientId?.isNotBlank() == true -> {
+        println("building")
+        spotifyAppApi {
+            credentials {
+                clientId = com.adamratzman.spotify.clientId
+                clientSecret = com.adamratzman.spotify.clientSecret
+            }
+        }.build().also {
+            println("built");instantiationCompleted = true; apiBacking = it;println("through seq")
         }
     }
+    else -> null.also { instantiationCompleted = true }
+}?.also { print("done when") }
 
 expect fun getEnvironmentVariable(name: String): String?
 
 expect fun Exception.stackTrace()
 
-// https://github.com/Kotlin/kotlinx.coroutines/issues/1996#issuecomment-728562784
-expect fun runBlockingTest(block: suspend CoroutineScope.() -> Unit)
-expect val testCoroutineContext: CoroutineContext
-
 suspend inline fun <reified T : Throwable> assertFailsWithSuspend(crossinline block: suspend () -> Unit) {
     val noExceptionMessage = "Expected ${T::class.simpleName} exception to be thrown, but no exception was thrown."
     try {