Apply cargo fmt formatting across the workspace

Co-authored-by: karthiknadig <3840081+karthiknadig@users.noreply.github.com>

Author: Copilot

crates/pet-conda/tests/ci_test.rs

@@ -132,8 +132,12 @@ fn detect_new_conda_env() {
     let env = environments
         .iter()
         .find(|x| x.name == Some(env_name.into()))
-        .unwrap_or_else(|| panic!("New Environment not created, detected envs {:?}",
-                environments));
+        .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());
@@ -226,8 +230,12 @@ fn detect_new_conda_env_without_python() {
     let env = environments
         .iter()
         .find(|x| x.name == Some(env_name.into()))
-        .unwrap_or_else(|| panic!("New Environment not created, detected envs {:?}",
-                environments));
+        .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());
@@ -271,8 +279,12 @@ fn detect_new_conda_env_created_with_p_flag_without_python() {
     let env = environments
         .iter()
         .find(|x| x.prefix == Some(prefix.clone()))
-        .unwrap_or_else(|| panic!("New Environment ({:?}) not created, detected envs {:?}",
-                prefix, environments));
+        .unwrap_or_else(|| {
+            panic!(
+                "New Environment ({:?}) not created, detected envs {:?}",
+                prefix, environments
+            )
+        });
 
     assert_eq!(env.prefix, prefix.clone().into());
     assert_eq!(env.name, None);
@@ -319,8 +331,12 @@ fn detect_new_conda_env_created_with_p_flag_with_python() {
     let env = environments
         .iter()
         .find(|x| x.prefix == Some(prefix.clone()))
-        .unwrap_or_else(|| panic!("New Environment not created, detected envs {:?}",
-                environments));
+        .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/utils_test.rs

@@ -23,8 +23,7 @@ fn is_not_conda_install() {
     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"]);
+    let path: PathBuf = resolve_test_path(&["unix", "anaconda3-2023.03", "envs", "env_python_3"]);
     assert!(!utils::is_conda_install(&path));
 }
 
@@ -37,8 +36,7 @@ fn is_conda_env() {
     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"]);
+    let path: PathBuf = resolve_test_path(&["unix", "anaconda3-2023.03", "envs", "env_python_3"]);
     assert!(utils::is_conda_env(&path));
 }
 

crates/pet-poetry/src/config.rs

@@ -241,56 +241,46 @@ create = false
 
 "#;
 
-        assert!(
-            !parse_contents(cfg)
-                .unwrap()
-                .virtualenvs_in_project
-                .unwrap_or_default()
-        );
+        assert!(!parse_contents(cfg)
+            .unwrap()
+            .virtualenvs_in_project
+            .unwrap_or_default());
 
         let cfg = r#"
 [virtualenvs]
 in-project = true
 create = false
 
 "#;
-        assert!(
-            parse_contents(cfg)
-                .unwrap()
-                .virtualenvs_in_project
-                .unwrap_or_default()
-        );
+        assert!(parse_contents(cfg)
+            .unwrap()
+            .virtualenvs_in_project
+            .unwrap_or_default());
 
         let cfg = r#"
 [virtualenvs]
 create = false
 
 "#;
-        assert!(
-            !parse_contents(cfg)
-                .unwrap()
-                .virtualenvs_in_project
-                .unwrap_or_default()
-        );
+        assert!(!parse_contents(cfg)
+            .unwrap()
+            .virtualenvs_in_project
+            .unwrap_or_default());
 
         let cfg = r#"
 virtualenvs.in-project = true # comment
 "#;
-        assert!(
-            parse_contents(cfg)
-                .unwrap()
-                .virtualenvs_in_project
-                .unwrap_or_default()
-        );
+        assert!(parse_contents(cfg)
+            .unwrap()
+            .virtualenvs_in_project
+            .unwrap_or_default());
 
         let cfg = r#"
 "#;
-        assert!(
-            !parse_contents(cfg)
-                .unwrap()
-                .virtualenvs_in_project
-                .unwrap_or_default()
-        );
+        assert!(!parse_contents(cfg)
+            .unwrap()
+            .virtualenvs_in_project
+            .unwrap_or_default());
     }
 
     #[test]
@@ -326,10 +316,7 @@ virtualenvs.path = "/path/to/virtualenvs"
 some-other-value = 1234
 
 "#;
-        assert_eq!(
-            parse_contents(cfg).unwrap().virtualenvs_path,
-            None
-        );
+        assert_eq!(parse_contents(cfg).unwrap().virtualenvs_path, None);
     }
 
     #[test]

crates/pet-poetry/tests/config_test.rs

@@ -69,13 +69,11 @@ fn global_config_with_specific_values() {
             "config.toml"
         ]))
     );
