cargo clippy --fix -- -W clippy::uninlined-format-args

OrionGonzalez · OrionGonzalez · commit e9c349911ab1 · 2023-04-20T11:54:57.000+02:00
diff --git a/rust/src/chrome.rs b/rust/src/chrome.rs
@@ -186,9 +186,9 @@ impl SeleniumManager for ChromeManager {
                 let mut browser_version_int = browser_version.parse::<i32>().unwrap_or_default();
                 for i in 0..FALLBACK_RETRIES {
                     let driver_url = if browser_version.is_empty() {
-                        format!("{}{}", DRIVER_URL, LATEST_RELEASE)
+                        format!("{DRIVER_URL}{LATEST_RELEASE}")
                     } else {
-                        format!("{}{}_{}", DRIVER_URL, LATEST_RELEASE, browser_version_int)
+                        format!("{DRIVER_URL}{LATEST_RELEASE}_{browser_version_int}")
                     };
                     if !browser_version.is_empty() && browser_version_int <= 0 {
                         break;
diff --git a/rust/src/downloads.rs b/rust/src/downloads.rs
@@ -49,13 +49,12 @@ pub async fn download_driver_to_tmp_folder(
             .and_then(|name| if name.is_empty() { None } else { Some(name) })
             .unwrap_or("tmp.bin");
 
-        log.trace(format!("File to be downloaded: {}", target_name));
+        log.trace(format!("File to be downloaded: {target_name}"));
         let target_name = tmp_dir.path().join(target_name);
         target_path = String::from(target_name.to_str().unwrap());
 
         log.trace(format!(
-            "Temporal folder for driver package: {}",
-            target_path
+            "Temporal folder for driver package: {target_path}"
         ));
         File::create(target_name)?
     };
diff --git a/rust/src/edge.rs b/rust/src/edge.rs
@@ -182,7 +182,7 @@ impl SeleniumManager for EdgeManager {
             }
             _ => {
                 let driver_url = match browser_version {
-                    None => format!("{}{}", DRIVER_URL, LATEST_STABLE),
+                    None => format!("{DRIVER_URL}{LATEST_STABLE}"),
                     Some(version) => format!(
                         "{}{}_{}_{}",
                         DRIVER_URL,
@@ -236,8 +236,7 @@ impl SeleniumManager for EdgeManager {
             "linux64"
         };
         Ok(format!(
-            "{}{}/edgedriver_{}.zip",
-            DRIVER_URL, driver_version, driver_label
+            "{DRIVER_URL}{driver_version}/edgedriver_{driver_label}.zip"
         ))
     }
 
diff --git a/rust/src/files.rs b/rust/src/files.rs
@@ -66,11 +66,10 @@ pub fn uncompress(
 ) -> Result<(), Box<dyn Error>> {
     let file = File::open(compressed_file)?;
     let kind = infer::get_from_path(compressed_file)?
-        .ok_or(format!("Format for file {:?} cannot be inferred", file))?;
+        .ok_or(format!("Format for file {file:?} cannot be inferred"))?;
     let extension = kind.extension();
     log.trace(format!(
-        "The detected extension of the compressed file is {}",
-        extension
+        "The detected extension of the compressed file is {extension}"
     ));
 
     if extension.eq_ignore_ascii_case(ZIP) {
@@ -81,8 +80,7 @@ pub fn uncompress(
         return Err("Wrong browser/driver version".into());
     } else {
         return Err(format!(
-            "Downloaded file cannot be uncompressed ({} extension)",
-            extension
+            "Downloaded file cannot be uncompressed ({extension} extension)"
         )
         .into());
     }
@@ -95,7 +93,7 @@ pub fn untargz(file: File, target: &Path, log: &Logger) -> Result<(), Box<dyn Er
     let mut archive = Archive::new(tar);
     let parent_path = target
         .parent()
-        .ok_or(format!("Error getting parent of {:?}", file))?;
+        .ok_or(format!("Error getting parent of {file:?}"))?;
     if !target.exists() {
         archive.unpack(parent_path)?;
     }
diff --git a/rust/src/firefox.rs b/rust/src/firefox.rs
@@ -178,7 +178,7 @@ impl SeleniumManager for FirefoxManager {
                 Ok(driver_version)
             }
             _ => {
-                let latest_url = format!("{}{}", DRIVER_URL, LATEST_RELEASE);
+                let latest_url = format!("{DRIVER_URL}{LATEST_RELEASE}");
                 let driver_version = read_redirect_from_link(self.get_http_client(), latest_url)?;
 
                 if let Some(browser_version) = browser_version {
diff --git a/rust/src/iexplorer.rs b/rust/src/iexplorer.rs
@@ -175,8 +175,7 @@ impl SeleniumManager for IExplorerManager {
                 release_version.push('0');
             }
             driver_url = format!(
-                "{}download/selenium-{}/{}{}.zip",
-                DRIVER_URL, release_version, IEDRIVER_RELEASE, driver_version
+                "{DRIVER_URL}download/selenium-{release_version}/{IEDRIVER_RELEASE}{driver_version}.zip"
             );
         }
         Ok(driver_url)
diff --git a/rust/src/lib.rs b/rust/src/lib.rs
@@ -127,7 +127,7 @@ pub trait SeleniumManager {
     fn download_driver(&self) -> Result<(), Box<dyn Error>> {
         let driver_url = Self::get_driver_url(self)?;
         self.get_logger()
-            .debug(format!("Driver URL: {}", driver_url));
+            .debug(format!("Driver URL: {driver_url}"));
         let (_tmp_folder, driver_zip_file) =
             download_driver_to_tmp_folder(self.get_http_client(), driver_url, self.get_logger())?;
         let driver_path_in_cache = Self::get_driver_path_in_cache(self);
@@ -158,15 +158,13 @@ pub trait SeleniumManager {
         match get_browser_version_from_metadata(&metadata.browsers, browser_name) {
             Some(version) => {
                 self.get_logger().trace(format!(
-                    "Browser with valid TTL. Getting {} version from metadata",
-                    browser_name
+                    "Browser with valid TTL. Getting {browser_name} version from metadata"
                 ));
                 Some(version)
             }
             _ => {
                 self.get_logger().debug(format!(
-                    "Using shell command to find out {} version",
-                    browser_name
+                    "Using shell command to find out {browser_name} version"
                 ));
                 let mut browser_version = "".to_string();
                 for command in commands.iter() {
@@ -179,8 +177,7 @@ pub trait SeleniumManager {
                         continue;
                     }
                     self.get_logger().debug(format!(
-                        "The version of {} is {}",
-                        browser_name, full_browser_version
+                        "The version of {browser_name} is {full_browser_version}"
                     ));
                     match self.get_major_version(&full_browser_version) {
                         Ok(v) => browser_version = v,
@@ -221,7 +218,7 @@ pub trait SeleniumManager {
                 }
                 None => {
                     if self.is_browser_version_unstable() {
-                        return Err(format!("Browser version '{:?}' not found", browser_version));
+                        return Err(format!("Browser version '{browser_version:?}' not found"));
                     } else {
                         self.get_logger().debug(format!(
                         "The version of {} cannot be detected. Trying with latest driver version",
@@ -347,9 +344,9 @@ pub trait SeleniumManager {
 
     fn run_shell_command_with_log(&self, command: String) -> Result<String, Box<dyn Error>> {
         self.get_logger()
-            .debug(format!("Running command: {:?}", command));
+            .debug(format!("Running command: {command:?}"));
         let output = run_shell_command(self.get_os(), command)?;
-        self.get_logger().debug(format!("Output: {:?}", output));
+        self.get_logger().debug(format!("Output: {output:?}"));
         Ok(output)
     }
 
@@ -448,7 +445,7 @@ pub trait SeleniumManager {
         if timeout != default_timeout {
             config.timeout = timeout;
             self.get_logger()
-                .debug(format!("Using timeout of {} seconds", timeout));
+                .debug(format!("Using timeout of {timeout} seconds"));
             self.update_http_client()?;
         }
         Ok(())
@@ -575,7 +572,7 @@ fn get_index_version(full_version: &str, index: usize) -> Result<String, Box<dyn
     let version_vec: Vec<&str> = full_version.split('.').collect();
     Ok(version_vec
         .get(index)
-        .ok_or(format!("Wrong version: {}", full_version))?
+        .ok_or(format!("Wrong version: {full_version}"))?
         .to_string())
 }
 
diff --git a/rust/src/logger.rs b/rust/src/logger.rs
@@ -169,9 +169,9 @@ impl Logger {
             }
             OutputType::Shell => {
                 if level == Level::Info {
-                    print!("{}", message);
+                    print!("{message}");
                 } else if level == Level::Error {
-                    eprint!("{}", message);
+                    eprint!("{message}");
                 }
             }
             _ => {
diff --git a/rust/src/metadata.rs b/rust/src/metadata.rs
@@ -164,6 +164,6 @@ pub fn clear_metadata(log: &Logger) {
         metadata_path.display()
     ));
     fs::remove_file(metadata_path).unwrap_or_else(|err| {
-        log.warn(format!("Error deleting metadata file: {}", err));
+        log.warn(format!("Error deleting metadata file: {err}"));
     });
 }
diff --git a/rust/tests/cli_tests.rs b/rust/tests/cli_tests.rs
@@ -36,8 +36,7 @@ fn ok_test(
     #[case] driver_version: String,
 ) {
     println!(
-        "CLI test browser={} -- browser_version={} -- driver_version={}",
-        browser, browser_version, driver_version
+        "CLI test browser={browser} -- browser_version={browser_version} -- driver_version={driver_version}"
     );
 
     let mut cmd = Command::new(env!("CARGO_BIN_EXE_selenium-manager"));
@@ -49,9 +48,9 @@ fn ok_test(
     let stdout = &cmd.unwrap().stdout;
     let output = match str::from_utf8(stdout) {
         Ok(v) => v,
-        Err(e) => panic!("Invalid UTF-8 sequence: {}", e),
+        Err(e) => panic!("Invalid UTF-8 sequence: {e}"),
     };
-    println!("{}", output);
+    println!("{output}");
 
     assert!(output.contains(&driver_name));
     if !browser_version.is_empty() && output.contains("cache") {
@@ -74,8 +73,7 @@ fn error_test(
     #[case] error_code: i32,
 ) {
     println!(
-        "CLI test browser={} -- browser_version={} -- driver_version={}",
-        browser, browser_version, driver_version
+        "CLI test browser={browser} -- browser_version={browser_version} -- driver_version={driver_version}"
     );
 
     let mut cmd = Command::new(env!("CARGO_BIN_EXE_selenium-manager"));
@@ -106,7 +104,7 @@ fn beta_test(#[case] browser: String, #[case] driver_name: String) {
 
     let stdout = &assert.get_output().stdout;
     let output = str::from_utf8(stdout).unwrap();
-    println!("output {:?}", output);
+    println!("output {output:?}");
     assert!(output.contains(&driver_name) || output.contains("ERROR"));
 }
 
@@ -122,8 +120,7 @@ fn beta_test(#[case] browser: String, #[case] driver_name: String) {
 )]
 fn path_test(#[case] browser: String, #[case] browser_path: String) {
     println!(
-        "Path test browser={} -- browser_path={}",
-        browser, browser_path
+        "Path test browser={browser} -- browser_path={browser_path}"
     );
 
     let mut cmd = Command::new(env!("CARGO_BIN_EXE_selenium-manager"));
diff --git a/rust/tests/output_tests.rs b/rust/tests/output_tests.rs
@@ -31,7 +31,7 @@ fn json_output_test() {
 
     let stdout = &cmd.unwrap().stdout;
     let output = str::from_utf8(stdout).unwrap();
-    println!("{}", output);
+    println!("{output}");
 
     let json: JsonOutput = serde_json::from_str(output).unwrap();
     assert!(!json.logs.is_empty());
@@ -53,7 +53,7 @@ fn shell_output_test() {
 
     let stdout = &cmd.unwrap().stdout;
     let output = str::from_utf8(stdout).unwrap();
-    println!("{}", output);
+    println!("{output}");
 
     let driver = Path::new(output);
     assert!(driver.exists());

Original file line number	Diff line number	Diff line change
`@@ -178,7 +178,7 @@ impl SeleniumManager for FirefoxManager {`
`178`	`178`	`Ok(driver_version)`
`179`	`179`	`}`
`180`	`180`	`_ => {`
`181`		`- let latest_url = format!("{}{}", DRIVER_URL, LATEST_RELEASE);`
	`181`	`+ let latest_url = format!("{DRIVER_URL}{LATEST_RELEASE}");`
`182`	`182`	`let driver_version = read_redirect_from_link(self.get_http_client(), latest_url)?;`
`183`	`183`
`184`	`184`	`if let Some(browser_version) = browser_version {`
Original file line number	Diff line number	Diff line change
`@@ -175,8 +175,7 @@ impl SeleniumManager for IExplorerManager {`
`175`	`175`	`release_version.push('0');`
`176`	`176`	`}`
`177`	`177`	`driver_url = format!(`
`178`		`- "{}download/selenium-{}/{}{}.zip",`
`179`		`- DRIVER_URL, release_version, IEDRIVER_RELEASE, driver_version`
	`178`	`+ "{DRIVER_URL}download/selenium-{release_version}/{IEDRIVER_RELEASE}{driver_version}.zip"`
`180`	`179`	`);`
`181`	`180`	`}`
`182`	`181`	`Ok(driver_url)`
Original file line number	Diff line number	Diff line change
`@@ -169,9 +169,9 @@ impl Logger {`
`169`	`169`	`}`
`170`	`170`	`OutputType::Shell => {`
`171`	`171`	`if level == Level::Info {`
`172`		`- print!("{}", message);`
	`172`	`+ print!("{message}");`
`173`	`173`	`} else if level == Level::Error {`
`174`		`- eprint!("{}", message);`
	`174`	`+ eprint!("{message}");`
`175`	`175`	`}`
`176`	`176`	`}`
`177`	`177`	`_ => {`
Original file line number	Diff line number	Diff line change
`@@ -164,6 +164,6 @@ pub fn clear_metadata(log: &Logger) {`
`164`	`164`	`metadata_path.display()`
`165`	`165`	`));`
`166`	`166`	`fs::remove_file(metadata_path).unwrap_or_else(\|err\| {`
`167`		`- log.warn(format!("Error deleting metadata file: {}", err));`
	`167`	`+ log.warn(format!("Error deleting metadata file: {err}"));`
`168`	`168`	`});`
`169`	`169`	`}`