Maintain/Build/

Process.rs

//=============================================================================//
// File Path: Element/Maintain/Source/Build/Process.rs
//=============================================================================//
// Module: Process
//
// Brief Description: Main orchestration logic for preparing and executing the build.
//
// RESPONSIBILITIES:
// ================
//
// Primary:
// - Orchestrate the entire build process from start to finish
// - Generate product names and bundle identifiers
// - Modify configuration files for specific build flavors
// - Stage and bundle Node.js sidecar binaries if needed
// - Execute the final build command
//
// Secondary:
// - Provide detailed logging of build orchestration steps
// - Ensure cleanup of temporary files
//
// ARCHITECTURAL ROLE:
// ===================
//
// Position:
// - Core/Orchestration layer
// - Build process coordination
//
// Dependencies (What this module requires):
// - External crates: std (env, fs, path, process, os), log, toml
// - Internal modules: Constant::*, Definition::*, Error::BuildError, Function::*
// - Traits implemented: None
//
// Dependents (What depends on this module):
// - Main entry point
// - Fn function
//
// IMPLEMENTATION DETAILS:
// =======================
//
// Design Patterns:
// - Orchestration pattern
// - Guard pattern (for file backup/restoration)
//
// Performance Considerations:
// - Complexity: O(n) - file I/O operations dominate
// - Memory usage patterns: Moderate (stores configuration data in memory)
// - Hot path optimizations: None needed (build time is user-facing)
//
// Thread Safety:
// - Thread-safe: No (not designed for concurrent execution)
// - Synchronization mechanisms used: None
// - Interior mutability considerations: None
//
// Error Handling:
// - Error types returned: BuildError (various)
// - Recovery strategies: Guard restores files on error
//
// EXAMPLES:
// =========
//
// Example 1: Basic build orchestration
/// ```rust
/// use crate::Maintain::Source::Build::Process;
/// use crate::Maintain::Source::Build::Argument;
/// let argument = Argument::parse();
/// Process(&argument)?;
/// ```
//
// Example 2: Handling build errors
/// ```rust
/// use crate::Maintain::Source::Build::Process;
/// match Process(&argument) {
/// Ok(_) => println!("Build succeeded"),
/// Err(e) => println!("Build failed: {}", e),
/// }
/// ```
//
//=============================================================================//
// IMPLEMENTATION
//=============================================================================//

use crate::Build::Error::Error as BuildError;
use crate::Build::Definition::{Argument, Guard, Manifest};
use crate::Build::JsonEdit::JsonEdit;
use crate::Build::TomlEdit::TomlEdit;
use crate::Build::WordsFromPascal::WordsFromPascal;
use crate::Build::Pascalize::Pascalize;
use crate::Build::GetTauriTargetTriple::GetTauriTargetTriple;

use crate::Build::Constant::{
CargoFile, JsonFile, JsonfiveFile,
NameDelimiter, IdDelimiter,
};

use log::info;
use std::{
    env, fs,
    path::PathBuf,
    process::{Command as ProcessCommand, Stdio},
};
use toml;

