Merge branch 'trunk' into dependabot/bundler/rb/rack-2.2.18

Author: aguspe

WORKSPACE

@@ -34,7 +34,7 @@ load("@rules_rust//rust:repositories.bzl", "rules_rust_dependencies", "rust_regi
 
 rules_rust_dependencies()
 
-rust_register_toolchains()
+rust_register_toolchains(versions = ["1.89.0"])
 
 load("@rules_rust//crate_universe:defs.bzl", "crates_repository")
 

rust/Cargo.Bazel.lock

@@ -1,5 +1,5 @@
 {
-  "checksum": "056872abd60303d8bce1e1a3108b098a6cb83bb21ce94a6c490cd177ed62b0dd",
+  "checksum": "638f6b3fe087406f8a272d384acf810030eab5b2e6cfb75c7ec6df0aafe69644",
   "crates": {
     "addr2line 0.25.1": {
       "name": "addr2line",

rust/src/downloads.rs

@@ -53,7 +53,7 @@ pub async fn download_to_tmp_folder(
         let target_name = response
             .url()
             .path_segments()
-            .and_then(|segments| segments.last())
+            .and_then(|mut segments| segments.next_back())
             .and_then(|name| if name.is_empty() { None } else { Some(name) })
             .unwrap_or("tmp.bin");
 

rust/src/lib.rs

@@ -624,17 +624,16 @@ pub trait SeleniumManager {
             if let Some(path) = browser_path {
                 self.get_logger()
                     .debug(format!("Found {} in PATH: {}", browser_name, &path));
-                if self.is_snap(&path) {
-                    if let Some(snap_path) = self.get_snap_path() {
-                        if snap_path.exists() {
-                            self.get_logger().debug(format!(
-                                "Using {} snap: {}",
-                                browser_name,
-                                path_to_string(snap_path.as_path())
-                            ));
-                            return Some(snap_path);
-                        }
-                    }
+                if self.is_snap(&path)
+                    && let Some(snap_path) = self.get_snap_path()
+                    && snap_path.exists()
+                {
+                    self.get_logger().debug(format!(
+                        "Using {} snap: {}",
+                        browser_name,
+                        path_to_string(snap_path.as_path())
+                    ));
+                    return Some(snap_path);
                 }
                 return Some(Path::new(&path).to_path_buf());
             }

rust/src/lock.rs

@@ -70,12 +70,10 @@ impl Lock {
 }
 
 pub fn clear_lock_if_required() {
-    let lock_path = get_lock_path();
-    if lock_path.is_some() {
-        let lock = lock_path.unwrap();
-        if lock.exists() {
-            fs::remove_file(lock).unwrap_or_default();
-        }
+    if let Some(lock) = get_lock_path()
+        && lock.exists()
+    {
+        fs::remove_file(lock).unwrap_or_default();
     }
 }
 

rust/src/main.rs

@@ -254,35 +254,35 @@ fn main() {
         })
         .unwrap_or_else(|err| {
             let log = selenium_manager.get_logger();
-            if selenium_manager.is_fallback_driver_from_cache() {
-                if let Some(best_driver_from_cache) =
+            if selenium_manager.is_fallback_driver_from_cache()
+                && let Some(best_driver_from_cache) =
                     selenium_manager.find_best_driver_from_cache().unwrap()
-                {
-                    log.debug_or_warn(
-                        format!(
-                            "There was an error managing {} ({}); using driver found in the cache",
-                            selenium_manager.get_driver_name(),
-                            err
-                        ),
-                        selenium_manager.is_offline(),
-                    );
-                    log_driver_and_browser_path(
-                        log,
-                        &best_driver_from_cache,
-                        &selenium_manager.get_browser_path_or_latest_from_cache(),
-                        selenium_manager.get_receiver(),
-                    );
-                    flush_and_exit(OK, log, Some(err));
-                }
+            {
+                log.debug_or_warn(
+                    format!(
+                        "There was an error managing {} ({}); using driver found in the cache",
+                        selenium_manager.get_driver_name(),
+                        err
+                    ),
+                    selenium_manager.is_offline(),
+                );
+                log_driver_and_browser_path(
+                    log,
+                    &best_driver_from_cache,
+                    &selenium_manager.get_browser_path_or_latest_from_cache(),
+                    selenium_manager.get_receiver(),
+                );
+                flush_and_exit(OK, log, Some(err));
             }
             if selenium_manager.is_offline() {
                 log.warn(&err);
                 flush_and_exit(OK, log, Some(err));
             } else {
-                let error_msg = log
-                    .is_debug_enabled()
-                    .then(|| format!("{:?}", err))
-                    .unwrap_or_else(|| err.to_string());
+                let error_msg = if log.is_debug_enabled() {
+                    format!("{:?}", err)
+                } else {
+                    err.to_string()
+                };
                 log.error(error_msg);
                 flush_and_exit(DATAERR, log, Some(err));
             }