Ensure we parse env variables once (#94)

Author: DonJayamanne

crates/pet-conda/src/environment_locations.rs

@@ -90,10 +90,8 @@ fn get_conda_environment_paths_from_known_paths(env_vars: &EnvVariables) -> Vec<
             if let Ok(entries) = fs::read_dir(full_path) {
                 for entry in entries.filter_map(Result::ok) {
                     let path = entry.path();
-                    if let Ok(meta) = fs::metadata(&path) {
-                        if meta.is_dir() {
-                            env_paths.push(path);
-                        }
+                    if path.is_dir() {
+                        env_paths.push(path);
                     }
                 }
             }
@@ -112,10 +110,8 @@ fn get_conda_environment_paths_from_additional_paths(
         if let Ok(entries) = fs::read_dir(path) {
             for entry in entries.filter_map(Result::ok) {
                 let path = entry.path();
-                if let Ok(meta) = fs::metadata(&path) {
-                    if meta.is_dir() {
-                        env_paths.push(path);
-                    }
+                if path.is_dir() {
+                    env_paths.push(path);
                 }
             }
         }
@@ -146,7 +142,7 @@ pub fn get_environments(conda_dir: &Path) -> Vec<PathBuf> {
         }
     } else if is_conda_env(conda_dir) {
         envs.push(conda_dir.to_path_buf());
-    } else if fs::metadata(conda_dir.join("envs")).is_ok() {
+    } else if conda_dir.join("envs").exists() {
         // This could be a directory where conda environments are stored.
         // I.e. its not necessarily the root conda install directory.
         // E.g. C:\Users\donjayamanne\.conda

crates/pet-conda/src/environments.rs

@@ -14,10 +14,7 @@ use pet_core::{
 };
 use pet_fs::path::{norm_case, resolve_symlink};
 use pet_python_utils::executable::{find_executable, find_executables};
-use std::{
-    fs,
-    path::{Path, PathBuf},
-};
+use std::path::{Path, PathBuf};
 
 #[derive(Debug, Clone)]
 pub struct CondaEnvironment {
@@ -84,7 +81,7 @@ pub fn get_conda_environment_info(
         None => get_conda_installation_used_to_create_conda_env(env_path),
     };
     if let Some(conda_dir) = &conda_install_folder {
-        if fs::metadata(conda_dir).is_err() {
+        if !conda_dir.exists() {
             warn!(
                 "Conda install folder {}, does not exist, hence will not be used for the Conda Env: {}",
                 env_path.display(),

crates/pet-conda/src/manager.rs

@@ -23,7 +23,7 @@ fn get_conda_executable(path: &Path) -> Option<PathBuf> {
 
     for relative_path in relative_path_to_conda_exe {
         let exe = path.join(&relative_path);
-        if exe.metadata().is_ok() {
+        if exe.exists() {
             return Some(exe);
         }
     }
@@ -49,10 +49,8 @@ pub fn find_conda_binary(env_vars: &EnvVariables) -> Option<PathBuf> {
     for path in env::split_paths(&paths) {
         for bin in get_conda_bin_names() {
             let conda_path = path.join(bin);
-            if let Ok(metadata) = std::fs::metadata(&conda_path) {
-                if metadata.is_file() || metadata.is_symlink() {
-                    return Some(conda_path);
-                }
+            if conda_path.is_file() || conda_path.is_symlink() {
+                return Some(conda_path);
             }
         }
     }

crates/pet-conda/src/utils.rs

@@ -1,25 +1,18 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
 
-use std::{
-    fs,
-    path::{Path, PathBuf},
-};
+use std::path::{Path, PathBuf};
 
 /// conda-meta must exist as this contains a mandatory `history` file.
 pub fn is_conda_install(path: &Path) -> bool {
-    (path.join("condabin").metadata().is_ok() || path.join("envs").metadata().is_ok())
-        && path.join("conda-meta").metadata().is_ok()
+    (path.join("condabin").exists() || path.join("envs").exists())
+        && path.join("conda-meta").exists()
 }
 
 /// conda-meta must exist as this contains a mandatory `history` file.
 /// The root conda installation folder is also a conda environment (its the base environment).
 pub fn is_conda_env(path: &Path) -> bool {
-    if let Ok(metadata) = fs::metadata(path.join("conda-meta")) {
-        metadata.is_dir()
-    } else {
-        false
-    }
+    path.join("conda-meta").is_dir()
 }
 
 /// Only used in tests, noop in production.

crates/pet-core/src/os_environment.rs

@@ -10,7 +10,7 @@ use std::{
 use log::trace;
 use pet_fs::path::norm_case;
 
-pub trait Environment {
+pub trait Environment: Send + Sync {
     fn get_user_home(&self) -> Option<PathBuf>;
     /// Only used in tests, None in production.
     #[allow(dead_code)]

crates/pet-core/src/python_environment.rs

@@ -114,7 +114,14 @@ impl PythonEnvironment {
 
 impl std::fmt::Display for PythonEnvironment {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
-        writeln!(f, "Environment ({:?})", self.kind).unwrap_or_default();
+        writeln!(
+            f,
+            "Environment ({})",
+            self.kind
+                .map(|v| format!("{v:?}"))
+                .unwrap_or("Unknown".to_string())
+        )
+        .unwrap_or_default();
         if let Some(name) = &self.display_name {
             writeln!(f, "   Display-Name: {name}").unwrap_or_default();
         }

crates/pet-global-virtualenvs/src/lib.rs

@@ -14,12 +14,12 @@ fn get_global_virtualenv_dirs(
 
     if let Some(work_on_home) = work_on_home_env_var {
         let work_on_home = norm_case(PathBuf::from(work_on_home));
-        if fs::metadata(&work_on_home).is_ok() {
+        if work_on_home.exists() {
             venv_dirs.push(work_on_home);
         } else if let Some(home) = &user_home {
             if let Ok(work_on_home) = work_on_home.strip_prefix("~") {
                 let work_on_home = home.join(work_on_home);
-                if fs::metadata(&work_on_home).is_ok() {
+                if work_on_home.exists() {
                     venv_dirs.push(work_on_home);
                 }
             }
@@ -28,7 +28,7 @@ fn get_global_virtualenv_dirs(
 
     // Used by pipenv (https://github.com/pypa/pipenv/blob/main/pipenv/utils/shell.py#L184)
     if let Some(xdg_data_home) = xdg_data_home.map(|d| PathBuf::from(d).join("virtualenvs")) {
-        if fs::metadata(&xdg_data_home).is_ok() {
+        if xdg_data_home.exists() {
             venv_dirs.push(xdg_data_home);
         }
     }
@@ -41,19 +41,19 @@ fn get_global_virtualenv_dirs(
             PathBuf::from(".local").join("share").join("virtualenvs"), // Used by pipenv (https://github.com/pypa/pipenv/blob/main/pipenv/utils/shell.py#L184)
         ] {
             let venv_dir = home.join(dir);
-            if fs::metadata(&venv_dir).is_ok() {
+            if venv_dir.exists() {
                 venv_dirs.push(venv_dir);
             }
         }
         if cfg!(target_os = "linux") {
             // https://virtualenvwrapper.readthedocs.io/en/latest/index.html
             // Default recommended location for virtualenvwrapper
             let envs = PathBuf::from("Envs");
-            if fs::metadata(&envs).is_ok() {
+            if envs.exists() {
                 venv_dirs.push(envs);
             }
             let envs = PathBuf::from("envs");
-            if fs::metadata(&envs).is_ok() {
+            if envs.exists() {
                 venv_dirs.push(envs);
             }
         }

crates/pet-homebrew/src/environment_locations.rs

@@ -4,7 +4,7 @@
 use crate::env_variables::EnvVariables;
 use lazy_static::lazy_static;
 use regex::Regex;
-use std::{fs, path::PathBuf};
+use std::path::PathBuf;
 
 lazy_static! {
     static ref PYTHON_VERSION: Regex =
@@ -41,9 +41,7 @@ pub fn get_homebrew_prefix_bin(env_vars: &EnvVariables) -> Vec<PathBuf> {
     // Check the environment variables
     if let Some(homebrew_prefix) = &env_vars.homebrew_prefix {
         let homebrew_prefix_bin = PathBuf::from(homebrew_prefix).join("bin");
-        if fs::metadata(&homebrew_prefix_bin).is_ok()
-            && !homebrew_prefixes.contains(&homebrew_prefix_bin)
-        {
+        if homebrew_prefix_bin.exists() && !homebrew_prefixes.contains(&homebrew_prefix_bin) {
             homebrew_prefixes.push(homebrew_prefix_bin);
         }
     }

crates/pet-pipenv/src/lib.rs

@@ -37,7 +37,7 @@ fn get_pipenv_project_from_prefix(prefix: &Path) -> Option<PathBuf> {
     let project_file = prefix.join(".project");
     let contents = fs::read_to_string(project_file).ok()?;
     let project_folder = norm_case(PathBuf::from(contents.trim().to_string()));
-    if fs::metadata(&project_folder).is_ok() {
+    if project_folder.exists() {
         Some(project_folder)
     } else {
         None
@@ -46,14 +46,14 @@ fn get_pipenv_project_from_prefix(prefix: &Path) -> Option<PathBuf> {
 
 fn is_pipenv(env: &PythonEnv, env_vars: &EnvVariables) -> bool {
     if let Some(project_path) = get_pipenv_project(env) {
-        if fs::metadata(project_path.join(env_vars.pipenv_pipfile.clone())).is_ok() {
+        if project_path.join(env_vars.pipenv_pipfile.clone()).exists() {
             return true;
         }
     }
     // If we have a Pipfile, then this is a pipenv environment.
     // Else likely a virtualenvwrapper or the like.
     if let Some(project_path) = get_pipenv_project(env) {
-        fs::metadata(project_path.join(env_vars.pipenv_pipfile.clone())).is_ok()
+        project_path.join(env_vars.pipenv_pipfile.clone()).exists()
     } else {
         false
     }

crates/pet-pyenv/src/environment_locations.rs

@@ -3,7 +3,7 @@
 
 use crate::env_variables::EnvVariables;
 use pet_fs::path::norm_case;
-use std::{fs, path::PathBuf};
+use std::path::PathBuf;
 
 #[cfg(windows)]
 pub fn get_home_pyenv_dir(env_vars: &EnvVariables) -> Option<PathBuf> {
@@ -24,10 +24,8 @@ pub fn get_binary_from_known_paths(env_vars: &EnvVariables) -> Option<PathBuf> {
         } else {
             known_path.join("pyenv")
         };
-        if let Ok(metadata) = fs::metadata(&exe) {
-            if metadata.is_file() {
-                return Some(norm_case(exe));
-            }
+        if exe.is_file() {
+            return Some(norm_case(exe));
         }
     }
     None