refactor: code

* separate some code to new modules
* make new artist redirect match case-insensitive (last.fm ignores cases)
* use LazyLock to store a global reqwest client
* use Display over ToString
* make listenbrainz's `ListenType` an enum
* remove some unneeded spotify json variables
* remove some unneeded clones
* update the colored dependency

Author: flazepe

Cargo.toml

@@ -5,7 +5,7 @@ edition = "2021"
 
 [dependencies]
 anyhow = "1"
-colored = "2"
+colored = "3"
 md5 = "0.7"
 reqwest = { version = "0.12", features = ["blocking", "json"] }
 serde = { version = "1", features = ["derive"] }

config.example.toml

@@ -2,7 +2,7 @@
 user_id = 8834263 # Your osu! user ID
 mode = "osu" # (optional) The osu! mode to scrobble. Possible values: "osu", "taiko", "fruits", "mania"
 use_original_metadata = true # (optional) Whether to use original metadata instead of romanized metadata
-use_spotify_metadata = false # Whether to use metadata matching local Spotify, if exists. This option ignores the option above
+use_spotify_metadata = false # Whether to use metadata matching local Spotify, if exists. If set to true, the option above is ignored
 min_beatmap_length_secs = 60 # (optional) The minimum beatmap length to scrobble (in seconds)
 log_scrobbles = false # (optional) Whether to log scrobbles to a file
 artist_redirects = [ # (optional) An array of tuples that contain the old and new artist name to replace with before scrobbling
@@ -18,4 +18,4 @@ api_secret = "api_secret" # Your Last.fm API secret
 
 # This section can be omitted if you do not use ListenBrainz
 [listenbrainz]
-user_token = "user_token" # Your ListenBrainz user token
+user_token = "user_token" # Your ListenBrainz user token

src/scrobbler/last_fm/mod.rs

@@ -1,17 +1,16 @@
 mod queries;
 
-use crate::{exit, logger::log_success};
+use crate::{exit, logger::log_success, scrobbler::REQWEST};
 use anyhow::{bail, Result};
 use colored::Colorize;
 use queries::LastfmQuery;
-use reqwest::{blocking::Client, StatusCode};
+use reqwest::StatusCode;
 use serde::Deserialize;
 use std::time::{SystemTime, UNIX_EPOCH};
 
 const API_BASE_URL: &str = "https://ws.audioscrobbler.com/2.0/";
 
 pub struct LastfmScrobbler {
-    pub client: Client,
     pub api_key: String,
     pub api_secret: String,
     pub session_key: String,
@@ -30,9 +29,7 @@ struct LastfmSessionData {
 
 impl LastfmScrobbler {
     pub fn new(username: String, password: String, api_key: String, api_secret: String) -> Self {
-        let client = Client::new();
-
-        let response = client
+        let response = REQWEST
             .post(API_BASE_URL)
             .header("content-length", "0")
             .query(
@@ -49,12 +46,11 @@ impl LastfmScrobbler {
         let Ok(session) = response else { exit!("Last.fm", "Invalid credentials provided.") };
         log_success("Last.fm", format!("Successfully authenticated with username {}.", session.session.name.bright_blue()));
 
-        Self { client, api_key, api_secret, session_key: session.session.key }
+        Self { api_key, api_secret, session_key: session.session.key }
     }
 
     pub fn scrobble(&self, artist: &str, title: &str, album: Option<&str>, total_length: u32) -> Result<()> {
-        let status = self
-            .client
+        let status = REQWEST
             .post(API_BASE_URL)
             .header("content-length", "0")
             .query(

src/scrobbler/listenbrainz/mod.rs

@@ -1,16 +1,15 @@
 mod payloads;
 
-use crate::{exit, logger::log_success};
+use crate::{exit, logger::log_success, scrobbler::REQWEST};
 use anyhow::{bail, Result};
 use colored::Colorize;
-use payloads::{Listen, Listens};
-use reqwest::{blocking::Client, StatusCode};
+use payloads::{Listen, ListenType, Listens};
+use reqwest::StatusCode;
 use serde::Deserialize;
 
 const API_BASE_URL: &str = "https://api.listenbrainz.org/1";
 
 pub struct ListenBrainzScrobbler {
-    pub client: Client,
     pub user_token: String,
 }
 
@@ -22,10 +21,7 @@ struct ListenBrainzToken {
 impl ListenBrainzScrobbler {
     pub fn new(user_token: String) -> Self {
         let user_token = format!("Token {user_token}");
-
-        let client = Client::new();
-
-        let response = client
+        let response = REQWEST
             .get(format!("{API_BASE_URL}/validate-token"))
             .header("authorization", &user_token)
             .send()
@@ -34,15 +30,14 @@ impl ListenBrainzScrobbler {
         let Ok(token) = response else { exit!("ListenBrainz", "Invalid user token provided.") };
         log_success("ListenBrainz", format!("Successfully authenticated with username {}.", token.user_name.bright_blue()));
 
-        Self { client, user_token }
+        Self { user_token }
     }
 
     pub fn scrobble(&self, artist: &str, title: &str, album: Option<&str>, total_length: u32) -> Result<()> {
-        let status = self
-            .client
+        let status = REQWEST
             .post(format!("{API_BASE_URL}/submit-listens"))
             .header("authorization", &self.user_token)
-            .json(&Listens::new("single", vec![Listen::new(artist, title, album, total_length)]))
+            .json(&Listens::new(ListenType::Single, vec![Listen::new(artist, title, album, total_length)]))
             .send()?
             .status();
 

src/scrobbler/listenbrainz/payloads.rs

@@ -6,13 +6,19 @@ use std::{
 
 #[derive(Serialize)]
 pub struct Listens {
-    pub listen_type: String,
+    pub listen_type: ListenType,
     pub payload: Vec<Listen>,
 }
 
+#[derive(Serialize)]
+#[serde(rename_all = "lowercase")]
+pub enum ListenType {
+    Single,
+}
+
 impl Listens {
-    pub fn new<T: ToString>(listen_type: T, listens: Vec<Listen>) -> Self {
-        Self { listen_type: listen_type.to_string(), payload: listens }
+    pub fn new(listen_type: ListenType, listens: Vec<Listen>) -> Self {
+        Self { listen_type, payload: listens }
     }
 }
 
@@ -77,7 +83,7 @@ pub struct TrackAdditionalInfo {
 }
 
 impl TrackAdditionalInfo {
-    pub fn new<T: ToString, U: ToString, V: ToString>(
+    pub fn new<T: Display, U: Display, V: Display>(
         media_player: T,
         submission_client: U,
         submission_client_version: V,

src/scrobbler/mod.rs

@@ -10,7 +10,10 @@ use crate::{
     spotify::Spotify,
 };
 use colored::Colorize;
-use std::{thread::sleep, time::Duration};
+use reqwest::blocking::Client;
+use std::{sync::LazyLock, thread::sleep, time::Duration};
+
+static REQWEST: LazyLock<Client> = LazyLock::new(Client::new);
 
 pub struct Scrobbler {
     config: ScrobblerConfig,
@@ -103,22 +106,21 @@ impl Scrobbler {
             .as_ref()
             .and_then(|artist_redirects| {
                 artist_redirects.iter().find(|(old, new)| {
-                    [artist_original.to_lowercase(), artist_romanized.to_lowercase()].contains(&old.to_lowercase()) && new != &artist
+                    [artist_original.to_lowercase(), artist_romanized.to_lowercase()].contains(&old.to_lowercase())
+                        && new.to_lowercase() != artist.to_lowercase()
                 })
             })
-            .map_or_else(
-                || "".into(),
-                |(old, new)| {
-                    artist = new.clone();
-                    format!(" (redirected from {})", old.bright_blue())
-                },
-            );
+            .map(|(old, new)| {
+                artist = new.clone();
+                format!(" (redirected from {})", old.bright_blue())
+            });
 
         log_success(
             "Scrobbler",
             format!(
-                "New score found: {}{redirected_text} - {} ({})",
+                "New score found: {}{} - {} ({})",
                 artist.bright_blue(),
+                redirected_text.as_deref().unwrap_or(""),
                 title.bright_blue(),
                 album.as_deref().unwrap_or("Unknown Album").bright_blue(),
             ),

src/spotify.rs renamed to src/spotify/mod.rs

@@ -1,7 +1,10 @@
+mod payloads;
+
 use crate::scores::Beatmapset;
 use anyhow::{bail, Context, Result};
+use payloads::{SpotifyArtist, SpotifyData, SpotifySearchResult, SpotifyToken, SpotifyTrack};
 use reqwest::blocking::Client;
-use serde::Deserialize;
+
 use serde_json::json;
 use std::time::{SystemTime, UNIX_EPOCH};
 
@@ -45,18 +48,13 @@ impl Spotify {
             "searchTerm": format!("{} - {}", beatmapset.artist_unicode, beatmapset.title_unicode),
             "offset": 0,
             "limit": 20,
-            "numberOfTopResults": 20,
-            "includeAudiobooks": false,
-            "includePreReleases": false,
         });
-
         let extensions = json!({
             "persistedQuery": {
                 "version": 1,
                 "sha256Hash": "220d098228a4eaf216b39e8c147865244959c4cc6fd82d394d88afda0b710929",
             },
         });
-
         let json = self
             .client
             .get("https://api-partner.spotify.com/pathfinder/v1/query")
@@ -79,80 +77,12 @@ impl Spotify {
             }
 
             return Ok(SpotifyTrack {
-                artist: artist.profile.name.clone(),
-                title: track.item.data.name.clone(),
-                album: track.item.data.album_of_track.name.clone(),
+                artist: artist.profile.name,
+                title: track.item.data.name,
+                album: track.item.data.album_of_track.name,
             });
         }
 
         bail!("Could not find track.");
     }
 }
-
-#[derive(Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct SpotifyToken {
-    pub access_token: String,
-    pub access_token_expiration_timestamp_ms: u128,
-}
-
-#[derive(Deserialize)]
-pub struct SpotifyTrack {
-    pub artist: String,
-    pub title: String,
-    pub album: String,
-}
-
-// Generics
-#[derive(Deserialize)]
-pub struct SpotifyData<T> {
-    data: T,
-}
-
-#[derive(Deserialize)]
-pub struct SpotifyItems<T> {
-    items: Vec<T>,
-}
-
-#[derive(Deserialize)]
-pub struct SpotifyItem<T> {
-    item: T,
-}
-
-// Search
-#[derive(Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct SpotifySearchResult {
-    search_v2: SpotifySearchV2,
-}
-
-#[derive(Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct SpotifySearchV2 {
-    tracks_v2: SpotifyItems<SpotifyItem<SpotifyData<SpotifyTrackItem>>>,
-}
-
-#[derive(Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct SpotifyTrackItem {
-    name: String,
-    album_of_track: SpotifyAlbum,
-    artists: SpotifyItems<SpotifyArtist>,
-}
-
-// Album
-#[derive(Deserialize)]
-pub struct SpotifyAlbum {
-    name: String,
-}
-
-// Artist
-#[derive(Deserialize)]
-pub struct SpotifyArtist {
-    profile: SpotifyArtistProfile,
-}
-
-#[derive(Deserialize)]
-pub struct SpotifyArtistProfile {
-    name: String,
-}

src/spotify/payloads.rs

@@ -0,0 +1,65 @@
+use serde::Deserialize;
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SpotifyToken {
+    pub access_token: String,
+    pub access_token_expiration_timestamp_ms: u128,
+}
+
+#[derive(Deserialize)]
+pub struct SpotifyTrack {
+    pub artist: String,
+    pub title: String,
+    pub album: String,
+}
+
+#[derive(Deserialize)]
+pub struct SpotifyData<T> {
+    pub data: T,
+}
+
+#[derive(Deserialize)]
+pub struct SpotifyItems<T> {
+    pub items: Vec<T>,
+}
+
+#[derive(Deserialize)]
+pub struct SpotifyItem<T> {
+    pub item: T,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SpotifySearchResult {
+    pub search_v2: SpotifySearchV2,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SpotifySearchV2 {
+    pub tracks_v2: SpotifyItems<SpotifyItem<SpotifyData<SpotifyTrackItem>>>,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SpotifyTrackItem {
+    pub name: String,
+    pub album_of_track: SpotifyAlbum,
+    pub artists: SpotifyItems<SpotifyArtist>,
+}
+
+#[derive(Deserialize)]
+pub struct SpotifyAlbum {
+    pub name: String,
+}
+
+#[derive(Deserialize)]
+pub struct SpotifyArtist {
+    pub profile: SpotifyArtistProfile,
+}
+
+#[derive(Deserialize)]
+pub struct SpotifyArtistProfile {
+    pub name: String,
+}