Fix formatting and linter issues

Author: DonJayamanne

.github/copilot-instructions.md

@@ -133,7 +133,7 @@ Tests validate discovered environments using 4 verification methods:
 - Use `rustup component add clippy` to install Clippy linter
 - Use `cargo fmt --all` to format code in all packages
 - Use `cargo clippy --all-features -- -Dwarnings` to check for linter issues
-- Use `cargo clippy --all-features --fix --allow-dirty` to automatically fix linter issues
+- Use `cargo clippy --all-features --fix --allow-dirty -- -Dwarnings` to automatically fix linter issues
 - Use `cargo build` to build the project
 - Use `cargo test --all` to test all packages (this can take a few seconds)
 - Use `cargo test [TESTNAME]` to test a specific test

crates/pet-conda/src/conda_rc.rs

@@ -353,7 +353,7 @@ envs_path:
 "#;
 
         assert_eq!(
-            parse_conda_rc_contents(&cfg).unwrap().env_dirs,
+            parse_conda_rc_contents(cfg).unwrap().env_dirs,
             [
                 PathBuf::from("/Users/username/dev/envs"),
                 PathBuf::from("/opt/conda/envs"),
@@ -373,7 +373,7 @@ envs_dirs:
 "#;
 
         assert_eq!(
-            parse_conda_rc_contents(&cfg).unwrap().env_dirs,
+            parse_conda_rc_contents(cfg).unwrap().env_dirs,
             ["/Users/username/dev/envs", "/opt/conda/envs",].map(PathBuf::from)
         );
 
@@ -388,7 +388,7 @@ envs_path:
 "#;
 
         assert_eq!(
-            parse_conda_rc_contents(&cfg).unwrap().env_dirs,
+            parse_conda_rc_contents(cfg).unwrap().env_dirs,
             [
                 PathBuf::from("/opt/somep lace/envs"),
                 expand_path(PathBuf::from("~/dev/envs2"))
@@ -402,7 +402,7 @@ channels:
 channel_priority: strict
 "#;
 
-        assert!(parse_conda_rc_contents(&cfg).unwrap().env_dirs.is_empty(),);
-        assert!(parse_conda_rc_contents(&cfg).unwrap().files.is_empty(),);
+        assert!(parse_conda_rc_contents(cfg).unwrap().env_dirs.is_empty(),);
+        assert!(parse_conda_rc_contents(cfg).unwrap().files.is_empty(),);
     }
 }

crates/pet-conda/src/environments.rs

@@ -295,8 +295,8 @@ fn is_conda_env_name_in_cmd(cmd_line: String, name: &str) -> bool {
     // # cmd: /Users/donjayamanne/miniconda3/bin/conda create -n conda1
     // # cmd_line: "# cmd: /usr/bin/conda create -p ./prefix-envs/.conda1 python=3.12 -y"
     // Look for "-n <name>" in the command line
-    cmd_line.contains(format!("-n {}", name).as_str())
-        || cmd_line.contains(format!("--name {}", name).as_str())
+    cmd_line.contains(format!("-n {name}").as_str())
+        || cmd_line.contains(format!("--name {name}").as_str())
 }
 
 pub fn get_activation_command(
@@ -364,7 +364,7 @@ mod tests {
     #[test]
     #[cfg(unix)]
     fn verify_conda_env_name() {
-        let mut line = "# cmd: /Users/donjayamanne/.pyenv/versions/mambaforge-22.11.1-3/lib/python3.10/site-packages/conda/__main__.py create --yes --name .conda python=3.12";
+        let line = "# cmd: /Users/donjayamanne/.pyenv/versions/mambaforge-22.11.1-3/lib/python3.10/site-packages/conda/__main__.py create --yes --name .conda python=3.12";
         assert!(is_conda_env_name_in_cmd(line.to_string(), ".conda"));
 
         let mut line = "# cmd: /Users/donjayamanne/.pyenv/versions/mambaforge-22.11.1-3/lib/python3.10/site-packages/conda/__main__.py create --yes -n .conda python=3.12";

crates/pet-conda/tests/ci_test.rs

@@ -84,7 +84,7 @@ fn detect_conda_root_from_path() {
     let python_env = PythonEnv::new(exe, Some(conda_dir.clone()), None);
     let env = conda.try_from(&python_env).unwrap();
 
-    assert_eq!(env.manager.is_some(), true);
+    assert!(env.manager.is_some());
 
     let manager = env.manager.unwrap();
     assert_eq!(manager.executable, conda_dir.join("bin").join("conda"));
@@ -132,13 +132,7 @@ fn detect_new_conda_env() {
     let env = environments
         .iter()
         .find(|x| x.name == Some(env_name.into()))
-        .expect(
-            format!(
-                "New Environment not created, detected envs {:?}",
-                environments
-            )
-            .as_str(),
-        );
+        .unwrap_or_else(|| panic!("New Environment not created, detected envs {environments:?}"));
 
     let prefix = conda_dir.clone().join("envs").join(env_name);
     assert_eq!(env.prefix, prefix.clone().into());
@@ -182,7 +176,7 @@ fn detect_conda_env_from_path() {
     let python_env = PythonEnv::new(exe.clone(), Some(prefix.clone()), None);
     let env = conda.try_from(&python_env).unwrap();
 
-    assert_eq!(env.manager.is_some(), true);
+    assert!(env.manager.is_some());
 
     let manager = env.manager.unwrap();
     assert_eq!(manager.executable, conda_dir.join("bin").join("conda"));
@@ -231,20 +225,14 @@ fn detect_new_conda_env_without_python() {
     let env = environments
         .iter()
         .find(|x| x.name == Some(env_name.into()))
-        .expect(
-            format!(
-                "New Environment not created, detected envs {:?}",
-                environments
-            )
-            .as_str(),
-        );
+        .unwrap_or_else(|| panic!("New Environment not created, detected envs {environments:?}"));
 
     let prefix = conda_dir.clone().join("envs").join(env_name);
     assert_eq!(env.prefix, prefix.clone().into());
     assert_eq!(env.name, Some(env_name.into()));
     assert_eq!(env.kind, Some(PythonEnvironmentKind::Conda));
-    assert_eq!(env.executable.is_none(), true);
-    assert_eq!(env.version.is_none(), true);
+    assert!(env.executable.is_none());
+    assert!(env.version.is_none());
 
     assert_eq!(env.manager, Some(manager.clone()));
 }
@@ -281,19 +269,15 @@ fn detect_new_conda_env_created_with_p_flag_without_python() {
     let env = environments
         .iter()
         .find(|x| x.prefix == Some(prefix.clone()))
-        .expect(
-            format!(
-                "New Environment ({:?}) not created, detected envs {:?}",
-                prefix, environments
-            )
-            .as_str(),
-        );
+        .unwrap_or_else(|| {
+            panic!("New Environment ({prefix:?}) not created, detected envs {environments:?}")
+        });
 
     assert_eq!(env.prefix, prefix.clone().into());
     assert_eq!(env.name, None);
     assert_eq!(env.kind, Some(PythonEnvironmentKind::Conda));
-    assert_eq!(env.executable.is_none(), true);
-    assert_eq!(env.version.is_none(), true);
+    assert!(env.executable.is_none());
+    assert!(env.version.is_none());
 
     assert_eq!(env.manager, Some(manager.clone()));
 }
@@ -334,13 +318,7 @@ fn detect_new_conda_env_created_with_p_flag_with_python() {
     let env = environments
         .iter()
         .find(|x| x.prefix == Some(prefix.clone()))
-        .expect(
-            format!(
-                "New Environment not created, detected envs {:?}",
-                environments
-            )
-            .as_str(),
-        );
+        .unwrap_or_else(|| panic!("New Environment not created, detected envs {environments:?}"));
 
     assert_eq!(env.prefix, prefix.clone().into());
     assert_eq!(env.name, None);

crates/pet-conda/tests/environment_locations_test.rs

@@ -9,8 +9,8 @@ fn non_existent_envrionments_txt() {
     use common::{create_env_variables, resolve_test_path};
     use pet_conda::environment_locations::get_conda_envs_from_environment_txt;
 
-    let root = resolve_test_path(&["unix", "root_empty"]).into();
-    let home = resolve_test_path(&["unix", "bogus directory"]).into();
+    let root = resolve_test_path(&["unix", "root_empty"]);
+    let home = resolve_test_path(&["unix", "bogus directory"]);
     let env = create_env_variables(home, root);
 
     let environments = get_conda_envs_from_environment_txt(&env);

crates/pet-conda/tests/lib_test.rs

@@ -20,8 +20,8 @@ fn find_conda_env_without_manager() {
 
     let env = locator
         .try_from(&PythonEnv::new(
-            path.join("bin").join("python").into(),
-            Some(path.clone().into()),
+            path.join("bin").join("python"),
+            Some(path.clone()),
             None,
         ))
         .unwrap();
@@ -71,8 +71,8 @@ fn find_conda_env_without_manager_but_detect_manager_from_history() {
 
     let env = locator
         .try_from(&PythonEnv::new(
-            path.join("bin").join("python").into(),
-            Some(path.clone().into()),
+            path.join("bin").join("python"),
+            Some(path.clone()),
             None,
         ))
         .unwrap();

crates/pet-conda/tests/manager_test.rs

@@ -48,5 +48,5 @@ fn does_not_find_conda_env_for_bogus_dirs() {
 
     let path = resolve_test_path(&["unix", "bogus_directory"]);
 
-    assert_eq!(CondaManager::from(&path).is_none(), true);
+    assert!(CondaManager::from(&path).is_none());
 }

crates/pet-conda/tests/package_test.rs

@@ -10,7 +10,7 @@ use common::resolve_test_path;
 #[cfg(unix)]
 #[test]
 fn empty_result_for_bogus_paths() {
-    let path: PathBuf = resolve_test_path(&["unix", "bogus_path"]).into();
+    let path: PathBuf = resolve_test_path(&["unix", "bogus_path"]);
     let pkg = CondaPackageInfo::from(&path, &package::Package::Conda);
 
     assert!(pkg.is_none());
@@ -19,7 +19,7 @@ fn empty_result_for_bogus_paths() {
 #[cfg(unix)]
 #[test]
 fn get_conda_package_info() {
-    let path: PathBuf = resolve_test_path(&["unix", "anaconda3-2023.03"]).into();
+    let path: PathBuf = resolve_test_path(&["unix", "anaconda3-2023.03"]);
     let pkg = CondaPackageInfo::from(&path, &package::Package::Conda).unwrap();
 
     assert_eq!(pkg.package, package::Package::Conda);
@@ -38,7 +38,7 @@ fn get_conda_package_info() {
 #[cfg(unix)]
 #[test]
 fn get_python_package_info() {
-    let path: PathBuf = resolve_test_path(&["unix", "anaconda3-2023.03"]).into();
+    let path: PathBuf = resolve_test_path(&["unix", "anaconda3-2023.03"]);
     let pkg = CondaPackageInfo::from(&path, &package::Package::Python).unwrap();
 
     assert_eq!(pkg.package, package::Package::Python);
@@ -57,7 +57,7 @@ fn get_python_package_info() {
 #[cfg(unix)]
 #[test]
 fn get_conda_package_info_without_history() {
-    let path: PathBuf = resolve_test_path(&["unix", "anaconda3-2023.03-without-history"]).into();
+    let path: PathBuf = resolve_test_path(&["unix", "anaconda3-2023.03-without-history"]);
     let pkg = CondaPackageInfo::from(&path, &package::Package::Conda).unwrap();
 
     assert_eq!(pkg.package, package::Package::Conda);
@@ -76,7 +76,7 @@ fn get_conda_package_info_without_history() {
 #[cfg(unix)]
 #[test]
 fn get_python_package_info_without_history() {
-    let path: PathBuf = resolve_test_path(&["unix", "anaconda3-2023.03-without-history"]).into();
+    let path: PathBuf = resolve_test_path(&["unix", "anaconda3-2023.03-without-history"]);
     let pkg = CondaPackageInfo::from(&path, &package::Package::Python).unwrap();
 
     assert_eq!(pkg.package, package::Package::Python);

crates/pet-conda/tests/utils_test.rs

@@ -9,48 +9,46 @@ use std::path::PathBuf;
 #[cfg(unix)]
 #[test]
 fn is_conda_install() {
-    let path: PathBuf = resolve_test_path(&["unix", "anaconda3-2023.03"]).into();
+    let path: PathBuf = resolve_test_path(&["unix", "anaconda3-2023.03"]);
     assert!(utils::is_conda_install(&path));
 
-    let path: PathBuf = resolve_test_path(&["unix", "anaconda3-2023.03-without-history"]).into();
+    let path: PathBuf = resolve_test_path(&["unix", "anaconda3-2023.03-without-history"]);
     assert!(utils::is_conda_install(&path));
 }
 
 #[cfg(unix)]
 #[test]
 fn is_not_conda_install() {
-    let path: PathBuf = resolve_test_path(&["unix", "some bogus directory"]).into();
-    assert_eq!(utils::is_conda_install(&path), false);
+    let path: PathBuf = resolve_test_path(&["unix", "some bogus directory"]);
+    assert!(!utils::is_conda_install(&path));
 
     // Conda env is not an install location.
-    let path: PathBuf =
-        resolve_test_path(&["unix", "anaconda3-2023.03", "envs", "env_python_3"]).into();
-    assert_eq!(utils::is_conda_install(&path), false);
+    let path: PathBuf = resolve_test_path(&["unix", "anaconda3-2023.03", "envs", "env_python_3"]);
+    assert!(!utils::is_conda_install(&path));
 }
 
 #[cfg(unix)]
 #[test]
 fn is_conda_env() {
-    let path: PathBuf = resolve_test_path(&["unix", "anaconda3-2023.03"]).into();
+    let path: PathBuf = resolve_test_path(&["unix", "anaconda3-2023.03"]);
     assert!(utils::is_conda_env(&path));
 
-    let path: PathBuf = resolve_test_path(&["unix", "anaconda3-2023.03-without-history"]).into();
+    let path: PathBuf = resolve_test_path(&["unix", "anaconda3-2023.03-without-history"]);
     assert!(utils::is_conda_env(&path));
 
-    let path: PathBuf =
-        resolve_test_path(&["unix", "anaconda3-2023.03", "envs", "env_python_3"]).into();
+    let path: PathBuf = resolve_test_path(&["unix", "anaconda3-2023.03", "envs", "env_python_3"]);
     assert!(utils::is_conda_env(&path));
 }
 
 #[cfg(unix)]
 #[test]
 fn is_not_conda_env() {
-    let path: PathBuf = resolve_test_path(&["unix", "some bogus directory"]).into();
-    assert_eq!(utils::is_conda_env(&path), false);
+    let path: PathBuf = resolve_test_path(&["unix", "some bogus directory"]);
+    assert!(!utils::is_conda_env(&path));
 
-    let path: PathBuf = resolve_test_path(&["unix", "anaconda3-2023.03"]).into();
+    let path: PathBuf = resolve_test_path(&["unix", "anaconda3-2023.03"]);
     assert!(utils::is_conda_env(&path));
 
-    let path: PathBuf = resolve_test_path(&["unix", "anaconda3-2023.03-without-history"]).into();
+    let path: PathBuf = resolve_test_path(&["unix", "anaconda3-2023.03-without-history"]);
     assert!(utils::is_conda_env(&path));
 }

crates/pet-core/src/python_environment.rs

@@ -416,7 +416,6 @@ pub fn get_environment_key(env: &PythonEnvironment) -> Option<PathBuf> {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
 
     #[test]
     #[cfg(windows)]