refactor: fix pedantic Clippy lints

server/src/index.rs

···
     scrobble: Option<ScrobblesTemplate>,
 }
 
-pub async fn get_index(monitor: ScrobbleMonitor) -> RootTemplate {
-    let scrobbles_template = monitor.try_get_scrobble();
-    if scrobbles_template.is_none() {
-        // start fetching scrobble so we can send a fresh response to the client ASAP
-        tokio::spawn(async move { monitor.get_scrobble().await });
-    }
+impl RootTemplate {
+    pub fn new(monitor: ScrobbleMonitor) -> RootTemplate {
+        let scrobbles_template = monitor.try_get_scrobble();
+        if scrobbles_template.is_none() {
+            // start fetching scrobble so we can send a fresh response to the client ASAP
+            tokio::spawn(async move { monitor.get_scrobble().await });
+        }
 
-    RootTemplate {
-        scrobble: scrobbles_template,
+        RootTemplate {
+            scrobble: scrobbles_template,
+        }
     }
 }

server/src/main.rs

···
 
 use std::{convert::Infallible, env, net::SocketAddr, time::Duration};
 
-use crate::index::get_index;
+use crate::index::RootTemplate;
 use crate::scrobble_monitor::ScrobbleMonitor;
 
 use askama::Template;
···
 }
 
 async fn render_index_handler(State(monitor): State<ScrobbleMonitor>) -> impl IntoResponse {
-    let template = get_index(monitor).await;
+    let template = RootTemplate::new(monitor);
     template.render().map(Html).map_err(|err| {
         tracing::error!("failed to render index: {err:?}");
         StatusCode::INTERNAL_SERVER_ERROR

server/src/scrobble.rs

···
 use serde::Deserialize;
 
 #[derive(Debug, Clone, Deserialize)]
-pub struct ScrobbleArtist {
+pub struct Artist {
     #[serde(rename = "#text")]
     pub text: String,
 }
 
 #[derive(Debug, Clone, Deserialize)]
-pub struct ScrobbleImage {
+pub struct Image {
     #[serde(rename = "#text")]
     pub text: String,
 }
 
 #[derive(Debug, Clone, Deserialize)]
-pub struct ScrobbleAttributes {
+pub struct Attributes {
     #[serde(rename = "nowplaying")]
     pub now_playing: String,
 }
 
 #[derive(Debug, Clone, Deserialize)]
-pub struct ScrobbleTrack {
-    pub artist: ScrobbleArtist,
-    pub image: Vec<ScrobbleImage>,
+pub struct Track {
+    pub artist: Artist,
+    pub image: Vec<Image>,
     pub name: String,
     #[serde(rename = "@attr")]
-    pub attributes: Option<ScrobbleAttributes>,
+    pub attributes: Option<Attributes>,
 }
 
 #[derive(Debug, Clone, Deserialize)]
-pub struct ScrobbleRecentTracks {
-    pub track: Vec<ScrobbleTrack>,
+pub struct RecentTracks {
+    pub track: Vec<Track>,
 }
 
 #[derive(Debug, Clone, Deserialize)]
 pub struct Scrobble {
     #[serde(rename = "recenttracks")]
-    pub recent_tracks: ScrobbleRecentTracks,
+    pub recent_tracks: RecentTracks,
 }
 
 #[derive(Template, Debug, Clone, PartialEq)]
···
     pub srcset: Option<String>,
 }
 
-pub fn scrobble_partial(scrobble: Scrobble) -> ScrobblesTemplate {
-    let latest_track = scrobble
-        .recent_tracks
-        .track
-        .into_iter()
-        .next()
-        .expect("no tracks were returned");
-    let srcset = latest_track.image.get(0..3).map(|images| {
-        format!(
-            "{}, {} 2x, {} 3x",
-            images[0].text, images[1].text, images[2].text
-        )
-    });
-    let text_intro = if latest_track
-        .attributes
-        .is_some_and(|attr| attr.now_playing == "true")
-    {
-        "Now playing: "
-    } else {
-        "Last played: "
-    };
-    let now_playing = format!("{} - {}", latest_track.name, latest_track.artist.text);
-
-    ScrobblesTemplate {
-        intro: text_intro,
-        now_playing,
-        image: latest_track
-            .image
+impl ScrobblesTemplate {
+    pub fn new(scrobble: Scrobble) -> ScrobblesTemplate {
+        let latest_track = scrobble
+            .recent_tracks
+            .track
             .into_iter()
             .next()
-            .map(|image| image.text),
-        srcset,
+            .expect("no tracks were returned");
+        let srcset = latest_track.image.get(0..3).map(|images| {
+            format!(
+                "{}, {} 2x, {} 3x",
+                images[0].text, images[1].text, images[2].text
+            )
+        });
+        let text_intro = if latest_track
+            .attributes
+            .is_some_and(|attr| attr.now_playing == "true")
+        {
+            "Now playing: "
+        } else {
+            "Last played: "
+        };
+        let now_playing = format!("{} - {}", latest_track.name, latest_track.artist.text);
+
+        ScrobblesTemplate {
+            intro: text_intro,
+            now_playing,
+            image: latest_track
+                .image
+                .into_iter()
+                .next()
+                .map(|image| image.text),
+            srcset,
+        }
     }
 }

server/src/scrobble_monitor.rs

···
 use reqwest::Client;
 use tokio::sync::RwLock;
 
-use crate::scrobble::{scrobble_partial, Scrobble, ScrobblesTemplate};
+use crate::scrobble::{Scrobble, ScrobblesTemplate};
 
 #[derive(Debug, Clone)]
 struct CachedScrobble {
···
             _ => {
                 tracing::debug!("fetching new scrobble data");
                 let scrobble = self.fetch_scrobble().await?;
-                let scrobble_partial = scrobble_partial(scrobble);
+                let scrobble_partial = ScrobblesTemplate::new(scrobble);
                 *last_scrobble = Some(CachedScrobble {
                     data: scrobble_partial.clone(),
                     fetch_time: Instant::now(),