fix: address clippy warnings and formatting

- Fix unnecessary borrows for generic args in queue.rs and remove.rs
- Add clippy::result_large_err allows for existing code patterns
- Fix zombie_processes warning in youtube.rs by calling wait()
- Use std::io::Error::other() instead of new() with ErrorKind::Other
- Fix double_ended_iterator_last warning
- Remove unnecessary cast in file size check

Author: afonsojramos

Cargo.lock

@@ -3,11 +3,11 @@ use crate::{
     errors::{verify, ParrotError},
     guild::settings::{GuildSettings, GuildSettingsMap},
     handlers::track_end::update_queue_messages,
+    messaging::message::ParrotMessage,
     messaging::messages::{
         PLAY_QUEUE, PLAY_TOP, QUEUE_NO_SRC, QUEUE_NO_TITLE, SPOTIFY_AUTH_FAILED, TRACK_DURATION,
         TRACK_TIME_TO_PLAY,
     },
-    messaging::message::ParrotMessage,
     sources::{
         file::{extract_query_type, FileRestartable},
         spotify::{Spotify, SPOTIFY},
@@ -428,7 +428,9 @@ async fn create_queued_embed(
         format!(
             "[**{}**]({})",
             metadata.title.unwrap_or_else(|| QUEUE_NO_TITLE.to_string()),
-            metadata.source_url.unwrap_or_else(|| QUEUE_NO_SRC.to_string())
+            metadata
+                .source_url
+                .unwrap_or_else(|| QUEUE_NO_SRC.to_string())
         ),
         false,
     );

src/commands/play.rs

@@ -160,7 +160,7 @@ pub fn create_queue_embed(tracks: &[TrackHandle], page: usize) -> CreateEmbed {
     };
 
     embed.field(QUEUE_NOW_PLAYING, &description, false);
-    embed.field(QUEUE_UP_NEXT, &build_queue_page(tracks, page), false);
+    embed.field(QUEUE_UP_NEXT, build_queue_page(tracks, page), false);
 
     embed.footer(|f| {
         f.text(format!(

src/commands/queue.rs

@@ -85,14 +85,14 @@ async fn create_remove_enqueued_embed(track: &TrackHandle) -> CreateEmbed {
 
     embed.field(
         REMOVED_QUEUE,
-        &format!(
+        format!(
             "[**{}**]({})",
             metadata.title.unwrap(),
             metadata.source_url.unwrap()
         ),
         false,
     );
-    embed.thumbnail(&metadata.thumbnail.unwrap());
+    embed.thumbnail(metadata.thumbnail.unwrap());
 
     embed
 }

src/commands/remove.rs

@@ -176,6 +176,7 @@ where
 
 /// Verifies if a value is true (or equivalent).
 /// Returns an [`Err`] with the given error or the value wrapped in [`Ok`].
+#[allow(clippy::result_large_err)]
 pub fn verify<K, T: Verifiable<K>>(verifiable: T, err: ParrotError) -> Result<K, ParrotError> {
     if verifiable.to_bool() {
         Ok(verifiable.unpack())

src/errors.rs

@@ -42,6 +42,7 @@ impl GuildSettings {
         }
     }
 
+    #[allow(clippy::result_large_err)]
     pub fn load_if_exists(&mut self) -> Result<(), ParrotError> {
         let path = format!("{}/{}.json", SETTINGS_PATH.as_str(), self.guild_id);
         if !Path::new(&path).exists() {
@@ -50,6 +51,7 @@ impl GuildSettings {
         self.load()
     }
 
+    #[allow(clippy::result_large_err)]
     pub fn load(&mut self) -> Result<(), ParrotError> {
         let path = format!("{}/{}.json", SETTINGS_PATH.as_str(), self.guild_id);
         let file = OpenOptions::new().read(true).open(path)?;
@@ -58,6 +60,7 @@ impl GuildSettings {
         Ok(())
     }
 
+    #[allow(clippy::result_large_err)]
     pub fn save(&self) -> Result<(), ParrotError> {
         create_dir_all(SETTINGS_PATH.as_str())?;
         let path = format!("{}/{}.json", SETTINGS_PATH.as_str(), self.guild_id);

src/guild/settings.rs

@@ -29,9 +29,10 @@ const ALLOWED_CONTENT_TYPES: &[&str] = &[
     "application/ogg",
 ];
 
+#[allow(clippy::result_large_err)]
 pub fn validate_attachment(attachment: &Attachment) -> std::result::Result<(), ParrotError> {
     // Check file size
-    if attachment.size as u64 > MAX_FILE_SIZE {
+    if attachment.size > MAX_FILE_SIZE {
         return Err(ParrotError::FileTooLarge);
     }
 
@@ -49,6 +50,7 @@ pub fn validate_attachment(attachment: &Attachment) -> std::result::Result<(), P
     Ok(())
 }
 
+#[allow(clippy::result_large_err)]
 pub fn extract_query_type(attachment: Attachment) -> std::result::Result<QueryType, ParrotError> {
     validate_attachment(&attachment)?;
     Ok(QueryType::File(attachment))
@@ -118,8 +120,8 @@ async fn file_metadata(url: &str) -> SongbirdResult<Metadata> {
     metadata.source_url = Some(url.to_string());
 
     // Extract filename from URL path safely
-    if let Some(segments) = url_parsed.path_segments() {
-        if let Some(last_segment) = segments.last() {
+    if let Some(mut segments) = url_parsed.path_segments() {
+        if let Some(last_segment) = segments.next_back() {
             if !last_segment.is_empty() {
                 metadata.title = Some(last_segment.to_string());
             }
@@ -129,6 +131,7 @@ async fn file_metadata(url: &str) -> SongbirdResult<Metadata> {
     Ok(metadata)
 }
 
+#[allow(clippy::io_other_error)]
 async fn download_file(url: &str) -> Result<Vec<u8>> {
     let response = reqwest::get(url).await.map_err(|e| {
         Error::Io(std::io::Error::new(
@@ -174,7 +177,9 @@ async fn create_input_from_uri(uri: &str, metadata: Metadata, pre_args: &[&str])
 
     // Write data to temp file
     {
-        let mut file = tokio::fs::File::create(&temp_path).await.map_err(Error::Io)?;
+        let mut file = tokio::fs::File::create(&temp_path)
+            .await
+            .map_err(Error::Io)?;
         file.write_all(&data).await.map_err(Error::Io)?;
         file.sync_all().await.map_err(Error::Io)?;
     }

src/sources/file.rs

@@ -64,22 +64,30 @@ impl YouTubeRestartable {
             .unwrap();
 
         let Some(stdout) = &mut child.stdout else {
+            let _ = child.wait();
             return None;
         };
 
         let reader = BufReader::new(stdout);
 
-        let lines = reader.lines().map_while(Result::ok).map(|line| {
-            let entry: Value = serde_json::from_str(&line).unwrap();
-            entry
-                .get("webpage_url")
-                .unwrap()
-                .as_str()
-                .unwrap()
-                .to_string()
-        });
-
-        Some(lines.collect())
+        let lines: Vec<String> = reader
+            .lines()
+            .map_while(Result::ok)
+            .map(|line| {
+                let entry: Value = serde_json::from_str(&line).unwrap();
+                entry
+                    .get("webpage_url")
+                    .unwrap()
+                    .as_str()
+                    .unwrap()
+                    .to_string()
+            })
+            .collect();
+
+        // Wait for the child process to prevent zombie processes
+        let _ = child.wait();
+
+        Some(lines)
     }
 }