Fix clippy formatting issues

Since the latest Rust version, clippy raises warnings if the inline formatting syntax is not used

Author: JR-1991

src/cli/auth.rs

@@ -57,7 +57,7 @@ impl Matcher for AuthSubCommand {
 
                 match response {
                     Ok(_) => println!("Profile set successfully"),
-                    Err(e) => println!("Failed to set profile: {}", e),
+                    Err(e) => println!("Failed to set profile: {e}"),
                 }
             }
         }
@@ -170,7 +170,7 @@ impl AuthProfile {
     /// # Implementation Details
     /// Uses "--" as a delimiter between URL and token since URLs cannot contain "--"
     fn combine_url_and_token(url: &str, token: &str) -> String {
-        format!("{}--{}", url, token)
+        format!("{url}--{token}")
     }
 
     /// Splits a combined URL and token string back into separate components.

src/cli/base.rs

@@ -31,7 +31,7 @@ pub fn evaluate_and_print_response<T: Serialize>(response: Result<Response<T>, S
             response.print_result();
         }
         Err(e) => {
-            println!("Error: {}", e);
+            println!("Error: {e}");
         }
     }
 }
@@ -56,10 +56,10 @@ where
 {
     let value = matches
         .get_one::<U>(arg_name)
-        .unwrap_or_else(|| panic!("{} is required.", arg_name))
+        .unwrap_or_else(|| panic!("{arg_name} is required."))
         .as_ref()
         .parse::<T>()
-        .unwrap_or_else(|_| panic!("{} is invalid.", arg_name));
+        .unwrap_or_else(|_| panic!("{arg_name} is invalid."));
 
     value
 }

src/cli/dataset.rs

@@ -12,7 +12,6 @@ use std::fs::File;
 use std::io::Write;
 use std::path::{Path, PathBuf};
 
-use chrono::ParseResult;
 use colored_json::Paint;
 use structopt::StructOpt;
 use tokio::runtime::Runtime;
@@ -386,7 +385,7 @@ impl Matcher for DatasetSubCommand {
 
                 let response = runtime.block_on(
                     direct_upload::batch_direct_upload()
-                        .client(&client)
+                        .client(client)
                         .id(id)
                         .files(paths)
                         .bodies(bodies)
@@ -431,7 +430,7 @@ impl Matcher for DatasetSubCommand {
                 };
 
                 if let Err(e) = response {
-                    eprintln!("Error: {}", e);
+                    eprintln!("Error: {e}");
                 }
             }
             DatasetSubCommand::Export {
@@ -451,7 +450,7 @@ impl Matcher for DatasetSubCommand {
                         }
                     },
                     Err(e) => {
-                        eprintln!("Error: {}", e);
+                        eprintln!("Error: {e}");
                         return;
                     }
                 };
@@ -719,7 +718,7 @@ impl DatasetSubCommand {
             .map(String::from)
             .unwrap_or_default();
 
-        let mime = infer_mime(path).map_err(|e| format!("Failed to infer mime type. Direct upload only supports files with known mime types. Error: {}", e))?;
+        let mime = infer_mime(path).map_err(|e| format!("Failed to infer mime type. Direct upload only supports files with known mime types. Error: {e}"))?;
 
         Ok(DirectUploadBody {
             file_name: Some(filename),

src/cli/file.rs

@@ -86,7 +86,7 @@ impl Matcher for FileSubCommand {
                 evaluate_and_print_response(response);
             }
             FileSubCommand::Meta { id } => {
-                println!("Getting file metadata for {:?}", id);
+                println!("Getting file metadata for {id:?}");
                 let response = runtime.block_on(metadata::get_file_meta(client, &id));
                 evaluate_and_print_response(response);
             }
@@ -108,7 +108,7 @@ impl Matcher for FileSubCommand {
                         Status::OK,
                     ),
                     Err(e) => Response::from_message(
-                        Message::PlainMessage(format!("Error downloading file: {}", e)),
+                        Message::PlainMessage(format!("Error downloading file: {e}")),
                         Status::ERROR,
                     ),
                 };

src/cli/info.rs

@@ -64,12 +64,13 @@ impl Matcher for InfoSubCommand {
                             for (key, exporter) in exporters.iter() {
                                 println!("  - {}: {}", key.bold().blue(), exporter.display_name);
                             }
-                            println!("{}", EXPORTERS_INSTRUCTIONS.to_string());
+                            let instructions = EXPORTERS_INSTRUCTIONS.to_string();
+                            println!("{instructions}");
                         } else {
                             eprintln!("Error: {}", response.message.unwrap());
                         }
                     }
-                    Err(e) => eprintln!("Error: {:?}", e),
+                    Err(e) => eprintln!("Error: {e:?}"),
                 }
             }
         };

