clippy: Inline variables

Author: Netfloex

api-server/src/api/query/search_torrents.rs

@@ -73,7 +73,7 @@ impl SearchTorrentsQuery {
                     }
                 }
                 Err(err) => {
-                    error!("Error:\n{:?}", err);
+                    error!("Error:\n{err:?}");
                     errors.push(ProviderError::new(
                         result.provider,
                         format!("{:?}: {}", err.kind(), err),

api-server/src/background/mod.rs

@@ -5,6 +5,6 @@ use log::error;
 
 pub async fn background(context: ContextPointer) {
     if let Err(error) = movie_tracking(context).await {
-        error!("MovieTracking error: {:?}", error);
+        error!("MovieTracking error: {error:?}");
     }
 }

api-server/src/background/movie_tracking.rs

@@ -75,7 +75,7 @@ pub async fn movie_tracking(context: ContextPointer) -> Result<(), HttpErrorKind
                     if let Some(movie) = movie {
                         let movie_name = movie.format();
 
-                        info!("Importing \"{}\" as \"{}\"", name, movie_name);
+                        info!("Importing {name:?} as {movie_name:?}");
 
                         let remote_path = torrent.get_content_path();
 
@@ -107,10 +107,10 @@ pub async fn movie_tracking(context: ContextPointer) -> Result<(), HttpErrorKind
                             .await?;
                         }
                     } else {
-                        warn!("No movie found for TMDB id: {}", tmdb);
+                        warn!("No movie found for TMDB id: {tmdb}");
                     }
                 } else {
-                    warn!("No TMDB id found for {}", name);
+                    warn!("No TMDB id found for {name}");
                 }
             }
         }
@@ -123,13 +123,10 @@ pub async fn movie_tracking(context: ContextPointer) -> Result<(), HttpErrorKind
             min_eta = *timeout_inactive;
             info!("No active torrents")
         } else {
-            info!(
-                "Watching {}/{} torrents",
-                active_torrents, watching_torrents
-            )
+            info!("Watching {active_torrents}/{watching_torrents} torrents")
         }
 
-        info!("Waiting: {}s", min_eta);
+        info!("Waiting: {min_eta}s");
         sleep(Duration::from_secs(min_eta as u64)).await;
     }
 }

api-server/src/main.rs

@@ -38,7 +38,7 @@ async fn rocket() -> _ {
 
     let config = get_config().unwrap_or_else(|e| {
         error!("Error missing required config");
-        error!("{}", e);
+        error!("{e}");
         process::exit(1);
     });
 

api-server/src/models/config.rs

@@ -101,7 +101,7 @@ pub fn get_config() -> Result<Config, Error> {
         std::process::exit(1);
     }
 
-    debug!("{:#?}", config);
+    debug!("{config:#?}");
 
     Ok(config)
 }

api-server/src/models/filter.rs

@@ -35,7 +35,7 @@ impl Filter {
             values: filter
                 .map(|x| FilterItem {
                     display: to_variant_name(&x).unwrap().to_owned(),
-                    name: format!("{:?}", x),
+                    name: format!("{x:?}"),
                 })
                 .collect(),
         }

api-server/src/models/http_error.rs

@@ -16,19 +16,19 @@ pub enum HttpErrorKind {
 
 impl HttpErrorKind {
     pub fn param(param: String) -> Self {
-        Self::InvalidParam(format!("Incorrect param: {}", param))
+        Self::InvalidParam(format!("Incorrect param: {param}"))
     }
     pub fn missing_query() -> Self {
         Self::MissingQuery("At least `imdb` or `query` must be defined.".into())
     }
     pub fn imdb_not_found(imdb: String) -> Self {
-        Self::ImdbNotFound(format!("IMDB ID not found: {}", imdb))
+        Self::ImdbNotFound(format!("IMDB ID not found: {imdb}"))
     }
 }
 
 impl Display for HttpErrorKind {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{:?}", self)
+        write!(f, "{self:?}")
     }
 }
 

api-server/src/models/movie_files.rs

@@ -71,7 +71,7 @@ impl MovieFiles {
                         movie_file = Some(file);
                     }
                 } else if SUBTITLE_FILE_EXTENSIONS.contains(&ext) {
-                    debug!("Found subtitle: {:?}", path);
+                    debug!("Found subtitle: {path:?}");
 
                     subtitles.push(path);
                 }

api-server/src/utils/import_movie.rs

@@ -30,9 +30,9 @@ pub async fn import_movie(
             .unwrap_or(OsStr::new("Unknown Movie")),
     );
 
-    info!("Copying to {:?}", movie_dest_file);
+    info!("Copying to {movie_dest_file:?}");
     fs::copy(movie_files.movie(), &movie_dest_file).await?;
-    info!("Movie copied to: {:?}", movie_dest_file);
+    info!("Movie copied to: {movie_dest_file:?}");
 
     // Copy subtitles
     for subtitle in movie_files.subtitles() {
@@ -59,15 +59,12 @@ pub async fn import_movie(
         );
 
         if let Some(new_subtitle_path) = new_subtitle_path {
-            info!(
-                "Importing subtitle {} to as {}",
-                subtitle_stem, new_subtitle_path
-            );
+            info!("Importing subtitle {subtitle_stem} to as {new_subtitle_path}");
 
             let dest_subtitle = dest_folder.join(new_subtitle_path);
-            debug!("Copying subtitle to {:?}", dest_subtitle);
+            debug!("Copying subtitle to {dest_subtitle:?}");
             fs::copy(subtitle, &dest_subtitle).await?;
-            debug!("Subtitle copied to: {:?}", dest_subtitle);
+            debug!("Subtitle copied to: {dest_subtitle:?}");
         }
     }
 

api-server/src/utils/parse_subtitle_language.rs

@@ -26,10 +26,7 @@ pub fn parse_subtitle_language(
         // target_base: MovieFile.2020
 
         if subtitle_name.starts_with(&target_base.to_lowercase()) {
-            debug!(
-                "Subtitle {} has the same base name as target file {}",
-                subtitle_name, target_base
-            );
+            debug!("Subtitle {subtitle_name} has the same base name as target file {target_base}");
             output.push('.');
             output.push_str(subtitle_ext);
             return Some(output);