Merge pull request #145 from adamint/uri_enhancement

adamint · web-flow · commit b750c7f4c02f · 2019-11-04T12:29:12.000-05:00
Uri enhancements and fixes
diff --git a/src/commonMain/kotlin/com.adamratzman.spotify/models/Albums.kt b/src/commonMain/kotlin/com.adamratzman.spotify/models/Albums.kt
@@ -48,6 +48,8 @@ data class SimpleAlbum(
     @SerialName("total_tracks") val totalTracks: Int? = null,
     @SerialName("album_group") private val albumGroupString: String? = null
 ) : CoreObject(href, id, AlbumUri(uriString), externalUrlsString) {
+    override val uri: AlbumUri get() = super.uri as AlbumUri
+
     @Transient
     val availableMarkets = availableMarketsString.map { CountryCode.valueOf(it) }
 
@@ -135,6 +137,8 @@ data class Album(
     @SerialName("total_tracks") val totalTracks: Int,
     val restrictions: Restrictions? = null
 ) : CoreObject(href, id, AlbumUri(uriString), externalUrlsString) {
+    override val uri: AlbumUri get() = super.uri as AlbumUri
+
     @Transient
     val availableMarkets = availableMarketsString.map { CountryCode.valueOf(it) }
 
diff --git a/src/commonMain/kotlin/com.adamratzman.spotify/models/Artists.kt b/src/commonMain/kotlin/com.adamratzman.spotify/models/Artists.kt
@@ -22,6 +22,8 @@ data class SimpleArtist(
     val name: String,
     val type: String
 ) : CoreObject(href, id, ArtistUri(uriString), externalUrlsString) {
+    override val uri: ArtistUri get() = super.uri as ArtistUri
+
     /**
      * Converts this [SimpleArtist] into a full [Artist] object
      */
@@ -55,7 +57,9 @@ data class Artist(
     val name: String,
     val popularity: Int,
     val type: String
-) : CoreObject(href, id, ArtistUri(uriString), externalUrlsString)
+) : CoreObject(href, id, ArtistUri(uriString), externalUrlsString) {
+    override val uri: ArtistUri get() = super.uri as ArtistUri
+}
 
 @Serializable
 internal data class ArtistList(val artists: List<Artist?>)
diff --git a/src/commonMain/kotlin/com.adamratzman.spotify/models/PagingObjects.kt b/src/commonMain/kotlin/com.adamratzman.spotify/models/PagingObjects.kt
@@ -207,7 +207,7 @@ abstract class AbstractPagingObject<T : Any>(
     @Transient open val previous: String? = null,
     @Transient open val total: Int = -1
 ) : List<T> {
-    override val size: Int = items.size
+    override val size: Int get() = items.size
 
     override fun contains(element: T) = items.contains(element)
 
diff --git a/src/commonMain/kotlin/com.adamratzman.spotify/models/Player.kt b/src/commonMain/kotlin/com.adamratzman.spotify/models/Player.kt
@@ -19,7 +19,9 @@ data class PlayHistoryContext(
     @SerialName("uri") private val uriString: String,
 
     val type: String
-) : CoreObject(href, href, TrackUri(uriString), externalUrlsString)
+) : CoreObject(href, href, TrackUri(uriString), externalUrlsString) {
+    override val uri: TrackUri get() = super.uri as TrackUri
+}
 
 /**
  * Information about a previously-played track
diff --git a/src/commonMain/kotlin/com.adamratzman.spotify/models/Playlist.kt b/src/commonMain/kotlin/com.adamratzman.spotify/models/Playlist.kt
@@ -45,6 +45,8 @@ data class SimplePlaylist(
     val tracks: PlaylistTrackInfo,
     val type: String
 ) : CoreObject(href, id, PlaylistUri(uriString), externalUrlsString) {
+    override val uri: PlaylistUri get() = super.uri as PlaylistUri
+
     @Transient
     val snapshot: PlaylistSnapshot = PlaylistSnapshot(snapshotIdString)
 
@@ -118,6 +120,8 @@ data class Playlist(
     val tracks: PagingObject<PlaylistTrack>,
     val type: String
 ) : CoreObject(href, id, PlaylistUri(uriString), externalUrlsString) {
+    override val uri: PlaylistUri get() = super.uri as PlaylistUri
+
     @Transient
     val snapshot: PlaylistSnapshot = PlaylistSnapshot(snapshotIdString)
 }
diff --git a/src/commonMain/kotlin/com.adamratzman.spotify/models/ResultObjects.kt b/src/commonMain/kotlin/com.adamratzman.spotify/models/ResultObjects.kt
@@ -11,7 +11,7 @@ import kotlinx.serialization.Transient
 
 internal const val TRANSIENT_EMPTY_STRING = ""
 internal val TRANSIENT_NULL = null
-internal val TRANSIENT_URI = UserUri("spotify:user:")
+internal val TRANSIENT_URI = UserUri("TRANSIENT_URI")
 
 /**
  * Represents an identifiable Spotify object such as an Album or Recommendation Seed
diff --git a/src/commonMain/kotlin/com.adamratzman.spotify/models/SpotifyUris.kt b/src/commonMain/kotlin/com.adamratzman.spotify/models/SpotifyUris.kt
@@ -1,19 +1,13 @@
 /* Spotify Web API - Kotlin Wrapper; MIT License, 2019; Original author: Adam Ratzman */
 package com.adamratzman.spotify.models
 
+import kotlinx.serialization.Decoder
+import kotlinx.serialization.Encoder
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.SerialDescriptor
 import kotlinx.serialization.Serializable
-import kotlinx.serialization.modules.SerializersModule
-
-internal val spotifyUriSerializersModule = SerializersModule {
-    polymorphic(SpotifyUri::class) {
-        AlbumUri::class with AlbumUri.serializer()
-        ArtistUri::class with ArtistUri.serializer()
-        TrackUri::class with TrackUri.serializer()
-        LocalTrackUri::class with LocalTrackUri.serializer()
-        UserUri::class with UserUri.serializer()
-        PlaylistUri::class with PlaylistUri.serializer()
-    }
-}
+import kotlinx.serialization.Serializer
+import kotlinx.serialization.internal.StringDescriptor
 
 private fun String.matchType(type: String): String? {
     val typeRegex = "^spotify:(?:.*:)*$type:([^:]+)(?::.*)*$|^([^:]+)$".toRegex()
@@ -35,26 +29,27 @@ private fun String.remove(type: String): String {
     throw SpotifyUriException("Illegal Spotify ID/URI: '$this' isn't convertible to '$type' id")
 }
 
+private class SimpleUriSerializer<T : SpotifyUri>(val ctor: (String) -> T) : KSerializer<T> {
+    override val descriptor: SerialDescriptor = StringDescriptor
+    override fun deserialize(decoder: Decoder): T = ctor(decoder.decodeString())
+    override fun serialize(encoder: Encoder, obj: T) = encoder.encodeString(obj.uri)
+}
+
 /**
  * Represents a Spotify URI, parsed from either a Spotify ID or taken from an endpoint.
  *
  * @property uri retrieve this URI as a string
  * @property id representation of this uri as an id
  */
 @Serializable
-sealed class SpotifyUri(val input: String, val type: UriType) {
+sealed class SpotifyUri(val input: String, type: String) {
     val uri: String
     val id: String
 
     init {
         input.replace(" ", "").let {
-            if (input == "spotify:user:") {
-                this.uri = input
-                this.id = input
-            } else {
-                this.uri = it.add(type.toString())
-                this.id = it.remove(type.toString())
-            }
+            this.uri = it.add(type)
+            this.id = it.remove(type)
         }
     }
 
@@ -73,60 +68,156 @@ sealed class SpotifyUri(val input: String, val type: UriType) {
         return "SpotifyUri($uri)"
     }
 
-    enum class UriType(private val typeStr: String) {
-        ALBUM("album"),
-        ARTIST("artist"),
-        TRACK("track"),
-        USER("user"),
-        PLAYLIST("playlist"),
-        LOCAL_TRACK("local");
+    @Serializer(forClass = SpotifyUri::class)
+    companion object : KSerializer<SpotifyUri> {
+        override val descriptor: SerialDescriptor = StringDescriptor
+        override fun deserialize(decoder: Decoder): SpotifyUri = SpotifyUri(decoder.decodeString())
+        override fun serialize(encoder: Encoder, obj: SpotifyUri) = encoder.encodeString(obj.uri)
+
+        /**
+         * This function safely instantiates a SpotifyUri from given constructor.
+         * */
+        inline fun <T : SpotifyUri> safeInitiate(uri: String, ctor: (String) -> T): T? {
+            return try {
+                ctor(uri)
+            } catch (e: SpotifyUriException) {
+                null
+            }
+        }
+
+        /**
+         * Creates a abstract SpotifyUri of given input. Doesn't allow ambiguity by disallowing creation by id.
+         * */
+        operator fun invoke(input: String): SpotifyUri {
+            val constructors = listOf(::AlbumUri, ::ArtistUri, TrackUri.Companion::invoke, ::UserUri, ::PlaylistUri)
+            for (ctor in constructors) {
+                safeInitiate(input, ctor)?.takeIf { it.uri == input }?.also { return it }
+            }
 
-        override fun toString() = typeStr
-    }
+            throw SpotifyUriException("Illegal Spotify ID/URI: '$input' isn't convertible to any arbitrary id")
+        }
 
-    companion object {
-        fun isUriType(uri: String, type: UriType) = uri.matchType(type.toString()) != null
+        /**
+         * This function returns whether or not the given input IS a given type.
+         *
+         * @example ```Kotlin
+         *     SpotifyUri.isType<UserUri>("abc") // returns: false
+         *     SpotifyUri.isType<UserUri>("spotify:user:abc") // returns: true
+         *     SpotifyUri.isType<UserUri>("spotify:track:abc") // returns: false
+         * ```
+         * */
+        inline fun <reified T: SpotifyUri> isType(input: String): Boolean {
+            return safeInitiate(input, ::invoke)?.let { it is T } ?: false
+        }
+
+        /**
+         * This function returns whether ot not the given input CAN be a given type.
+         *
+         * @example ```Kotlin
+         *     SpotifyUri.canBeType<UserUri>("abc") // returns: true
+         *     SpotifyUri.canBeType<UserUri>("spotify:user:abc") // returns: true
+         *     SpotifyUri.canBeType<UserUri>("spotify:track:abc") // returns: false
+         * ```
+         * */
+        inline fun <reified T: SpotifyUri> canBeType(input: String): Boolean {
+            return isType<T>(input) || !input.contains(':')
+        }
     }
 }
 
 /**
  * Represents a Spotify **Album** URI, parsed from either a Spotify ID or taken from an endpoint.
  */
 @Serializable
-class AlbumUri(private val inputString: String) : SpotifyUri(inputString, UriType.ALBUM)
+class AlbumUri(input: String) : SpotifyUri(input, "album") {
+    @Serializer(forClass = AlbumUri::class)
+    companion object : KSerializer<AlbumUri> by SimpleUriSerializer(::AlbumUri)
+}
+
+@Deprecated("renamed", ReplaceWith("AlbumUri", "com.adamratzman.spotify.models.AlbumUri"))
 typealias AlbumURI = AlbumUri
 
 /**
  * Represents a Spotify **Artist** URI, parsed from either a Spotify ID or taken from an endpoint.
  */
 @Serializable
-class ArtistUri(private val inputString: String) : SpotifyUri(inputString, UriType.ARTIST)
-typealias ArtistURI = ArtistUri
+class ArtistUri(input: String) : SpotifyUri(input, "artist") {
+    @Serializer(forClass = ArtistUri::class)
+    companion object : KSerializer<ArtistUri> by SimpleUriSerializer(::ArtistUri)
+}
 
-/**
- * Represents a Spotify **Track** URI, parsed from either a Spotify ID or taken from an endpoint.
- */
-@Serializable
-class TrackUri(private val inputString: String) : SpotifyUri(inputString, UriType.TRACK)
-typealias TrackURI = TrackUri
+@Deprecated("renamed", ReplaceWith("ArtistUri", "com.adamratzman.spotify.models.ArtistUri"))
+typealias ArtistURI = ArtistUri
 
 /**
  * Represents a Spotify **User** URI, parsed from either a Spotify ID or taken from an endpoint.
  */
 @Serializable
-class UserUri(private val inputString: String) : SpotifyUri(inputString, UriType.USER)
+class UserUri(input: String) : SpotifyUri(input, "user") {
+    @Serializer(forClass = UserUri::class)
+    companion object : KSerializer<UserUri> by SimpleUriSerializer(::UserUri)
+}
+
+@Deprecated("renamed", ReplaceWith("UserUri", "com.adamratzman.spotify.models.UserUri"))
 typealias UserURI = UserUri
 
 /**
  * Represents a Spotify **Playlist** URI, parsed from either a Spotify ID or taken from an endpoint.
  */
 @Serializable
-class PlaylistUri(private val inputString: String) : SpotifyUri(inputString, UriType.PLAYLIST)
+class PlaylistUri(input: String) : SpotifyUri(input, "playlist") {
+    @Serializer(forClass = PlaylistUri::class)
+    companion object : KSerializer<PlaylistUri> by SimpleUriSerializer(::PlaylistUri)
+}
+
+@Deprecated("renamed", ReplaceWith("PlaylistUri", "com.adamratzman.spotify.models.PlaylistUri"))
 typealias PlaylistURI = PlaylistUri
 
+/**
+ * Represents a Spotify **Track** URI, ether LocalTrack or SpotifyTrack, parsed from either a Spotify ID or taken
+ * from an endpoint
+ * */
+@Serializable
+sealed class TrackUri(input: String, type: String) : SpotifyUri(input, type) {
+    @Serializer(forClass = TrackUri::class)
+    companion object : KSerializer<TrackUri> {
+        override val descriptor: SerialDescriptor = StringDescriptor
+        override fun deserialize(decoder: Decoder): TrackUri = TrackUri(decoder.decodeString())
+        override fun serialize(encoder: Encoder, obj: TrackUri) = encoder.encodeString(obj.uri)
+
+        /**
+         * Creates a abstract TrackURI of given input. Prefers SpotifyTrackUri if the input is ambiguous.
+         * */
+        operator fun invoke(input: String): TrackUri {
+            val constructors = listOf(::SpotifyTrackUri, ::LocalTrackUri)
+            for (ctor in constructors) {
+                safeInitiate(input, ctor)?.also { return it }
+            }
+            throw SpotifyUriException("Illegal Spotify ID/URI: '$input' isn't convertible to 'track' or 'local' id")
+        }
+    }
+}
+
+@Deprecated("renamed", ReplaceWith("TrackUri", "com.adamratzman.spotify.models.TrackUri"))
+typealias TrackURI = TrackUri
+
+/**
+ * Represents a Spotify **Track** URI, parsed from either a Spotify ID or taken from an endpoint.
+ */
+@Serializable
+class SpotifyTrackUri(input: String) : TrackUri(input, "track") {
+    @Serializer(forClass = SpotifyTrackUri::class)
+    companion object : KSerializer<SpotifyTrackUri> by SimpleUriSerializer(::SpotifyTrackUri)
+}
+
 /**
  * Represents a Spotify **local track** URI
  */
 @Serializable
-class LocalTrackUri(private val inputString: String) : SpotifyUri(inputString, UriType.LOCAL_TRACK)
+class LocalTrackUri(input: String) : TrackUri(input, "local") {
+    @Serializer(forClass = LocalTrackUri::class)
+    companion object : KSerializer<LocalTrackUri> by SimpleUriSerializer(::LocalTrackUri)
+}
+
+@Deprecated("renamed", ReplaceWith("LocalTrackUri", "com.adamratzman.spotify.models.LocalTrackUri"))
 typealias LocalTrackURI = LocalTrackUri
diff --git a/src/commonMain/kotlin/com.adamratzman.spotify/models/Track.kt b/src/commonMain/kotlin/com.adamratzman.spotify/models/Track.kt
@@ -58,6 +58,8 @@ data class SimpleTrack(
     val popularity: Int? = null,
     val restrictions: Restrictions? = null
 ) : RelinkingAvailableResponse(linkedFrom, href, id, TrackUri(uriString), externalUrlsString) {
+    override val uri: TrackUri get() = super.uri as TrackUri
+
     @Transient
     val availableMarkets = availableMarketsString.map { CountryCode.valueOf(it) }
 
@@ -142,6 +144,8 @@ data class Track(
     if (uriString.contains("local:")) LocalTrackUri(uriString) else TrackUri(uriString),
     externalUrlsString
 ) {
+    override val uri: TrackUri get() = super.uri as TrackUri
+
     @Transient
     val availableMarkets = availableMarketsString.map { CountryCode.valueOf(it) }
 
@@ -166,6 +170,7 @@ data class LinkedTrack(
 
     val type: String
 ) : CoreObject(href, id, TrackUri(uriString), externalUrlsString) {
+    override val uri: TrackUri get() = super.uri as TrackUri
 
     /**
      * Retrieves the full [Track] object associated with this [LinkedTrack] with the given market
diff --git a/src/commonMain/kotlin/com.adamratzman.spotify/models/Users.kt b/src/commonMain/kotlin/com.adamratzman.spotify/models/Users.kt
@@ -40,7 +40,9 @@ data class SpotifyUserInformation(
     val product: String?,
     @SerialName("explicit_content") val explicitContentSettings: ExplicitContentSettings?,
     val type: String
-) : CoreObject(href, id, UserUri(uriString), externalUrlsString)
+) : CoreObject(href, id, UserUri(uriString), externalUrlsString) {
+    override val uri: UserUri get() = super.uri as UserUri
+}
 
 /**
  * Public information about a Spotify user
@@ -63,7 +65,9 @@ data class SpotifyPublicUser(
     val followers: Followers = Followers(null, -1),
     val images: List<SpotifyImage> = listOf(),
     val type: String
-) : CoreObject(href, id, UserUri(uriString), externalUrlsString)
+) : CoreObject(href, id, UserUri(uriString), externalUrlsString) {
+    override val uri: UserUri get() = super.uri as UserUri
+}
 
 /**
  * Information about a Spotify user's followers
diff --git a/src/commonMain/kotlin/com.adamratzman.spotify/models/serialization/SerializationUtils.kt b/src/commonMain/kotlin/com.adamratzman.spotify/models/serialization/SerializationUtils.kt
@@ -9,7 +9,6 @@ import com.adamratzman.spotify.models.CursorBasedPagingObject
 import com.adamratzman.spotify.models.NeedsApi
 import com.adamratzman.spotify.models.PagingObject
 import com.adamratzman.spotify.models.instantiatePagingObjects
-import com.adamratzman.spotify.models.spotifyUriSerializersModule
 import kotlinx.serialization.KSerializer
 import kotlinx.serialization.Serializable
 import kotlinx.serialization.json.Json
@@ -21,7 +20,7 @@ import kotlinx.serialization.serializer
 
 @Suppress("EXPERIMENTAL_API_USAGE")
 internal val json =
-    Json(JsonConfiguration.Stable, spotifyUriSerializersModule)
+    Json(JsonConfiguration.Stable)
     // Json(JsonConfiguration.Stable.copy(strictMode = false, useArrayPolymorphism = true), spotifyUriSerializersModule)
 
 internal inline fun <reified T : Any> String.toObjectNullable(serializer: KSerializer<T>, api: SpotifyApi?): T? = try {
diff --git a/src/commonTest/kotlin/com.adamratzman/spotify/utilities/UrisTests.kt b/src/commonTest/kotlin/com.adamratzman/spotify/utilities/UrisTests.kt