/// Main orchestration logic for preparing and executing the build.
///
/// This function is the core of the build system, coordinating all aspects
/// of preparing, building, and restoring project configurations. It:
///
/// 1. Validates the project directory and configuration files
/// 2. Creates guards to backup and restore configuration files
/// 3. Generates a unique product name and bundle identifier based on build flags
/// 4. Modifies Cargo.toml and Tauri configuration files
/// 5. Optionally stages a Node.js sidecar binary
/// 6. Executes the provided build command
/// 7. Cleans up temporary files after successful build
///
/// # Parameters
///
/// * `Argument` - Parsed command-line arguments and environment variables
///
/// # Returns
///
/// Returns `Ok(())` on successful build completion or a `BuildError` if
/// any step fails.
///
/// # Errors
///
/// * `BuildError::Missing` - If the project directory doesn't exist
/// * `BuildError::Config` - If Tauri configuration file not found
/// * `BuildError::Exists` - If a backup file already exists
/// * `BuildError::Io` - For file operation failures
/// * `BuildError::Edit` - For TOML editing failures
/// * `BuildError::Json` / `BuildError::Jsonfive` - For JSON/JSON5 parsing failures
/// * `BuildError::Parse` - For TOML parsing failures
/// * `BuildError::Shell` - If the build command fails
///
/// # Build Flavor Generation
///
/// The product name and bundle identifier are generated by combining:
///
/// - **Environment**: Node.js environment (development, production, etc.)
/// - **Dependency**: Dependency information (org/repo or generic)
/// - **Node Version**: Node.js version if bundling a sidecar
/// - **Build Flags**: Bundle, Clean, Browser, Compile, Debug
///
/// Example product name: `Development_GenDependency_22NodeVersion_Debug_Mountain`
///
/// Example bundle identifier: `land.editor.binary.development.generic.node.22.debug.mountain`
///
/// # Node.js Sidecar Bundling
///
/// If `NodeVersion` is specified:
/// - The Node.js binary is copied from `Element/SideCar/{triple}/NODE/{version}/`
/// - The binary is staged in the project's `Binary/` directory
/// - The Tauri configuration is updated to include the sidecar
/// - The binary is given appropriate permissions on Unix-like systems
/// - The temporary directory is cleaned up after successful build
///
/// # File Safety
///
/// All configuration file modifications are protected by the Guard pattern:
/// - Files are backed up before modification
/// - Files are automatically restored on error or when the guard drops
/// - This ensures the original state is preserved regardless of build outcome
///
/// # Example
///
/// ```no_run
/// use crate::Maintain::Source::Build::Process;
/// use crate::Maintain::Source::Build::Argument;
/// let argument = Argument::parse();
/// Process(&argument)?;
/// ```
pub fn Process(Argument: &Argument) -> Result<(), BuildError> {
    info!(target: "Build", "Starting build orchestration...");

    log::debug!(target: "Build", "Argument: {:?}", Argument);

    let ProjectDir = PathBuf::from(&Argument.Directory);

    if !ProjectDir.is_dir() {
        return Err(BuildError::Missing(ProjectDir));
    }

    let CargoPath = ProjectDir.join(CargoFile);

    let ConfigPath = {
        let Jsonfive = ProjectDir.join(JsonfiveFile);

        if Jsonfive.exists() {
            Jsonfive
        } else {
            ProjectDir.join(JsonFile)
        }
    };

    if !ConfigPath.exists() {
        return Err(BuildError::Config);
    }

    // Create guards for file backup and restoration
    let _CargoGuard = Guard::New(CargoPath.clone(), "Cargo.toml".to_string())?;

    let _ConfigGuard = Guard::New(ConfigPath.clone(), "Tauri config".to_string())?;

    let mut NamePartsForProductName = Vec::new();

    let mut NamePartsForId = Vec::new();

    // Include Node.js environment in product name
    if let Some(NodeValue) = &Argument.Environment {
        if !NodeValue.is_empty() {
            let PascalEnv = Pascalize(NodeValue);

            if !PascalEnv.is_empty() {
                NamePartsForProductName.push(format!("{}NodeEnvironment", PascalEnv));

                NamePartsForId.extend(WordsFromPascal(&PascalEnv));

                NamePartsForId.push("node".to_string());

                NamePartsForId.push("environment".to_string());
            }
        }
    }

    // Include dependency information in product name
    if let Some(DependencyValue) = &Argument.Dependency {
        if !DependencyValue.is_empty() {
            let (PascalDepBase, IdDepWords) = if DependencyValue.eq_ignore_ascii_case("true") {
                ("Generic".to_string(), vec!["generic".to_string()])
            } else if let Some((Org, Repo)) = DependencyValue.split_once('/') {
                (
                    format!("{}{}", Pascalize(Org), Pascalize(Repo)),
                    {
                        let mut w = WordsFromPascal(&Pascalize(Org));

                        w.extend(WordsFromPascal(&Pascalize(Repo)));

                        w
                    },
                )
            } else {
                (Pascalize(DependencyValue), WordsFromPascal(&Pascalize(DependencyValue)))
            };

            if !PascalDepBase.is_empty() {
                NamePartsForProductName.push(format!("{}Dependency", PascalDepBase));

                NamePartsForId.extend(IdDepWords);

                NamePartsForId.push("dependency".to_string());
            }
        }
    }

    // Include Node.js version in product name
    if let Some(Version) = &Argument.NodeVersion {
        if !Version.is_empty() {
            let PascalVersion = format!("{}NodeVersion", Version);

            NamePartsForProductName.push(PascalVersion.clone());

            NamePartsForId.push("node".to_string());

            NamePartsForId.push(Version.to_string());
        }
    }

    // Include build flags in product name
    if Argument.Bundle.as_ref().map_or(false, |v| v == "true") {
        NamePartsForProductName.push("Bundle".to_string());

        NamePartsForId.push("bundle".to_string());
    }

    if Argument.Clean.as_ref().map_or(false, |v| v == "true") {
        NamePartsForProductName.push("Clean".to_string());

        NamePartsForId.push("clean".to_string());
    }

    if Argument.Browser.as_ref().map_or(false, |v| v == "true") {
        NamePartsForProductName.push("Browser".to_string());

        NamePartsForId.push("browser".to_string());
    }

    if Argument.Compile.as_ref().map_or(false, |v| v == "true") {
        NamePartsForProductName.push("Compile".to_string());

        NamePartsForId.push("compile".to_string());
    }

    if Argument.Debug.as_ref().map_or(false, |v| v == "true")
        || Argument.Command.iter().any(|arg| arg.contains("--debug"))
    {
        NamePartsForProductName.push("Debug".to_string());

        NamePartsForId.push("debug".to_string());
    }

    // Generate final product name
    let ProductNamePrefix = NamePartsForProductName.join(NameDelimiter);

    let FinalName = if !ProductNamePrefix.is_empty() {
        format!("{}{}{}", ProductNamePrefix, NameDelimiter, Argument.Name)
    } else {
        Argument.Name.clone()
    };

    info!(target: "Build", "Final generated product name: '{}'", FinalName);

    // Generate final bundle identifier
    NamePartsForId.extend(WordsFromPascal(&Argument.Name));

    let IdSuffix = NamePartsForId
        .into_iter()
        .filter(|s| !s.is_empty())
        .collect::<Vec<String>>()
        .join(IdDelimiter);

    let FinalId = format!("{}{}{}", Argument.Prefix, IdDelimiter, IdSuffix);

    info!(target: "Build", "Generated bundle identifier: '{}'", FinalId);

    // Update Cargo.toml if product name changed
    if FinalName != Argument.Name {
        TomlEdit(&CargoPath, &Argument.Name, &FinalName)?;
    }

    // Get version from Cargo.toml
    let AppVersion = toml::from_str::<Manifest>(&fs::read_to_string(&CargoPath)?)?.get_version().to_string();

    // Update Tauri configuration and optionally bundle Node.js sidecar
    JsonEdit(
        &ConfigPath,
        &FinalName,
        &FinalId,
        &AppVersion,
        (if let Some(version) = &Argument.NodeVersion {
            info!(target: "Build", "Selected Node.js version: {}", version);

            let Triple = GetTauriTargetTriple();

            // Path to the pre-downloaded Node executable
            let Executable = if cfg!(target_os = "windows") {
                PathBuf::from(format!("./Element/SideCar/{}/NODE/{}/node.exe", Triple, version))
            } else {
                PathBuf::from(format!("./Element/SideCar/{}/NODE/{}/bin/node", Triple, version))
            };

            // Define a consistent, temporary directory for the staged binary
            let DirectorySideCarTemporary = ProjectDir.join("Binary");

            fs::create_dir_all(&DirectorySideCarTemporary)?;

            // Define the consistent name for the binary that Tauri will bundle
            let PathExecutableDestination = if cfg!(target_os = "windows") {
                DirectorySideCarTemporary.join(format!("node-{}.exe", Triple))
            } else {
                DirectorySideCarTemporary.join(format!("node-{}", Triple))
            };

            info!(
                target: "Build",
                "Staging sidecar from {} to {}",
                Executable.display(),
                PathExecutableDestination.display()
            );

            // Perform the copy
            fs::copy(&Executable, &PathExecutableDestination)?;

            // On non-windows, make sure the copied binary is executable
            #[cfg(not(target_os = "windows"))]
            {
                use std::os::unix::fs::PermissionsExt;

                let mut Permission = fs::metadata(&PathExecutableDestination)?.permissions();

                // rwxr-xr-x
                Permission.set_mode(0o755);

                fs::set_permissions(&PathExecutableDestination, Permission)?;
            }

            Some("Binary/node".to_string())
        } else {
            info!(target: "Build", "No Node.js flavour selected for bundling.");

            None
        })
        .as_deref(),
    )?;

    // Execute the build command
    if Argument.Command.is_empty() {
        return Err(BuildError::NoCommand);
    }

    let mut ShellCommand = if cfg!(target_os = "windows") {
        let mut Command = ProcessCommand::new("cmd");

        Command.arg("/C").args(&Argument.Command);

        Command
    } else {
        let mut Command = ProcessCommand::new(&Argument.Command[0]);

        Command.args(&Argument.Command[1..]);

        Command
    };

    info!(target: "Build::Exec", "Executing final build command: {:?}", ShellCommand);

    let Status = ShellCommand
        .current_dir(env::current_dir()?)
        .stdout(Stdio::inherit())
        .stderr(Stdio::inherit())
        .status()?;

    // Handle build failure
    if !Status.success() {
        let temp_sidecar_dir = ProjectDir.join("bin");

        if temp_sidecar_dir.exists() {
            let _ = fs::remove_dir_all(&temp_sidecar_dir);
        }

        return Err(BuildError::Shell(Status));
    }

    // Final cleanup of the temporary sidecar directory after a successful build
    let DirectorySideCarTemporary = ProjectDir.join("bin");

    if DirectorySideCarTemporary.exists() {
        fs::remove_dir_all(&DirectorySideCarTemporary)?;

        info!(target: "Build", "Cleaned up temporary sidecar directory.");
    }

    info!(target: "Build", "Build orchestration completed successfully.");

    Ok(())
}