-    assert!(
-        config
-            .clone()
-            .unwrap()
-            .virtualenvs_in_project
-            .unwrap_or_default()
-    );
+    assert!(config
+        .clone()
+        .unwrap()
+        .virtualenvs_in_project
+        .unwrap_or_default());
     assert_eq!(
         config.clone().unwrap().virtualenvs_path,
         PathBuf::from("some/path/virtualenvs".to_string())
@@ -115,13 +113,11 @@ fn local_config_with_specific_values() {
             "poetry.toml"
         ]))
     );
-    assert!(
-        !config
-            .clone()
-            .unwrap()
-            .virtualenvs_in_project
-            .unwrap_or_default()
-    );
+    assert!(!config
+        .clone()
+        .unwrap()
+        .virtualenvs_in_project
+        .unwrap_or_default());
     assert_eq!(
         config.clone().unwrap().virtualenvs_path,
         PathBuf::from("/directory/virtualenvs".to_string())

crates/pet-pyenv/tests/pyenv_test.rs

@@ -60,12 +60,8 @@ fn does_not_find_any_pyenv_envs_even_with_pyenv_installed() {
         "bin",
     ]);
     let pyenv_exe = resolve_test_path(&[homebrew_bin.to_str().unwrap(), "pyenv"]);
-    let environment = create_test_environment(
-        HashMap::new(),
-        Some(home.clone()),
-        vec![homebrew_bin],
-        None,
-    );
+    let environment =
+        create_test_environment(HashMap::new(), Some(home.clone()), vec![homebrew_bin], None);
 
     let conda = Arc::new(Conda::from(&environment));
     let locator = PyEnv::from(&environment, conda);
@@ -116,12 +112,8 @@ fn find_pyenv_envs() {
     ]);
     let conda_exe = conda_dir.join("bin").join("conda");
 
-    let environment = create_test_environment(
-        HashMap::new(),
-        Some(home.clone()),
-        vec![homebrew_bin],
-        None,
-    );
+    let environment =
+        create_test_environment(HashMap::new(), Some(home.clone()), vec![homebrew_bin], None);
 
     let conda = Arc::new(Conda::from(&environment));
     let locator = PyEnv::from(&environment, conda);

crates/pet-python-utils/tests/sys_prefix_test.rs

