feat: Enable global expose with nested paths

crates/pixi_utils/src/executable_utils.rs

@@ -83,6 +83,7 @@ mod tests {
     #[case::python3_config("python3-config", "python3-config")]
     #[case::x2to3("2to3", "2to3")]
     #[case::x2to3312("2to3-3.12", "2to3-3.12")]
+    #[case::nested_executable("subdir/executable.sh", "subdir/executable")]
     fn test_strip_executable_unix(#[case] path: &str, #[case] expected: &str) {
         let path = Path::new(path);
         let result = strip_unix_executable_extension(path.to_string_lossy().to_string());
@@ -100,6 +101,7 @@ mod tests {
     #[case::python3_config("python3-config", "python3-config")]
     #[case::x2to3("2to3", "2to3")]
     #[case::x2to3312("2to3-3.12", "2to3-3.12")]
+    #[case::nested_executable("subdir\\executable.exe", "subdir\\executable")]
     fn test_strip_executable_windows(#[case] path: &str, #[case] expected: &str) {
         let path = Path::new(path);
         let result = strip_windows_executable_extension(path.to_string_lossy().to_string());
@@ -114,6 +116,7 @@ mod tests {
     #[case::package010("package0.1.0", "package0.1.0")]
     #[case::x2to3("2to3", "2to3")]
     #[case::x2to3312("2to3-3.12", "2to3-3.12")]
+    #[case::nested_executable("subdir/executable", "subdir/executable")]
     fn test_strip_executable_extension(#[case] path: &str, #[case] expected: &str) {
         let result = strip_executable_extension(path.into());
         assert_eq!(result, expected);

docs/features/global_tools.md

@@ -149,6 +149,25 @@ exposed = { ansible = "ansible" } # (1)!
 
 1. The `ansible` binary is exposed even though it is installed by a dependency of `ansible`, the `ansible-core` package.
 
+It's also possible to expose an executable which is located in a nested directory.
+For example dotnet.exe executable is located in a dotnet folder,
+to expose dotnet.exe you must specify its relative path :
+
+```
+pixi global install dotnet --expose dotnet=dotnet\dotnet.exe
+```
+you can also omit the extension
+```
+pixi global install dotnet --expose dotnet=dotnet\dotnet
+```
+will create the following entry in the manifest:
+```toml
+[envs.dotnet]
+channels = ["conda-forge"]
+dependencies = { dotnet = "*" }
+exposed = { dotnet = 'dotnet\dotnet' }
+```
+
 ### Dependencies
 Dependencies are the **Conda** packages that will be installed into your environment. For example, running:
 ```

src/global/common.rs

@@ -975,70 +975,87 @@ mod tests {
             ExposedName::from_str("test").unwrap(),
             "test".to_string(),
         ));
+        exposed.insert(Mapping::new(
+            ExposedName::from_str("nested_test").unwrap(),
+            Path::new("other_dir")
+                .join("nested_test")
+                .to_str()
+                .unwrap()
+                .to_string(),
+        ));
         let (to_remove, to_add) = get_expose_scripts_sync_status(&bin_dir, &env_dir, &exposed)
             .await
             .unwrap();
         assert!(to_remove.is_empty());
-        assert_eq!(to_add.len(), 1);
+        assert_eq!(to_add.len(), 2);
 
         // Add a legacy script to the bin directory
-        // even if it's should be exposed and it's pointing to correct executable
+        // even if it should be exposed and it's pointing to correct executable
         // it is an old script
         // we need to remove it and replace with trampoline
-        let script_path = if cfg!(windows) {
-            bin_dir.path().join("test.bat")
-        } else {
-            bin_dir.path().join("test")
-        };
+        let script_names = ["test", "nested_test"];
 
         #[cfg(windows)]
         {
-            let script = format!(
-                r#"
+            for script_name in script_names {
+                let script_path = bin_dir.path().join(format!("{}.bat", script_name));
+                let script = format!(
+                    r#"
             @"{}" %*
             "#,
-                env_dir
-                    .path()
-                    .join("bin")
-                    .join("test.exe")
-                    .to_string_lossy()
-            );
-            tokio_fs::write(&script_path, script).await.unwrap();
+                    env_dir
+                        .path()
+                        .join("bin")
+                        .join(format!("{}.exe", script_name))
+                        .to_string_lossy()
+                );
+                tokio_fs::write(&script_path, script).await.unwrap();
+            }
         }
         #[cfg(unix)]
         {
             use std::os::unix::fs::PermissionsExt;
 
-            let script = format!(
-                r#"#!/bin/sh
+            for script_name in script_names {
+                let script_path = bin_dir.path().join(script_name);
+                let script = format!(
+                    r#"#!/bin/sh
             "{}" "$@"
             "#,
-                env_dir.path().join("bin").join("test").to_string_lossy()
-            );
-            tokio_fs::write(&script_path, script).await.unwrap();
-            // Set the file permissions to make it executable
-            let metadata = tokio_fs::metadata(&script_path).await.unwrap();
-            let mut permissions = metadata.permissions();
-            permissions.set_mode(0o755); // rwxr-xr-x
-            tokio_fs::set_permissions(&script_path, permissions)
-                .await
-                .unwrap();
+                    env_dir
+                        .path()
+                        .join("bin")
+                        .join(script_name)
+                        .to_string_lossy()
+                );
+                tokio_fs::write(&script_path, script).await.unwrap();
+                // Set the file permissions to make it executable
+                let metadata = tokio_fs::metadata(&script_path).await.unwrap();
+                let mut permissions = metadata.permissions();
+                permissions.set_mode(0o755); // rwxr-xr-x
+                tokio_fs::set_permissions(&script_path, permissions)
+                    .await
+                    .unwrap();
+            }
         };
 
-        let (mut to_remove, mut to_add) =
-            get_expose_scripts_sync_status(&bin_dir, &env_dir, &exposed)
-                .await
-                .unwrap();
-        assert!(to_remove.pop().unwrap().exposed_name().to_string() == "test");
-        assert!(to_add.pop().unwrap().to_string() == "test");
+        // Test to_remove and to_add to see if the legacy scripts are removed and trampolines are added
+        let (to_remove, to_add) = get_expose_scripts_sync_status(&bin_dir, &env_dir, &exposed)
+            .await
+            .unwrap();
+        assert!(to_remove.iter().all(|bin| !bin.is_trampoline()));
+        assert_eq!(to_remove.len(), 2);
+        assert_eq!(to_add.len(), 2);
 
         // Test to_remove when nothing should be exposed
-        let (mut to_remove, to_add) =
+        // it should remove all the legacy scripts and add nothing
+        let (to_remove, to_add) =
             get_expose_scripts_sync_status(&bin_dir, &env_dir, &IndexSet::new())
                 .await
                 .unwrap();
 
-        assert!(to_remove.pop().unwrap().exposed_name().to_string() == "test");
+        assert!(to_remove.iter().all(|bin| !bin.is_trampoline()));
+        assert_eq!(to_remove.len(), 2);
         assert!(to_add.is_empty());
     }
 
@@ -1100,8 +1117,9 @@ mod tests {
             get_expose_scripts_sync_status(&bin_dir, &env_dir, &IndexSet::new())
                 .await
                 .unwrap();
+        assert_eq!(to_remove.len(), 1);
 
-        assert!(to_remove.pop().unwrap().exposed_name().to_string() == "test");
+        assert_eq!(to_remove.pop().unwrap().exposed_name().to_string(), "test");
         assert!(to_add.is_empty());
     }
 }

src/global/list.rs

@@ -52,13 +52,13 @@ pub fn format_exposed(exposed: &IndexSet<Mapping>, last: bool) -> Option<String>
 
 fn format_mapping(mapping: &Mapping) -> String {
     let exp = mapping.exposed_name().to_string();
-    if exp == mapping.executable_name() {
+    if exp == mapping.executable_relname() {
         console::style(exp).yellow().to_string()
     } else {
         format!(
             "{} -> {}",
             console::style(exp).yellow(),
-            console::style(mapping.executable_name()).yellow()
+            console::style(mapping.executable_relname()).yellow()
         )
     }
 }

src/global/mod.rs

@@ -5,9 +5,10 @@ pub(crate) mod project;
 pub(crate) mod trampoline;
 
 pub(crate) use common::{BinDir, EnvChanges, EnvDir, EnvRoot, EnvState, StateChange, StateChanges};
+use pixi_utils::executable_from_path;
 pub(crate) use project::{EnvironmentName, ExposedName, Mapping, Project};
 
-use crate::prefix::Prefix;
+use crate::prefix::{Executable, Prefix};
 use rattler_conda_types::PrefixRecord;
 use std::path::{Path, PathBuf};
 
@@ -22,33 +23,26 @@ fn find_executables(prefix: &Prefix, prefix_package: &PrefixRecord) -> Vec<PathB
         .collect()
 }
 
-fn is_executable(prefix: &Prefix, relative_path: &Path) -> bool {
-    // Check if the file is in a known executable directory.
-    let binary_folders = if cfg!(windows) {
-        &([
-            "",
-            "Library/mingw-w64/bin/",
-            "Library/usr/bin/",
-            "Library/bin/",
-            "Scripts/",
-            "bin/",
-        ][..])
-    } else {
-        &(["bin"][..])
-    };
-
-    let parent_folder = match relative_path.parent() {
-        Some(dir) => dir,
-        None => return false,
-    };
-
-    if !binary_folders
+/// Processes prefix records (that you can get by using `find_installed_packages`)
+/// to filter and collect executable files.
+pub fn find_executables_for_many_records(
+    prefix: &Prefix,
+    prefix_packages: &[PrefixRecord],
+) -> Vec<Executable> {
+    let executables = prefix_packages
         .iter()
-        .any(|bin_path| Path::new(bin_path) == parent_folder)
-    {
-        return false;
-    }
+        .flat_map(|record| {
+            record
+                .files
+                .iter()
+                .filter(|relative_path| is_executable(prefix, relative_path))
+                .map(|path| Executable::new(executable_from_path(path), path.clone()))
+        })
+        .collect();
+    executables
+}
 
+fn is_executable(prefix: &Prefix, relative_path: &Path) -> bool {
     // Check if the file is executable
     let absolute_path = prefix.root().join(relative_path);
     is_executable::is_executable(absolute_path)