[rust] Improve management of the configuration key for cache path

Author: bonigarcia

rust/src/config.rs

@@ -170,21 +170,28 @@ impl StringKey<'_> {
     pub fn get_value(&self) -> String {
         let config = get_config().unwrap_or_default();
         let keys = self.0.to_owned();
+        let default_value = self.1.to_owned();
+
         let mut result;
+        let mut first_key = "";
         for key in keys {
+            if first_key.is_empty() {
+                first_key = key;
+            }
             if config.contains_key(key) {
                 result = config[key].as_str().unwrap().to_string()
             } else {
                 result = env::var(get_env_name(key)).unwrap_or_default()
             }
             if !result.is_empty() {
-                if key.eq(CACHE_PATH_KEY) {
-                    write_cache_path(result.clone());
-                }
-                return result;
+                // The configuration key for the cache path ("cache-path") is special because
+                // the rest of the configuration values depend on this value (since the
+                // configuration file is stored in the cache path). Therefore, this value needs
+                // to be discovered in the first place and stored globally (on CACHE_PATH)
+                return check_cache_path(key, result, default_value);
             }
         }
-        self.1.to_owned()
+        default_value
     }
 }
 
@@ -239,6 +246,22 @@ fn concat(prefix: &str, suffix: &str) -> String {
     version_label
 }
 
+fn check_cache_path(key: &str, value_in_config_or_env: String, default_value: String) -> String {
+    let return_value = if key.eq(CACHE_PATH_KEY) {
+        if default_value.is_empty() {
+            value_in_config_or_env
+        } else {
+            default_value
+        }
+    } else {
+        value_in_config_or_env
+    };
+    if key.eq(CACHE_PATH_KEY) {
+        write_cache_path(return_value.clone());
+    }
+    return_value
+}
+
 fn write_cache_path(cache_path: String) {
     CACHE_PATH.with(|value| {
         *value.borrow_mut() = cache_path;

rust/src/files.rs

@@ -206,7 +206,7 @@ pub fn unzip(
         final_path,
         single_file,
         &compressed_path.to_path_buf(),
-        &log,
+        log,
     )?;
 
     Ok(())
@@ -251,7 +251,7 @@ pub fn copy_folder_content(
                 destination_path,
                 single_file.clone(),
                 avoid_path,
-                &log,
+                log,
             )?;
         }
     }

rust/src/logger.rs

@@ -15,6 +15,7 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use crate::config::BooleanKey;
 use crate::metadata::now_unix_timestamp;
 use env_logger::fmt::Color;
 use env_logger::Target::Stdout;
@@ -70,6 +71,12 @@ pub struct JsonOutput {
 }
 
 impl Logger {
+    pub fn default() -> Self {
+        let debug = BooleanKey("debug", false).get_value();
+        let trace = BooleanKey("trace", false).get_value();
+        Logger::create("", debug, trace)
+    }
+
     pub fn create(output: &str, debug: bool, trace: bool) -> Self {
         let output_type;
         if output.eq_ignore_ascii_case("json") {

rust/src/main.rs

@@ -23,7 +23,6 @@ use exitcode::DATAERR;
 use exitcode::OK;
 use exitcode::UNAVAILABLE;
 use selenium_manager::config::{BooleanKey, StringKey, CACHE_PATH_KEY};
-use selenium_manager::files::{default_cache_folder, path_buf_to_string};
 use selenium_manager::grid::GridManager;
 use selenium_manager::logger::{Logger, BROWSER_PATH, DRIVER_PATH};
 use selenium_manager::REQUEST_TIMEOUT_SEC;
@@ -129,13 +128,9 @@ struct Cli {
 
 fn main() {
     let cli = Cli::parse();
+    let cache_path =
+        StringKey(vec![CACHE_PATH_KEY], &cli.cache_path.unwrap_or_default()).get_value();
 
-    let default_cache_path = path_buf_to_string(default_cache_folder());
-    let cache_path = StringKey(
-        vec![CACHE_PATH_KEY],
-        &cli.cache_path.unwrap_or(default_cache_path),
-    )
-    .get_value();
     let debug = cli.debug || BooleanKey("debug", false).get_value();
     let trace = cli.trace || BooleanKey("trace", false).get_value();
     let log = Logger::create(&cli.output, debug, trace);