use std::fmt;
use serde::{Deserialize, Serialize};
macro_rules! wire_display {
($name:ident) => {
impl fmt::Display for $name {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(self.as_str())
}
}
};
}
#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum Language {
#[default]
Ru,
En,
Uk,
Uz,
Us,
Kk,
Hy,
}
impl Language {
#[must_use]
pub fn as_str(self) -> &'static str {
match self {
Self::Ru => "ru",
Self::En => "en",
Self::Uk => "uk",
Self::Uz => "uz",
Self::Us => "us",
Self::Kk => "kk",
Self::Hy => "hy",
}
}
}
wire_display!(Language);
#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum SearchType {
#[default]
All,
Artist,
User,
Album,
Playlist,
Track,
Podcast,
PodcastEpisode,
}
impl SearchType {
#[must_use]
pub fn as_str(self) -> &'static str {
match self {
Self::All => "all",
Self::Artist => "artist",
Self::User => "user",
Self::Album => "album",
Self::Playlist => "playlist",
Self::Track => "track",
Self::Podcast => "podcast",
Self::PodcastEpisode => "podcast_episode",
}
}
}
wire_display!(SearchType);
#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum LyricsFormat {
#[default]
#[serde(rename = "TEXT")]
Text,
#[serde(rename = "LRC")]
Lrc,
}
impl LyricsFormat {
#[must_use]
pub fn as_str(self) -> &'static str {
match self {
Self::Text => "TEXT",
Self::Lrc => "LRC",
}
}
}
wire_display!(LyricsFormat);
#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum Visibility {
#[default]
Public,
Private,
}
impl Visibility {
#[must_use]
pub fn as_str(self) -> &'static str {
match self {
Self::Public => "public",
Self::Private => "private",
}
}
}
wire_display!(Visibility);
#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum SortBy {
#[default]
Year,
Rating,
}
impl SortBy {
#[must_use]
pub fn as_str(self) -> &'static str {
match self {
Self::Year => "year",
Self::Rating => "rating",
}
}
}
wire_display!(SortBy);
#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum SortOrder {
Asc,
#[default]
Desc,
}
impl SortOrder {
#[must_use]
pub fn as_str(self) -> &'static str {
match self {
Self::Asc => "asc",
Self::Desc => "desc",
}
}
}
wire_display!(SortOrder);
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Likeable {
Track,
Artist,
Album,
Playlist,
}
impl Likeable {
#[must_use]
pub fn as_str(self) -> &'static str {
match self {
Self::Track => "track",
Self::Artist => "artist",
Self::Album => "album",
Self::Playlist => "playlist",
}
}
}
wire_display!(Likeable);
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Dislikeable {
Track,
Artist,
}
impl Dislikeable {
#[must_use]
pub fn as_str(self) -> &'static str {
match self {
Self::Track => "track",
Self::Artist => "artist",
}
}
}
wire_display!(Dislikeable);
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum RotorFeedback {
RadioStarted,
TrackStarted,
TrackFinished,
Skip,
}
impl RotorFeedback {
#[must_use]
pub fn as_str(self) -> &'static str {
match self {
Self::RadioStarted => "radioStarted",
Self::TrackStarted => "trackStarted",
Self::TrackFinished => "trackFinished",
Self::Skip => "skip",
}
}
}
wire_display!(RotorFeedback);
#[derive(Debug, Default, Clone, Copy, PartialEq, Eq)]
pub enum MoodEnergy {
#[default]
All,
Fun,
Active,
Calm,
Sad,
}
impl MoodEnergy {
#[must_use]
pub fn as_str(self) -> &'static str {
match self {
Self::All => "all",
Self::Fun => "fun",
Self::Active => "active",
Self::Calm => "calm",
Self::Sad => "sad",
}
}
}
wire_display!(MoodEnergy);
#[derive(Debug, Default, Clone, Copy, PartialEq, Eq)]
pub enum Diversity {
#[default]
Default,
Favorite,
Popular,
Discover,
}
impl Diversity {
#[must_use]
pub fn as_str(self) -> &'static str {
match self {
Self::Default => "default",
Self::Favorite => "favorite",
Self::Popular => "popular",
Self::Discover => "discover",
}
}
}
wire_display!(Diversity);
#[derive(Debug, Default, Clone, Copy, PartialEq, Eq)]
pub enum StationLanguage {
Any,
Russian,
#[default]
NotRussian,
}
impl StationLanguage {
#[must_use]
pub fn as_str(self) -> &'static str {
match self {
Self::Any => "any",
Self::Russian => "russian",
Self::NotRussian => "not-russian",
}
}
}
wire_display!(StationLanguage);
#[derive(Debug, Default, Clone, Copy, PartialEq, Eq)]
pub enum StationType {
#[default]
Rotor,
Generative,
}
impl StationType {
#[must_use]
pub fn as_str(self) -> &'static str {
match self {
Self::Rotor => "rotor",
Self::Generative => "generative",
}
}
}
wire_display!(StationType);
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) enum BatchObject {
Track,
Album,
Artist,
Playlist,
}
impl BatchObject {
pub(crate) fn as_str(self) -> &'static str {
match self {
Self::Track => "track",
Self::Album => "album",
Self::Artist => "artist",
Self::Playlist => "playlist",
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn wire_values_match_what_the_api_expects() {
assert_eq!(SearchType::PodcastEpisode.as_str(), "podcast_episode");
assert_eq!(SearchType::All.as_str(), "all");
assert_eq!(LyricsFormat::Lrc.as_str(), "LRC");
assert_eq!(LyricsFormat::Text.as_str(), "TEXT");
assert_eq!(RotorFeedback::TrackFinished.as_str(), "trackFinished");
assert_eq!(RotorFeedback::RadioStarted.as_str(), "radioStarted");
assert_eq!(StationLanguage::NotRussian.as_str(), "not-russian");
assert_eq!(Visibility::Private.as_str(), "private");
assert_eq!(Language::Ru.as_str(), "ru");
assert_eq!(SortBy::Year.as_str(), "year");
assert_eq!(SortOrder::Desc.as_str(), "desc");
assert_eq!(Likeable::Playlist.as_str(), "playlist");
assert_eq!(Dislikeable::Artist.as_str(), "artist");
assert_eq!(MoodEnergy::All.as_str(), "all");
assert_eq!(Diversity::Default.as_str(), "default");
assert_eq!(StationType::Generative.as_str(), "generative");
assert_eq!(BatchObject::Playlist.as_str(), "playlist");
}
#[test]
fn display_renders_the_wire_value() {
assert_eq!(SearchType::Track.to_string(), "track");
assert_eq!(StationLanguage::NotRussian.to_string(), "not-russian");
assert_eq!(LyricsFormat::Lrc.to_string(), "LRC");
}
#[test]
fn defaults_match_the_api_defaults() {
assert_eq!(Language::default(), Language::Ru);
assert_eq!(SearchType::default(), SearchType::All);
assert_eq!(LyricsFormat::default(), LyricsFormat::Text);
assert_eq!(Visibility::default(), Visibility::Public);
assert_eq!(SortBy::default(), SortBy::Year);
assert_eq!(SortOrder::default(), SortOrder::Desc);
assert_eq!(MoodEnergy::default(), MoodEnergy::All);
assert_eq!(Diversity::default(), Diversity::Default);
assert_eq!(StationLanguage::default(), StationLanguage::NotRussian);
assert_eq!(StationType::default(), StationType::Rotor);
}
}