correctly classify javadoc jar in publication, fix user collection parsing

Author: adamint

build.gradle.kts

@@ -73,6 +73,7 @@ val dokkaJar: TaskProvider<Jar> by tasks.registering(Jar::class) {
     group = JavaBasePlugin.DOCUMENTATION_GROUP
     description = "spotify-web-api-kotlin generated documentation"
     from(tasks.dokkaHtml)
+    archiveClassifier.set("javadoc")
 }
 
 kotlin {
@@ -151,10 +152,6 @@ kotlin {
         mavenPublication { setupPom(artifactId) }
     }*/
 
-    publishing {
-        registerPublishing()
-    }
-
     targets {
         sourceSets {
             val kotlinxDatetimeVersion: String by project
@@ -298,6 +295,10 @@ kotlin {
     }
 }
 
+publishing {
+    registerPublishing()
+}
+
 tasks {
     val dokkaHtml by getting(DokkaTask::class) {
         outputDirectory.set(projectDir.resolve("docs"))
@@ -354,7 +355,7 @@ tasks {
 
 fun MavenPublication.setupPom(publicationName: String) {
     artifactId = artifactId.replace("-web", "")
-    artifact(dokkaJar.get())
+    artifact(dokkaJar.get()) // add javadocs to publication
 
     pom {
         name.set(publicationName)

src/commonMain/kotlin/com.adamratzman.spotify/models/SpotifyUris.kt

@@ -24,15 +24,20 @@ private fun String.matchType(type: String, allowColon: Boolean): String? {
     return match[1].takeIf { it.isNotBlank() || match[2].isEmpty() } ?: match[2].takeIf { it.isNotEmpty() }
 }
 
+private fun String.matchesUserCollectionUri() = this.matches("^spotify:user:([^:]+):collection".toRegex())
+
 private fun String.add(type: String, allowColon: Boolean): String {
-    this.matchType(type, allowColon)?.let {
+    if (type == UserCollectionUriType && matchesUserCollectionUri()) return this
+    else this.matchType(type, allowColon)?.let {
         return "spotify:$type:${it.trim()}"
     }
     throw SpotifyUriException("Illegal Spotify ID/URI: '$this' isn't convertible to '$type' uri")
 }
 
 private fun String.remove(type: String, allowColon: Boolean): String {
-    this.matchType(type, allowColon)?.let {
+    println(type)
+    if (type == UserCollectionUriType && matchesUserCollectionUri()) return "collection"
+    else this.matchType(type, allowColon)?.let {
         return it.trim()
     }
     throw SpotifyUriException("Illegal Spotify ID/URI: '$this' isn't convertible to '$type' id")
@@ -112,7 +117,7 @@ public sealed class SpotifyUri(input: String, public val type: String, allowColo
             val constructors = listOf(
                 ::ArtistUri,
                 PlayableUri.Companion::invoke,
-                ImmutableCollectionUri.Companion::invoke,
+                CollectionUri.Companion::invoke,
                 ::UserUri,
                 ::PlaylistUri
             )
@@ -178,7 +183,7 @@ public sealed class CollectionUri(input: String, type: String, allowColon: Boole
          * Creates an abstract [CollectionUri] of given input. Prefers [PlaylistUri] if the input is ambiguous.
          */
         public operator fun invoke(input: String): CollectionUri {
-            val constructors = listOf(::PlaylistUri, ImmutableCollectionUri.Companion::invoke)
+            val constructors = listOf(::PlaylistUri, ::UserCollectionUri, ImmutableCollectionUri.Companion::invoke)
             for (ctor in constructors) {
                 safeInitiate(input, ctor)?.also { return it }
             }
@@ -372,9 +377,24 @@ public object ShowUriSerializer : KSerializer<ShowUri> by SimpleUriSerializer(::
  */
 public fun String.toShowUri(): ShowUri = ShowUri(this)
 
+private const val UserCollectionUriType = "UserCollectionUri"
+
+/**
+ * Represents a Spotify **User Collection URI** URI (spotify:user:XXXX:collection), parsed from either a Spotify ID or taken from an endpoint.
+ * It appears that this URI corresponds to the user's saved tracks collection in their library.
+ */
+@Serializable(with = UserCollectionUriSerializer::class)
+public class UserCollectionUri(input: String) : CollectionUri(input, UserCollectionUriType), ContextUri
+public object UserCollectionUriSerializer : KSerializer<UserCollectionUri> by SimpleUriSerializer(::UserCollectionUri)
+
 /**
- * Represents a Spotify **Context** URI (one of [AlbumUri], [ArtistUri], [PlaylistUri], or [ShowUri]),
-*/
+ * Convert a show id or uri string to a [ShowUri] object
+ */
+public fun String.toUserCollectionUri(): UserCollectionUri = UserCollectionUri(this)
+
+/**
+ * Represents a Spotify **Context** URI (one of [AlbumUri], [ArtistUri], [PlaylistUri], [UserCollectionUri], or [ShowUri]),
+ */
 @Serializable(with = ContextUriSerializer::class)
 public interface ContextUri : ISpotifyUri {
     public companion object {

src/commonTest/kotlin/com.adamratzman/spotify/utilities/UrisTests.kt

@@ -9,6 +9,7 @@ import com.adamratzman.spotify.models.PlaylistUri
 import com.adamratzman.spotify.models.SpotifyTrackUri
 import com.adamratzman.spotify.models.SpotifyUri
 import com.adamratzman.spotify.models.SpotifyUriException
+import com.adamratzman.spotify.models.UserCollectionUri
 import com.adamratzman.spotify.models.UserUri
 import kotlin.test.Test
 import kotlin.test.assertEquals
@@ -185,6 +186,45 @@ class UrisTests {
         )
     }
 
+    @Test
+    fun testUserCollectionUri() {
+        assertFailsWith<SpotifyUriException> {
+            UserCollectionUri("a:invalid")
+        }
+
+        assertFailsWith<SpotifyUriException> {
+            UserCollectionUri("a:invalid").uri
+        }
+
+        assertFailsWith<SpotifyUriException> {
+            UserCollectionUri("a:invalid").id
+        }
+
+        assertFailsWith<SpotifyUriException> {
+            UserCollectionUri("spotify:user:testuser").uri
+        }
+
+        assertEquals(
+            "spotify:user:adamratzman1:collection",
+            UserCollectionUri("spotify:user:adamratzman1:collection").uri
+        )
+
+        assertEquals(
+            "spotify:user:adamratzman1:collection",
+            UserCollectionUri("spotify:user:adamratzman1:collection").uri
+        )
+
+        assertEquals(
+            UserCollectionUri::class,
+            SpotifyUri("spotify:user:adamratzman1:collection")::class
+        )
+
+        assertEquals(
+            "collection",
+            UserCollectionUri("spotify:user:adamratzman1:collection").id
+        )
+    }
+
     @Test
     fun testPlaylistUri() {
         assertFailsWith<SpotifyUriException> {