use std::fmt;
use serde::{Deserialize, Serialize};
pub mod account;
pub mod album;
pub mod artist;
pub mod clip;
pub mod concert;
pub mod credit;
pub mod device_auth;
pub mod disclaimer;
pub mod feed;
pub mod genre;
pub mod label;
pub mod landing;
pub mod like;
pub mod metatag;
pub mod misc;
pub mod music_history;
pub mod pin;
pub mod playlist;
pub mod presaves;
pub mod queue;
pub mod rotor;
pub mod search;
pub mod shot;
pub mod supplement;
pub mod track;
pub mod user;
pub mod video;
pub use account::*;
pub use album::*;
pub use artist::*;
pub use clip::*;
pub use concert::*;
pub use credit::*;
pub use device_auth::*;
pub use disclaimer::*;
pub use feed::*;
pub use genre::*;
pub use label::*;
pub use landing::*;
pub use like::*;
pub use metatag::*;
pub use misc::*;
pub use music_history::*;
pub use pin::*;
pub use playlist::*;
pub use presaves::*;
pub use queue::*;
pub use rotor::*;
pub use search::*;
pub use shot::*;
pub use supplement::*;
pub use track::*;
pub use user::*;
pub use video::*;
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(untagged)]
pub enum Id {
Number(i64),
Text(String),
}
impl Id {
#[must_use]
pub fn as_number(&self) -> Option<i64> {
match self {
Self::Number(n) => Some(*n),
Self::Text(s) => crate::sign::track_id_to_number(s),
}
}
}
impl fmt::Display for Id {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::Number(n) => write!(f, "{n}"),
Self::Text(s) => f.write_str(s),
}
}
}
impl From<i64> for Id {
fn from(value: i64) -> Self {
Self::Number(value)
}
}
impl From<String> for Id {
fn from(value: String) -> Self {
Self::Text(value)
}
}
impl From<&str> for Id {
fn from(value: &str) -> Self {
Self::Text(value.to_owned())
}
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(untagged)]
pub enum FlagOrList {
Flag(bool),
List(Vec<serde_json::Value>),
}
impl FlagOrList {
#[must_use]
pub fn is_set(&self) -> bool {
match self {
Self::Flag(flag) => *flag,
Self::List(items) => !items.is_empty(),
}
}
#[must_use]
pub fn list(&self) -> &[serde_json::Value] {
match self {
Self::Flag(_) => &[],
Self::List(items) => items,
}
}
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct CoverDerivedColors {
pub average: Option<String>,
pub wave_text: Option<String>,
pub mini_player: Option<String>,
pub accent: Option<String>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct Cover {
pub r#type: Option<String>,
pub uri: Option<String>,
pub items_uri: Vec<String>,
pub dir: Option<String>,
pub version: Option<String>,
pub custom: Option<bool>,
pub is_custom: Option<bool>,
pub copyright_name: Option<String>,
pub copyright_cline: Option<String>,
pub prefix: Option<String>,
pub error: Option<String>,
pub color: Option<String>,
pub derived_colors: Option<CoverDerivedColors>,
pub video_url: Option<String>,
}
impl Cover {
#[must_use]
pub fn url(&self, size: &str) -> Option<String> {
self.uri
.as_deref()
.map(|uri| normalize_image_url(uri, size))
}
}
#[must_use]
pub fn normalize_image_url(uri: &str, size: &str) -> String {
let sized = uri.replace("%%", size);
if sized.starts_with("//") {
format!("https:{sized}")
} else if sized.starts_with("http://") || sized.starts_with("https://") {
sized
} else {
format!("https://{sized}")
}
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct Icon {
pub background_color: Option<String>,
pub image_url: Option<String>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct Link {
pub title: Option<String>,
pub href: Option<String>,
pub url: Option<String>,
pub img_url: Option<String>,
pub subtitle: Option<String>,
pub r#type: Option<String>,
pub social_network: Option<String>,
}
impl Link {
#[must_use]
pub fn target(&self) -> Option<&str> {
self.href.as_deref().or(self.url.as_deref())
}
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct ContentRestrictions {
pub available: Option<bool>,
pub disclaimers: Vec<String>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct ExtraAction {
pub r#type: Option<String>,
pub title: Option<String>,
pub color: Option<String>,
pub url: Option<String>,
}
#[derive(Debug, Default, Clone, Copy, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct Pager {
pub total: Option<u32>,
pub page: Option<u32>,
pub per_page: Option<u32>,
}
impl Pager {
#[must_use]
pub fn has_next(&self) -> bool {
match (self.total, self.page, self.per_page) {
(Some(total), Some(page), Some(per_page)) if per_page > 0 => {
(page + 1) * per_page < total
},
_ => false,
}
}
pub(crate) fn has_next_after(&self, expected: u32) -> bool {
match (self.total, self.per_page) {
(Some(total), Some(per_page)) if per_page > 0 => (expected + 1) * per_page < total,
_ => false,
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn ids_accept_both_json_shapes() {
assert_eq!(serde_json::from_str::<Id>("42").unwrap(), Id::Number(42));
assert_eq!(
serde_json::from_str::<Id>(r#""42""#).unwrap(),
Id::Text("42".into())
);
assert_eq!(
serde_json::from_str::<Id>(r#""42:1001""#).unwrap(),
Id::Text("42:1001".into())
);
}
#[test]
fn ids_render_and_normalize() {
assert_eq!(Id::Number(42).to_string(), "42");
assert_eq!(Id::Text("42:1001".into()).to_string(), "42:1001");
assert_eq!(Id::Number(42).as_number(), Some(42));
assert_eq!(Id::Text("42:1001".into()).as_number(), Some(42));
assert_eq!(Id::Text("nope".into()).as_number(), None);
}
#[test]
fn image_urls_normalize_every_scheme_the_api_sends() {
assert_eq!(
normalize_image_url("avatars.yandex.net/get-music/%%", "400x400"),
"https://avatars.yandex.net/get-music/400x400"
);
assert_eq!(
normalize_image_url("//avatars.yandex.net/%%", "50x50"),
"https://avatars.yandex.net/50x50"
);
assert_eq!(
normalize_image_url("https://avatars.yandex.net/%%", "1000x1000"),
"https://avatars.yandex.net/1000x1000"
);
assert_eq!(
normalize_image_url("http://host/%%", "1x1"),
"http://host/1x1"
);
}
#[test]
fn a_mosaic_cover_has_no_single_url() {
let cover: Cover =
serde_json::from_str(r#"{"type":"mosaic","itemsUri":["a/%%","b/%%"]}"#).unwrap();
assert!(cover.url("100x100").is_none());
assert_eq!(cover.items_uri.len(), 2);
}
#[test]
fn links_report_whichever_url_key_arrived() {
let with_href: Link = serde_json::from_str(r#"{"href":"https://a"}"#).unwrap();
let with_url: Link = serde_json::from_str(r#"{"url":"https://b"}"#).unwrap();
let neither: Link = serde_json::from_str("{}").unwrap();
assert_eq!(with_href.target(), Some("https://a"));
assert_eq!(with_url.target(), Some("https://b"));
assert_eq!(neither.target(), None);
}
#[test]
fn pager_detects_a_following_page() {
let mid = Pager {
total: Some(100),
page: Some(0),
per_page: Some(20),
};
let last = Pager {
total: Some(100),
page: Some(4),
per_page: Some(20),
};
let exact = Pager {
total: Some(40),
page: Some(1),
per_page: Some(20),
};
assert!(mid.has_next());
assert!(!last.has_next());
assert!(!exact.has_next());
assert!(!Pager::default().has_next());
assert!(
!Pager {
total: Some(10),
page: Some(0),
per_page: Some(0)
}
.has_next()
);
}
#[test]
fn models_tolerate_an_empty_object() {
serde_json::from_str::<Cover>("{}").unwrap();
serde_json::from_str::<Link>("{}").unwrap();
serde_json::from_str::<Icon>("{}").unwrap();
serde_json::from_str::<Pager>("{}").unwrap();
serde_json::from_str::<ContentRestrictions>("{}").unwrap();
serde_json::from_str::<ExtraAction>("{}").unwrap();
serde_json::from_str::<CoverDerivedColors>("{}").unwrap();
}
#[test]
fn unknown_fields_are_ignored_rather_than_fatal() {
let cover: Cover =
serde_json::from_str(r#"{"uri":"a/%%","brandNewFieldFromUpstream":123}"#).unwrap();
assert_eq!(cover.uri.as_deref(), Some("a/%%"));
}
}