@@ -34,8 +34,7 @@ fn version_from_sys_prefix_using_version_info_format() {
 #[cfg(unix)]
 #[test]
 fn no_version_without_pyvenv_cfg_and_without_headers() {
-    let path: PathBuf =
-        resolve_test_path(&["unix", "pyvenv_cfg", "python3.9.9_without_headers"]);
+    let path: PathBuf = resolve_test_path(&["unix", "pyvenv_cfg", "python3.9.9_without_headers"]);
     let version = version::from_prefix(&path);
     assert!(version.is_none());
 

crates/pet/tests/ci_test.rs

@@ -290,12 +290,11 @@ fn verify_validity_of_interpreter_info(environment: PythonEnvironment) {
                 && interpreter_info.clone().sys_prefix == "/usr/local/python/3.10.13")
             || (prefix.to_str().unwrap() == "/usr/local/python/3.10.13"
                 && interpreter_info.clone().sys_prefix == "/usr/local/python/current"))
-        || (interpreter_info.clone().executable
-            == "/home/codespace/.python/current/bin/python"
-            && (prefix.to_str().unwrap() == "/home/codespace/.python/current"
-                && interpreter_info.clone().sys_prefix == "/usr/local/python/3.10.13")
-            || (prefix.to_str().unwrap() == "/usr/local/python/3.10.13"
-                && interpreter_info.clone().sys_prefix == "/home/codespace/.python/current"))
+            || (interpreter_info.clone().executable == "/home/codespace/.python/current/bin/python"
+                && (prefix.to_str().unwrap() == "/home/codespace/.python/current"
+                    && interpreter_info.clone().sys_prefix == "/usr/local/python/3.10.13")
+                || (prefix.to_str().unwrap() == "/usr/local/python/3.10.13"
+                    && interpreter_info.clone().sys_prefix == "/home/codespace/.python/current"))
         {
             // known issue https://github.com/microsoft/python-environment-tools/issues/64
         } else {
@@ -367,7 +366,9 @@ fn verify_we_can_get_same_env_info_using_from_with_exe(
     let env = PythonEnv::new(executable.clone(), None, None);
     let resolved =
         identify_python_environment_using_locators(&env, &locators, &global_env_search_paths)
-            .unwrap_or_else(|| panic!("Failed to resolve environment using `resolve` for {environment:?}"));
+            .unwrap_or_else(|| {
+                panic!("Failed to resolve environment using `resolve` for {environment:?}")
+            });
     trace!(
         "For exe {:?} we got Environment = {:?}, To compare against {:?}",
         executable,
@@ -488,17 +489,19 @@ fn compare_environments(actual: PythonEnvironment, expected: PythonEnvironment,
     actual.version = expected.clone().version;
 
     if let Some(prefix) = expected.clone().prefix {
-        if (actual.clone().executable == Some(PathBuf::from("/usr/local/python/current/bin/python"))
+        if (actual.clone().executable
+            == Some(PathBuf::from("/usr/local/python/current/bin/python"))
             && (prefix.to_str().unwrap() == "/usr/local/python/current"
                 && actual.clone().prefix == Some(PathBuf::from("/usr/local/python/3.10.13")))
             || (prefix.to_str().unwrap() == "/usr/local/python/3.10.13"
                 && actual.clone().prefix == Some(PathBuf::from("/usr/local/python/current"))))
-        || (actual.clone().executable
-            == Some(PathBuf::from("/home/codespace/.python/current/bin/python"))
-            && (prefix.to_str().unwrap() == "/home/codespace/.python/current"
-                && actual.clone().prefix == Some(PathBuf::from("/usr/local/python/3.10.13")))
-            || (prefix.to_str().unwrap() == "/usr/local/python/3.10.13"
-                && actual.clone().prefix == Some(PathBuf::from("/home/codespace/.python/current"))))
+            || (actual.clone().executable
+                == Some(PathBuf::from("/home/codespace/.python/current/bin/python"))
+                && (prefix.to_str().unwrap() == "/home/codespace/.python/current"
+                    && actual.clone().prefix == Some(PathBuf::from("/usr/local/python/3.10.13")))
+                || (prefix.to_str().unwrap() == "/usr/local/python/3.10.13"
+                    && actual.clone().prefix
+                        == Some(PathBuf::from("/home/codespace/.python/current"))))
         {
             // known issue https://github.com/microsoft/python-environment-tools/issues/64
             actual.prefix = expected.clone().prefix;
@@ -513,7 +516,8 @@ fn compare_environments(actual: PythonEnvironment, expected: PythonEnvironment,
             .iter()
             .filter(|p| {
                 // This is in the path, but not easy to figure out, unless we add support for codespaces or CI.
-                !(p.starts_with("/Users/runner/hostedtoolcache/Python") && p.to_string_lossy().contains("arm64"))
+                !(p.starts_with("/Users/runner/hostedtoolcache/Python")
+                    && p.to_string_lossy().contains("arm64"))
             })
             .map(|p| p.to_path_buf())
             .collect::<Vec<PathBuf>>(),
@@ -526,30 +530,35 @@ fn compare_environments(actual: PythonEnvironment, expected: PythonEnvironment,
             .iter()
             .filter(|p| {
                 // This is in the path, but not easy to figure out, unless we add support for codespaces or CI.
-                !(p.starts_with("/Users/runner/hostedtoolcache/Python") && p.to_string_lossy().contains("arm64"))
+                !(p.starts_with("/Users/runner/hostedtoolcache/Python")
+                    && p.to_string_lossy().contains("arm64"))
             })
             .map(|p| p.to_path_buf())
             .collect::<Vec<PathBuf>>(),
     );
 
     // if we know the arch, then verify it
-    if expected.arch.as_ref().is_some() && actual.arch.as_ref().is_some()
-        && actual.arch.as_ref() != expected.arch.as_ref() {
-            error!(
-                "Arch mismatch when using {} for {:?} and {:?}",
-                method, expected, actual
-            );
-        }
+    if expected.arch.as_ref().is_some()
+        && actual.arch.as_ref().is_some()
+        && actual.arch.as_ref() != expected.arch.as_ref()
+    {
+        error!(
+            "Arch mismatch when using {} for {:?} and {:?}",
+            method, expected, actual
+        );
+    }
     actual.arch = expected.clone().arch;
 
     // if we know the prefix, then verify it
-    if expected.prefix.as_ref().is_some() && actual.prefix.as_ref().is_some()
-        && actual.prefix.as_ref() != expected.prefix.as_ref() {
-            error!(
-                "Prefirx mismatch when using {} for {:?} and {:?}",
-                method, expected, actual
-            );
-        }
+    if expected.prefix.as_ref().is_some()
+        && actual.prefix.as_ref().is_some()
+        && actual.prefix.as_ref() != expected.prefix.as_ref()
+    {
+        error!(
+            "Prefirx mismatch when using {} for {:?} and {:?}",
+            method, expected, actual
+        );
+    }
     actual.prefix = expected.clone().prefix;
 
     assert_eq!(
@@ -596,8 +605,9 @@ fn verify_we_can_get_same_env_info_using_resolve_with_exe(
         locator.configure(&config);
     }
 
-    let env = resolve_environment(executable, &locators, &os_environment)
-        .unwrap_or_else(|| panic!("Failed to resolve environment using `resolve` for {environment:?}"));
+    let env = resolve_environment(executable, &locators, &os_environment).unwrap_or_else(|| {
+        panic!("Failed to resolve environment using `resolve` for {environment:?}")
+    });
     trace!(
         "For exe {:?} we got Environment = {:?}, To compare against {:?}",
         executable,