v1 of the shim extracted from other work

Author: arrdem

py/tools/venv_shim/BUILD.bazel

@@ -6,6 +6,7 @@ rust_binary(
         "src/main.rs",
     ],
     deps = [
+        "@crate_index//:miette",
     ],
 )
 

py/tools/venv_shim/Cargo.toml

@@ -9,14 +9,14 @@ edition.workspace = true
 readme.workspace = true
 rust-version.workspace = true
 
+[features]
+debug = []
+
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [[bin]]
 name = "python_shim"
 path = "src/main.rs"
 
 [dependencies]
-#libc = { workspace = true }
-#clap = { workspace = true }
-#miette = { workspace = true }
-#py = { path = "../py" }
+miette = { workspace = true }

py/tools/venv_shim/src/main.rs

@@ -1,18 +1,11 @@
+use miette::miette;
 use std::env;
 use std::fs;
 use std::io::{self, BufRead};
 use std::os::unix::process::CommandExt;
 use std::path::{Path, PathBuf};
 use std::process::Command;
 
-fn compare_versions(version_from_cfg: &str, executable_path: &Path) -> bool {
-    if let Some(file_name) = executable_path.file_name().and_then(|n| n.to_str()) {
-        return file_name.ends_with(&format!("python{}", version_from_cfg));
-    } else {
-        false
-    }
-}
-
 fn find_pyvenv_cfg(start_path: &Path) -> Option<PathBuf> {
     let parent = start_path.parent()?.parent()?;
     let cfg_path = parent.join("pyvenv.cfg");
@@ -39,7 +32,30 @@ fn extract_pyvenv_version_info(cfg_path: &Path) -> Result<Option<String>, io::Er
     Ok(None)
 }
 
-fn find_python_executables(version_from_cfg: &str, exclude_dir: &Path) -> Option<Vec<PathBuf>> {
+fn parse_version_info(version_str: &str) -> Option<String> {
+    // To avoid pulling in the regex crate, we're gonna do this by hand.
+    let parts: Vec<_> = version_str.split(".").collect();
+    match parts[..] {
+        [major, minor, ..] => Some(format!("{}.{}", major, minor)),
+        _ => None,
+    }
+}
+
+fn compare_versions(
+    version_from_cfg: &str,
+    executable_path: &Path,
+) -> bool {
+    if let Some(file_name) = executable_path.file_name().and_then(|n| n.to_str()) {
+        return file_name.ends_with(&format!("python{}", version_from_cfg));
+    } else {
+        false
+    }
+}
+
+fn find_python_executables(
+    version_from_cfg: &str,
+    exclude_dir: &Path,
+) -> Option<Vec<PathBuf>> {
     let python_prefix = format!("python{}", version_from_cfg);
     let path_env = env::var_os("PATH")?;
 
@@ -63,80 +79,65 @@ fn find_python_executables(version_from_cfg: &str, exclude_dir: &Path) -> Option
     }
 }
 
-fn parse_version_info(version_str: &str) -> Option<String> {
-    // To avoid pulling in the regex crate, we're gonna do this by hand.
-    let parts: Vec<_> = version_str.split(".").collect();
-    match parts[..] {
-        [major, minor, ..] => Some(format!("{}.{}", major, minor)),
-        _ => None,
-    }
-}
-
-fn main() -> () {
+fn main() -> miette::Result<()> {
     let current_exe = env::current_exe().unwrap();
     let args: Vec<_> = env::args().collect();
-    println!("In the Aspect venv shim!");
+
+    #[cfg(feature = "debug")]
     println!("[aspect] Current executable path: {:?}", current_exe);
 
     let pyvenv_cfg_path = match find_pyvenv_cfg(&current_exe) {
         Some(path) => {
-            println!("[aspect] Found pyvenv.cfg at: {:?}", path);
+            #[cfg(feature = "debug")]
+            eprintln!("[aspect] Found pyvenv.cfg at: {:?}", path);
             path
         }
         None => {
-            eprintln!("pyvenv.cfg not found one directory level up.");
-            return;
+            return Err(miette!("pyvenv.cfg not found one directory level up."));
         }
     };
 
     let version_info_result = extract_pyvenv_version_info(&pyvenv_cfg_path).unwrap();
     let version_info = match version_info_result {
         Some(v) => {
-            println!("[aspect] version_info from pyvenv.cfg: {}", v);
+            #[cfg(feature = "debug")]
+            eprintln!("[aspect] version_info from pyvenv.cfg: {}", v);
             v
         }
         None => {
-            eprintln!("version_info key not found in pyvenv.cfg.");
-            return;
+            return Err(miette!("version_info key not found in pyvenv.cfg."));
         }
     };
 
     let target_python_version = match parse_version_info(&version_info) {
         Some(v) => {
-            println!("[aspect] Parsed target Python version (major.minor): {}", v);
+            #[cfg(feature = "debug")]
+            eprintln!("[aspect] Parsed target Python version (major.minor): {}", v);
             v
         }
         None => {
-            eprintln!("Could not parse version_info as x.y.");
-            return;
+            return Err(miette!("Could not parse version_info as x.y."));
         }
     };
 
-    if target_python_version.is_empty() {
-        eprintln!("Target Python version is empty.");
-        return;
-    }
-
     let exclude_dir = current_exe.parent().unwrap();
     if let Some(python_executables) = find_python_executables(&target_python_version, exclude_dir) {
-        if python_executables.is_empty() {
+        #[cfg(feature = "debug")]
+        {
             eprintln!(
-                "No suitable Python interpreter found in PATH matching version '{}'.",
-                target_python_version
+                "[aspect] Found potential Python interpreters in PATH with matching version:"
             );
-            return;
-        }
-
-        println!("[aspect] Found potential Python interpreters in PATH with matching version:");
-        for exe in &python_executables {
-            println!("[aspect] - {:?}", exe);
+            for exe in &python_executables {
+                println!("[aspect] - {:?}", exe);
+            }
         }
 
         let interpreter_path = &python_executables[0];
         let exe_path = current_exe.to_string_lossy().into_owned();
         let exec_args = &args[1..];
 
-        println!(
+        #[cfg(feature = "debug")]
+        eprintln!(
             "[aspect] Attempting to execute: {:?} with argv[0] as {:?} and args as {:?}",
             interpreter_path, exe_path, exec_args,
         );
@@ -162,5 +163,12 @@ fn main() -> () {
         }
 
         let _ = cmd.exec();
+
+        return Ok(());
+    } else {
+        return Err(miette!(
+            "No suitable Python interpreter found in PATH matching version '{}'.",
+            &version_info,
+        ));
     }
 }