refactor: split scrobble parsing/templating into separate file

Let's not overthink it rn but it would be nice if the ScrobbleMonitor
struct could be more generic and support fetching arbitrary types in the
future.

server/src/main.rs

···
+mod scrobble;
 mod scrobble_monitor;
 
 use std::{env, net::SocketAddr};

server/src/scrobble.rs

···
+use maud::{html, Markup};
+use serde::Deserialize;
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct ScrobbleArtist {
+    #[serde(rename = "#text")]
+    pub text: String,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct ScrobbleImage {
+    #[serde(rename = "#text")]
+    pub text: String,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct ScrobbleAttributes {
+    #[serde(rename = "nowplaying")]
+    pub now_playing: bool,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct ScrobbleTrack {
+    pub artist: ScrobbleArtist,
+    pub image: Vec<ScrobbleImage>,
+    pub name: String,
+    #[serde(rename = "@attr")]
+    pub attributes: Option<ScrobbleAttributes>,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct ScrobbleRecentTracks {
+    pub track: Vec<ScrobbleTrack>,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct Scrobble {
+    #[serde(rename = "recenttracks")]
+    pub recent_tracks: ScrobbleRecentTracks,
+}
+
+pub fn scrobble_partial(scrobble: &Scrobble) -> Markup {
+    let latest_track = &scrobble.recent_tracks.track[0];
+    let srcset = format!(
+        "{}, {} 2x, {} 3x",
+        latest_track.image[0].text, latest_track.image[1].text, latest_track.image[2].text
+    );
+    let text_intro = if latest_track
+        .attributes
+        .as_ref()
+        .map_or(false, |attr| attr.now_playing)
+    {
+        "Now playing: "
+    } else {
+        "Last played: "
+    };
+    let now_playing = format!("{} - {}", latest_track.name, latest_track.artist.text);
+
+    html! {
+        .bar-container {
+            img .bar-cover
+                src=(latest_track.image[0].text)
+                alt="Cover art"
+                srcset=(srcset);
+
+            p .bar-text-intro {
+                (text_intro)
+            }
+
+            p .bar-text-music {
+                (now_playing)
+            }
+        }
+    }
+}

server/src/scrobble_monitor.rs

···
     time::{Duration, Instant},
 };
 
-use maud::{html, Markup};
+use maud::Markup;
 use reqwest::Client;
-use serde::Deserialize;
 use tokio::sync::RwLock;
+
+use crate::scrobble::{scrobble_partial, Scrobble};
 
 #[derive(Debug, Clone)]
 struct CachedScrobble {
···
     fetch_time: Instant,
 }
 
-#[derive(Debug, Clone, Deserialize)]
-struct ScrobbleArtist {
-    #[serde(rename = "#text")]
-    text: String,
-}
-
-#[derive(Debug, Clone, Deserialize)]
-struct ScrobbleImage {
-    #[serde(rename = "#text")]
-    text: String,
-}
-
-#[derive(Debug, Clone, Deserialize)]
-struct ScrobbleAttributes {
-    #[serde(rename = "nowplaying")]
-    now_playing: bool,
-}
-
-#[derive(Debug, Clone, Deserialize)]
-struct ScrobbleTrack {
-    artist: ScrobbleArtist,
-    image: Vec<ScrobbleImage>,
-    name: String,
-    #[serde(rename = "@attr")]
-    attributes: Option<ScrobbleAttributes>,
-}
-
-#[derive(Debug, Clone, Deserialize)]
-struct ScrobbleRecentTracks {
-    track: Vec<ScrobbleTrack>,
-}
-
-#[derive(Debug, Clone, Deserialize)]
-struct Scrobble {
-    #[serde(rename = "recenttracks")]
-    recent_tracks: ScrobbleRecentTracks,
-}
-
 #[derive(Debug, Clone)]
 pub struct ScrobbleMonitor {
     client: Client,
···
             _ => {
                 tracing::debug!("fetching new scrobble data");
                 let scrobble = self.fetch_scrobble().await?;
-                let scrobble_partial = self.scrobble_partial(&scrobble);
+                let scrobble_partial = scrobble_partial(&scrobble);
                 *last_scrobble = Some(CachedScrobble {
                     data: scrobble_partial.clone(),
                     fetch_time: Instant::now(),
···
             .send()
             .await?;
         Ok(response.json().await?)
-    }
-
-    fn scrobble_partial(&self, scrobble: &Scrobble) -> Markup {
-        let latest_track = &scrobble.recent_tracks.track[0];
-        let srcset = format!(
-            "{}, {} 2x, {} 3x",
-            latest_track.image[0].text, latest_track.image[1].text, latest_track.image[2].text
-        );
-        let text_intro = if latest_track
-            .attributes
-            .as_ref()
-            .map_or(false, |attr| attr.now_playing)
-        {
-            "Now playing: "
-        } else {
-            "Last played: "
-        };
-        let now_playing = format!("{} - {}", latest_track.name, latest_track.artist.text);
-
-        html! {
-            .bar-container {
-                img .bar-cover
-                    src=(latest_track.image[0].text)
-                    alt="Cover art"
-                    srcset=(srcset);
-
-                p .bar-text-intro {
-                    (text_intro)
-                }
-
-                p .bar-text-music {
-                    (now_playing)
-                }
-            }
-        }
     }
 }