catch parsing errors

Author: adamint

build.gradle.kts

@@ -14,7 +14,7 @@ plugins {
 }
 
 group = "com.adamratzman"
-version = "3.0.0-rc.3"
+version = "3.0.0-rc.4"
 
 java {
     withSourcesJar()
@@ -253,7 +253,10 @@ tasks {
         archives(javadocJar)
     }
 
-    "publish" {
-        dependsOn(dokka)
+    val publishJvm by registering(Task::class) {
+        dependsOn.add(check)
+        dependsOn.add(dokka)
+        dependsOn.add("publishJvmPublicationToNexusRepository")
     }
+
 }

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

@@ -26,6 +26,7 @@ import com.adamratzman.spotify.utils.Market
 import com.adamratzman.spotify.utils.formatDate
 import kotlinx.serialization.list
 import kotlinx.serialization.serializer
+import kotlin.reflect.KClass
 
 typealias BrowseAPI = BrowseApi
 
@@ -41,9 +42,9 @@ class BrowseApi(api: SpotifyApi<*, *>) : SpotifyEndpoint(api) {
     fun getAvailableGenreSeeds(): SpotifyRestAction<List<String>> {
         return toAction {
             get(EndpointBuilder("/recommendations/available-genre-seeds").toString()).toInnerArray(
-                String.serializer().list,
-                "genres",
-                json
+                    String.serializer().list,
+                    "genres",
+                    json
             )
         }
     }
@@ -66,10 +67,10 @@ class BrowseApi(api: SpotifyApi<*, *>) : SpotifyEndpoint(api) {
     ): SpotifyRestActionPaging<SimpleAlbum, PagingObject<SimpleAlbum>> {
         return toActionPaging {
             get(
-                EndpointBuilder("/browse/new-releases").with("limit", limit).with("offset", offset).with(
-                    "country",
-                    market?.name
-                ).toString()
+                    EndpointBuilder("/browse/new-releases").with("limit", limit).with("offset", offset).with(
+                            "country",
+                            market?.name
+                    ).toString()
             ).toPagingObject(SimpleAlbum.serializer(), "albums", endpoint = this, json = json)
         }
     }
@@ -101,12 +102,12 @@ class BrowseApi(api: SpotifyApi<*, *>) : SpotifyEndpoint(api) {
     ): SpotifyRestAction<FeaturedPlaylists> {
         return toAction {
             get(
-                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()
+                    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()
             ).toObject(FeaturedPlaylists.serializer(), api, json)
         }
     }
@@ -134,10 +135,10 @@ class BrowseApi(api: SpotifyApi<*, *>) : SpotifyEndpoint(api) {
     ): SpotifyRestActionPaging<SpotifyCategory, PagingObject<SpotifyCategory>> {
         return toActionPaging {
             get(
-                EndpointBuilder("/browse/categories").with("limit", limit).with("offset", offset).with(
-                    "market",
-                    market?.name
-                ).with("locale", locale).toString()
+                    EndpointBuilder("/browse/categories").with("limit", limit).with("offset", offset).with(
+                            "market",
+                            market?.name
+                    ).with("locale", locale).toString()
             ).toPagingObject(SpotifyCategory.serializer(), "categories", endpoint = this, json = json)
         }
     }
@@ -162,8 +163,8 @@ class BrowseApi(api: SpotifyApi<*, *>) : SpotifyEndpoint(api) {
     ): SpotifyRestAction<SpotifyCategory> {
         return toAction {
             get(
-                EndpointBuilder("/browse/categories/${categoryId.encodeUrl()}").with("market", market?.name)
-                    .with("locale", locale).toString()
+                    EndpointBuilder("/browse/categories/${categoryId.encodeUrl()}").with("market", market?.name)
+                            .with("locale", locale).toString()
             ).toObject(SpotifyCategory.serializer(), api, json)
         }
     }
@@ -187,11 +188,11 @@ class BrowseApi(api: SpotifyApi<*, *>) : SpotifyEndpoint(api) {
     ): SpotifyRestActionPaging<SimplePlaylist, PagingObject<SimplePlaylist>> {
         return toActionPaging {
             get(
-                EndpointBuilder("/browse/categories/${categoryId.encodeUrl()}/playlists").with(
-                    "limit",
-                    limit
-                ).with("offset", offset)
-                    .with("market", market?.name).toString()
+                    EndpointBuilder("/browse/categories/${categoryId.encodeUrl()}/playlists").with(
+                            "limit",
+                            limit
+                    ).with("offset", offset)
+                            .with("market", market?.name).toString()
             ).toPagingObject(SimplePlaylist.serializer(), "playlists", endpoint = this, json = json)
         }
     }
@@ -237,16 +238,16 @@ class BrowseApi(api: SpotifyApi<*, *>) : SpotifyEndpoint(api) {
         minAttributes: List<TrackAttribute<*>> = listOf(),
         maxAttributes: List<TrackAttribute<*>> = listOf()
     ): SpotifyRestAction<RecommendationResponse> =
-        getRecommendations(
-            seedArtists,
-            seedGenres,
-            seedTracks,
-            limit,
-            market,
-            targetAttributes.map { it.tuneableTrackAttribute to it.value }.toMap(),
-            minAttributes.map { it.tuneableTrackAttribute to it.value }.toMap(),
-            maxAttributes.map { it.tuneableTrackAttribute to it.value }.toMap()
-        )
+            getRecommendations(
+                    seedArtists,
+                    seedGenres,
+                    seedTracks,
+                    limit,
+                    market,
+                    targetAttributes.map { it.tuneableTrackAttribute to it.value }.toMap(),
+                    minAttributes.map { it.tuneableTrackAttribute to it.value }.toMap(),
+                    maxAttributes.map { it.tuneableTrackAttribute to it.value }.toMap()
+            )
 
     /**
      * Create a playlist-style listening experience based on seed artists, tracks and genres.
@@ -292,18 +293,18 @@ class BrowseApi(api: SpotifyApi<*, *>) : SpotifyEndpoint(api) {
     ): SpotifyRestAction<RecommendationResponse> {
         if (seedArtists?.isEmpty() != false && seedGenres?.isEmpty() != false && seedTracks?.isEmpty() != false) {
             throw SpotifyException.BadRequestException(
-                ErrorObject(
-                    400,
-                    "At least one seed (genre, artist, track) must be provided."
-                )
+                    ErrorObject(
+                            400,
+                            "At least one seed (genre, artist, track) must be provided."
+                    )
             )
         }
 
         return toAction {
             val builder = EndpointBuilder("/recommendations").with("limit", limit).with("market", market?.name)
-                .with("seed_artists", seedArtists?.joinToString(",") { ArtistUri(it).id.encodeUrl() })
-                .with("seed_genres", seedGenres?.joinToString(",") { it.encodeUrl() })
-                .with("seed_tracks", seedTracks?.joinToString(",") { TrackUri(it).id.encodeUrl() })
+                    .with("seed_artists", seedArtists?.joinToString(",") { ArtistUri(it).id.encodeUrl() })
+                    .with("seed_genres", seedGenres?.joinToString(",") { it.encodeUrl() })
+                    .with("seed_tracks", seedTracks?.joinToString(",") { TrackUri(it).id.encodeUrl() })
             targetAttributes.forEach { (attribute, value) -> builder.with("target_$attribute", value) }
             minAttributes.forEach { (attribute, value) -> builder.with("min_$attribute", value) }
             maxAttributes.forEach { (attribute, value) -> builder.with("max_$attribute", value) }
@@ -321,33 +322,34 @@ sealed class TuneableTrackAttribute<T : Number>(
     val attribute: String,
     val integerOnly: Boolean,
     val min: T?,
-    val max: T?
+    val max: T?,
+    val tClazz: KClass<T>
 ) {
     /**
      * A confidence measure from 0.0 to 1.0 of whether the track is acoustic.
      * 1.0 represents high confidence the track is acoustic.
      */
-    object ACOUSTICNESS : TuneableTrackAttribute<Float>("acousticness", false, 0f, 1f)
+    object ACOUSTICNESS : TuneableTrackAttribute<Float>("acousticness", false, 0f, 1f, Float::class)
 
     /**
      * Danceability describes how suitable a track is for dancing based on a combination of musical
      * elements including tempo, rhythm stability, beat strength, and overall regularity. A value of 0.0 is
      * least danceable and 1.0 is most danceable.
      */
-    object DANCEABILITY : TuneableTrackAttribute<Float>("danceability", false, 0f, 1f)
+    object DANCEABILITY : TuneableTrackAttribute<Float>("danceability", false, 0f, 1f, Float::class)
 
     /**
      * The duration of the track in milliseconds.
      */
-    object DURATION_IN_MILLISECONDS : TuneableTrackAttribute<Int>("duration_ms", true, 0, null)
+    object DURATION_IN_MILLISECONDS : TuneableTrackAttribute<Int>("duration_ms", true, 0, null, Int::class)
 
     /**
      * Energy is a measure from 0.0 to 1.0 and represents a perceptual measure of intensity and activity.
      * Typically, energetic tracks feel fast, loud, and noisy. For example, death metal has high energy,
      * while a Bach prelude scores low on the scale. Perceptual features contributing to this attribute
      * include dynamic range, perceived loudness, timbre, onset rate, and general entropy.
      */
-    object ENERGY : TuneableTrackAttribute<Float>("energy", false, 0f, 1f)
+    object ENERGY : TuneableTrackAttribute<Float>("energy", false, 0f, 1f, Float::class)
 
     /**
      * Predicts whether a track contains no vocals. “Ooh” and “aah” sounds are treated as
@@ -356,34 +358,34 @@ sealed class TuneableTrackAttribute<T : Number>(
      * no vocal content. Values above 0.5 are intended to represent instrumental tracks, but
      * confidence is higher as the value approaches 1.0.
      */
-    object INSTRUMENTALNESS : TuneableTrackAttribute<Float>("instrumentalness", false, 0f, 1f)
+    object INSTRUMENTALNESS : TuneableTrackAttribute<Float>("instrumentalness", false, 0f, 1f, Float::class)
 
     /**
      * The key the track is in. Integers map to pitches using standard Pitch Class notation.
      * E.g. 0 = C, 1 = C♯/D♭, 2 = D, and so on.
      */
-    object KEY : TuneableTrackAttribute<Int>("key", true, 0, 11)
+    object KEY : TuneableTrackAttribute<Int>("key", true, 0, 11, Int::class)
 
     /**
      * Detects the presence of an audience in the recording. Higher liveness values represent an increased
      * probability that the track was performed live. A value above 0.8 provides strong likelihood
      * that the track is live.
      */
-    object LIVENESS : TuneableTrackAttribute<Float>("liveness", false, 0f, 1f)
+    object LIVENESS : TuneableTrackAttribute<Float>("liveness", false, 0f, 1f, Float::class)
 
     /**
      * The overall loudness of a track in decibels (dB). Loudness values are averaged across the
      * entire track and are useful for comparing relative loudness of tracks. Loudness is the
      * quality of a sound that is the primary psychological correlate of physical strength (amplitude).
      * Values typically range between -60 and 0 db.
      */
-    object LOUDNESS : TuneableTrackAttribute<Float>("loudness", false, null, null)
+    object LOUDNESS : TuneableTrackAttribute<Float>("loudness", false, null, null, Float::class)
 
     /**
      * Mode indicates the modality (major or minor) of a track, the type of scale from which its
      * melodic content is derived. Major is represented by 1 and minor is 0.
      */
-    object MODE : TuneableTrackAttribute<Int>("mode", true, 0, 1)
+    object MODE : TuneableTrackAttribute<Int>("mode", true, 0, 1, Int::class)
 
     /**
      * The popularity of the track. The value will be between 0 and 100, with 100 being the most popular.
@@ -392,7 +394,7 @@ sealed class TuneableTrackAttribute<T : Number>(
      * the market parameter, it is expected to find relinked tracks with popularities that do not match
      * min_*, max_*and target_* popularities. These relinked tracks are accurate replacements for unplayable tracks with the expected popularity scores. Original, non-relinked tracks are available via the linked_from attribute of the relinked track response.
      */
-    object POPULARITY : TuneableTrackAttribute<Int>("popularity", true, 0, 100)
+    object POPULARITY : TuneableTrackAttribute<Int>("popularity", true, 0, 100, Int::class)
 
     /**
      * Speechiness detects the presence of spoken words in a track. The more exclusively speech-like the
@@ -402,61 +404,67 @@ sealed class TuneableTrackAttribute<T : Number>(
      * such cases as rap music. Values below 0.33 most likely represent music and other non-speech-like
      * tracks.
      */
-    object SPEECHINESS : TuneableTrackAttribute<Float>("speechiness", false, 0f, 1f)
+    object SPEECHINESS : TuneableTrackAttribute<Float>("speechiness", false, 0f, 1f, Float::class)
 
     /**
      * The overall estimated tempo of a track in beats per minute (BPM). In musical terminology, tempo is the
      * speed or pace of a given piece and derives directly from the average beat duration.
      */
-    object TEMPO : TuneableTrackAttribute<Float>("tempo", false, 0f, null)
+    object TEMPO : TuneableTrackAttribute<Float>("tempo", false, 0f, null, Float::class)
 
     /**
      * An estimated overall time signature of a track. The time signature (meter)
      * is a notational convention to specify how many beats are in each bar (or measure).
      * The time signature ranges from 3 to 7 indicating time signatures of 3/4, to 7/4.
      * A value of -1 may indicate no time signature, while a value of 1 indicates a rather complex or changing time signature.
      */
-    object TIME_SIGNATURE : TuneableTrackAttribute<Int>("time_signature", true, -1, 7)
+    object TIME_SIGNATURE : TuneableTrackAttribute<Int>("time_signature", true, -1, 7, Int::class)
 
     /**
      * A measure from 0.0 to 1.0 describing the musical positiveness conveyed by a track. Tracks with high
      * valence sound more positive (e.g. happy, cheerful, euphoric), while tracks with low valence
      * sound more negative (e.g. sad, depressed, angry).
      */
-    object VALENCE : TuneableTrackAttribute<Float>("valence", false, 0f, 1f)
+    object VALENCE : TuneableTrackAttribute<Float>("valence", false, 0f, 1f, Float::class)
 
     override fun toString() = attribute
 
-    fun asTrackAttribute(value: T): TrackAttribute<T> {
+    fun <V : Number> asTrackAttribute(value: V): TrackAttribute<T> {
         require(!(min != null && min.toDouble() > value.toDouble())) { "Attribute value for $this must be greater than $min!" }
         require(!(max != null && max.toDouble() < value.toDouble())) { "Attribute value for $this must be less than $max!" }
 
-        return TrackAttribute(this, value)
+        @Suppress("UNCHECKED_CAST")
+        return TrackAttribute(this, when (tClazz) {
+            Int::class -> value.toInt() as T
+            Float::class -> value.toFloat() as T
+            Double::class -> value.toDouble() as T
+            else -> value.toDouble() as T
+        })
     }
 
     companion object {
         fun values() = listOf(
-            ACOUSTICNESS,
-            DANCEABILITY,
-            DURATION_IN_MILLISECONDS,
-            ENERGY,
-            INSTRUMENTALNESS,
-            KEY,
-            LIVENESS,
-            LOUDNESS,
-            MODE,
-            POPULARITY,
-            SPEECHINESS,
-            TEMPO,
-            TIME_SIGNATURE,
-            VALENCE
+                ACOUSTICNESS,
+                DANCEABILITY,
+                DURATION_IN_MILLISECONDS,
+                ENERGY,
+                INSTRUMENTALNESS,
+                KEY,
+                LIVENESS,
+                LOUDNESS,
+                MODE,
+                POPULARITY,
+                SPEECHINESS,
+                TEMPO,
+                TIME_SIGNATURE,
+                VALENCE
         )
     }
 }
 
 data class TrackAttribute<T : Number>(val tuneableTrackAttribute: TuneableTrackAttribute<T>, val value: T) {
     companion object {
         fun <T : Number> create(tuneableTrackAttribute: TuneableTrackAttribute<T>, value: T) =
-            tuneableTrackAttribute.asTrackAttribute(value)
+                tuneableTrackAttribute.asTrackAttribute(value)
     }
 }