//! Environment Setup Module
 //!
 //! Handles the initialization and setup of the build environment for generating
 //! shellcode loaders. This includes verifying prerequisites, creating temporary
 //! directories, and managing the working directory.
 //!
 //! # Workflow
 //!
 //! 1. Verify cargo is installed and accessible
 //! 2. Create a unique temporary directory for the build
 //! 3. Change the working directory to the temp location
 //!
 //! # Safety
 //!
 //! Functions that modify the working directory are not thread-safe. Tests that
 //! use these functions must serialize using `TEST_DIR_MUTEX` to prevent race
 //! conditions.
 //!
 //! # Example
 //!
 //! ```no_run
 //! use myph_v2::env_setup::setup_environment;
 //!
 //! let temp_dir = setup_environment().expect("Failed to setup environment");
 //! println!("Build directory: {:?}", temp_dir);
 //! ```
 
 use std::env;
 use std::io;
 use std::path::PathBuf;
 use std::process::Command;
 
 /// Check if cargo is installed on the system
 ///
 /// Returns `Ok(())` if cargo is installed and accessible via PATH,
 /// otherwise returns an error.
 pub fn check_cargo_installed() -> io::Result<()> {
     let status = Command::new("cargo")
         .arg("--version")
         .stdout(std::process::Stdio::null())
         .stderr(std::process::Stdio::null())
         .status()?;
 
     if status.success() {
         Ok(())
     } else {
         Err(io::Error::new(
             io::ErrorKind::NotFound,
             "cargo command failed to execute",
         ))
     }
 }
 
 /// Create a temporary directory and return its path
 ///
 /// Creates a new temporary directory with a unique name in the system temp directory.
 /// Note: The directory will NOT be automatically cleaned up and must be
 /// manually removed when no longer needed.
 ///
 /// Returns the path to the newly created temporary directory.
 pub fn create_temp_directory() -> io::Result<PathBuf> {
     let base_temp_dir = env::temp_dir();
 
     let unique_dir = base_temp_dir.join(format!("myph-{}", rand::random::<u32>()));
 
     std::fs::create_dir_all(&unique_dir)?;
 
     Ok(unique_dir)
 }
 
 /// Change the current working directory to the specified path
 ///
 /// # Arguments
 ///
 /// * `path` - The path to change to
 ///
 /// Returns `Ok(())` if successful, otherwise returns an error.
 pub fn change_working_directory(path: &PathBuf) -> io::Result<()> {
     env::set_current_dir(path)?;
     Ok(())
 }
 
 /// Setup the environment for running the application
 ///
 /// This function performs the following steps:
 /// 1. Checks if cargo is installed
 /// 2. Creates a temporary directory
 /// 3. Changes the working directory to the temporary directory
 ///
 /// Returns the path to the temporary directory if successful,
 /// otherwise returns an error describing what went wrong.
 pub fn setup_environment() -> io::Result<PathBuf> {
     check_cargo_installed().map_err(|e| {
         io::Error::new(
             io::ErrorKind::NotFound,
             format!("cargo is not installed or not in PATH: {}", e),
         )
     })?;
 
     let temp_dir = create_temp_directory()?;
 
     change_working_directory(&temp_dir)?;
 
     Ok(temp_dir)
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
     use crate::TEST_DIR_MUTEX;
     use std::env;
 
     #[test]
     fn test_check_cargo_installed() {
         // This test assumes cargo is installed in the test environment
         let result = check_cargo_installed();
         assert!(
             result.is_ok(),
             "cargo should be installed in test environment"
         );
     }
 
     #[test]
     fn test_create_temp_directory() {
         let result = create_temp_directory();
         assert!(result.is_ok(), "should be able to create temp directory");
 
         let temp_path = result.unwrap();
         assert!(temp_path.exists(), "temp directory should exist");
         assert!(temp_path.is_dir(), "temp path should be a directory");
 
         // Clean up
         let _ = std::fs::remove_dir_all(&temp_path);
     }
 
     #[test]
     fn test_change_working_directory() {
         let _lock = TEST_DIR_MUTEX.lock().unwrap_or_else(|e| e.into_inner());
 
         // Save current directory
         let original_dir = env::current_dir().unwrap();
 
         // Create a temp directory
         let temp_dir = create_temp_directory().unwrap();
 
         // Change to it
         let result = change_working_directory(&temp_dir);
         assert!(result.is_ok(), "should be able to change directory");
 
         // Verify we're in the new directory
         let current_dir = env::current_dir().unwrap();
         assert_eq!(current_dir, temp_dir, "should be in temp directory");
 
         // Clean up - change back to original directory
         let _ = env::set_current_dir(&original_dir);
         let _ = std::fs::remove_dir_all(&temp_dir);
     }
 
     #[test]
     fn test_setup_environment() {
         let _lock = TEST_DIR_MUTEX.lock().unwrap_or_else(|e| e.into_inner());
 
         // Save current directory
         let original_dir = env::current_dir().unwrap();
 
         // Run setup
         let result = setup_environment();
         assert!(result.is_ok(), "setup_environment should succeed");
 
         let temp_dir = result.unwrap();
         assert!(temp_dir.exists(), "temp directory should exist");
 
         // Verify we changed to the temp directory
         let current_dir = env::current_dir().unwrap();
         assert_eq!(current_dir, temp_dir, "should be in temp directory");
 
         // Clean up
         let _ = env::set_current_dir(&original_dir);
         let _ = std::fs::remove_dir_all(&temp_dir);
     }
 
     #[test]
     fn test_change_to_nonexistent_directory() {
         let nonexistent_path = env::temp_dir().join("definitely-does-not-exist-123456789");
         let result = change_working_directory(&nonexistent_path);
         assert!(
             result.is_err(),
             "should fail to change to nonexistent directory"
         );
     }
 }

© 2024 - 2026 djnn, inc • generated with stagit