src/data_access/datafile.rs

@@ -264,7 +264,7 @@ async fn get_full_dv_path(client: &BaseClient, id: &Identifier) -> Result<String
     let directory_label = metadata.directory_label;
 
     Ok(if let Some(directory_label) = directory_label {
-        format!("{}/{}", directory_label, label)
+        format!("{directory_label}/{label}")
     } else {
         label
     })
@@ -313,7 +313,7 @@ pub(crate) fn construct_range_header(
     Ok(match downloaded_bytes {
         Some(remaining_bytes) => HeaderMap::from_iter([(
             RANGE,
-            HeaderValue::from_str(format!("bytes={}-", remaining_bytes).as_str())
+            HeaderValue::from_str(format!("bytes={remaining_bytes}-").as_str())
                 .map_err(|e| e.to_string())?,
         )])
         .into(),

src/data_access/dataset.rs

@@ -75,8 +75,7 @@ pub async fn download_dataset_files(
     .await
     .map_err(|e| {
         format!(
-            "Failed to fetch file bundle from dataset: {} ({})",
-            e, version
+            "Failed to fetch file bundle from dataset: {e} ({version})"
         )
     })?;
 
@@ -134,7 +133,7 @@ async fn prepare_download(
     let version = determine_version(version, client.has_api_token());
     let bundle_size = get_dataset_size(client, id, &Some(version.clone()))
         .await
-        .map_err(|e| format!("Failed to fetch dataset size: {}", e))?
+        .map_err(|e| format!("Failed to fetch dataset size: {e}"))?
         .data
         .ok_or("Bundle size response has no data".to_string())?
         .storage_size

src/datasetversion.rs

@@ -56,7 +56,7 @@ impl Display for DatasetVersion {
             DatasetVersion::Latest => write!(f, ":latest"),
             DatasetVersion::Draft => write!(f, ":draft"),
             DatasetVersion::LatestPublished => write!(f, ":latest-published"),
-            DatasetVersion::Version(v) => write!(f, "{}", v),
+            DatasetVersion::Version(v) => write!(f, "{v}"),
         }
     }
 }

src/direct_upload/db.rs

@@ -31,7 +31,7 @@ pub(crate) async fn create_database(
         // Create the database
         match Sqlite::create_database(&db_path).await {
             Ok(_) => println!("Create db success"),
-            Err(error) => panic!("error: {}", error),
+            Err(error) => panic!("error: {error}"),
         }
     }
 

src/direct_upload/hasher.rs

@@ -675,24 +675,24 @@ mod tests {
                 "MD5" => {
                     let expected_hash = format!("{:x}", md5::compute(content));
                     let hash = hasher.compute().unwrap();
-                    assert_eq!(hash, expected_hash, "Hash for {} is incorrect", algorithm);
+                    assert_eq!(hash, expected_hash, "Hash for {algorithm} is incorrect");
                 }
                 "SHA-256" => {
                     let expected_hash = format!("{:x}", sha2::Sha256::digest(content));
                     let hash = hasher.compute().unwrap();
-                    assert_eq!(hash, expected_hash, "Hash for {} is incorrect", algorithm);
+                    assert_eq!(hash, expected_hash, "Hash for {algorithm} is incorrect");
                 }
                 "SHA-512" => {
                     let expected_hash = format!("{:x}", sha2::Sha512::digest(content));
                     let hash = hasher.compute().unwrap();
-                    assert_eq!(hash, expected_hash, "Hash for {} is incorrect", algorithm);
+                    assert_eq!(hash, expected_hash, "Hash for {algorithm} is incorrect");
                 }
                 "SHA-1" => {
                     let expected_hash = format!("{:x}", sha1::Sha1::digest(content));
                     let hash = hasher.compute().unwrap();
-                    assert_eq!(hash, expected_hash, "Hash for {} is incorrect", algorithm);
+                    assert_eq!(hash, expected_hash, "Hash for {algorithm} is incorrect");
                 }
-                _ => panic!("Unsupported algorithm: {}", algorithm),
+                _ => panic!("Unsupported algorithm: {algorithm}"),
             }
         }
     }