Merge pull request #12 from zirco-lang/copilot/update-zircon-build-process

Delegate zrc build and install to hook scripts

Author: thetayloredman

src/build.rs

@@ -1,11 +1,10 @@
-//! Build operations for compiling zrc
+//! Build operations for compiling Rust projects
 
-use std::path::Path;
-use std::process::Command;
+use std::{path::Path, process::Command};
 
-/// Build zrc using cargo
-pub fn build_zrc(source_dir: &Path) -> Result<(), Box<dyn std::error::Error>> {
-    println!("Building zrc (this may take several minutes)...");
+/// Build a Rust project using cargo
+pub fn build_rust_project(source_dir: &Path) -> Result<(), Box<dyn std::error::Error>> {
+    println!("Building (this may take several minutes)...");
 
     let status = Command::new("cargo")
         .arg("build")
@@ -15,7 +14,7 @@ pub fn build_zrc(source_dir: &Path) -> Result<(), Box<dyn std::error::Error>> {
 
     if !status.success() {
         let exit_code = status.code().unwrap_or(-1);
-        return Err(format!("Failed to build zrc (exit code: {})", exit_code).into());
+        return Err(format!("Build failed (exit code: {})", exit_code).into());
     }
 
     println!("Build complete!");

src/cmds/build_cmds.rs

@@ -1,10 +1,10 @@
 //! Commands for building zrc toolchains
 
+use std::{error::Error, process::Command};
+
 use clap::Parser;
-use std::error::Error;
 
-use crate::cli::DispatchCommand;
-use crate::{build, deps, git_utils, installer, paths};
+use crate::{cli::DispatchCommand, deps, git_utils, paths};
 
 /// Build a specific version of zrc
 #[derive(Parser)]
@@ -54,56 +54,104 @@ impl DispatchCommand for BuildCmd {
 
         println!("Building version: {}", version);
 
-        // Check if cargo is available
-        build::check_cargo()?;
-
-        // Build zrc
-        build::build_zrc(&source_dir)?;
-
         // Create toolchain directory
         let toolchain_dir = paths::toolchain_dir(&version);
-        let toolchain_bin_dir = paths::toolchain_bin_dir(&version);
-        let toolchain_include_dir = paths::toolchain_include_dir(&version);
-
-        std::fs::create_dir_all(&toolchain_bin_dir)?;
-        std::fs::create_dir_all(&toolchain_include_dir)?;
-
-        // Install binary
-        installer::install_zrc_binary(&source_dir, &toolchain_bin_dir)?;
-
-        // Install zircop binary if it exists
-        let has_zircop = installer::install_zircop_binary(&source_dir, &toolchain_bin_dir)?;
+        std::fs::create_dir_all(&toolchain_dir)?;
 
-        // Install include files
-        installer::install_include_files(&source_dir, &toolchain_include_dir)?;
+        // Execute the hook script from the zrc repo
+        // The hook handles building and installing to the toolchain directory
+        run_build_hook(&source_dir, &toolchain_dir)?;
 
         // Update current symlink
         let current_link = paths::current_toolchain_link();
         paths::create_link(&toolchain_dir, &current_link)?;
 
-        // Create/update bin links
-        let zrc_link = paths::zrc_binary_link();
-        let zrc_binary = paths::toolchain_zrc_binary(&version);
-        paths::create_link(&zrc_binary, &zrc_link)?;
-
-        // Create/update zircop bin link if it exists
-        if has_zircop {
-            let zircop_link = paths::zircop_binary_link();
-            let zircop_binary = paths::toolchain_zircop_binary(&version);
-            paths::create_link(&zircop_binary, &zircop_link)?;
-        }
-
-        // Create/update include link
-        let include_link = paths::include_dir_link();
-        paths::create_link(&toolchain_include_dir, &include_link)?;
-
         println!("\n✓ Successfully built and installed zrc {}", version);
         println!("  Toolchain location: {}", toolchain_dir.display());
-        println!("\nTo use zrc, add to your PATH:");
-        println!("  export PATH=\"{}:$PATH\"", paths::bin_dir().display());
-        println!("\nOr run:");
+        println!("\nTo use zrc, run:");
         println!("  source <(zircon env)");
 
         Ok(())
     }
 }
+
+/// Run the build hook script from the zrc repository
+#[cfg(unix)]
+fn run_build_hook(
+    source_dir: &std::path::Path,
+    toolchain_dir: &std::path::Path,
+) -> Result<(), Box<dyn Error>> {
+    let hook_script = source_dir.join("hooks").join("zircon.sh");
+    if !hook_script.exists() {
+        return Err(format!(
+            "Hook script not found at {}. This version of zrc may not support zircon hooks.",
+            hook_script.display()
+        )
+        .into());
+    }
+
+    println!("Running zrc build hook...");
+    let status = Command::new("bash")
+        .arg(&hook_script)
+        .env("ZIRCON_TOOLCHAIN_DIR", toolchain_dir)
+        .current_dir(source_dir)
+        .status()?;
+
+    if !status.success() {
+        let exit_code = status.code().unwrap_or(-1);
+        return Err(format!("Hook script failed (exit code: {})", exit_code).into());
+    }
+
+    Ok(())
+}
+
+/// Run the build hook script from the zrc repository (Windows)
+#[cfg(windows)]
+fn run_build_hook(
+    source_dir: &std::path::Path,
+    toolchain_dir: &std::path::Path,
+) -> Result<(), Box<dyn Error>> {
+    // Check for PowerShell script first, then batch file
+    let ps_hook = source_dir.join("hooks").join("zircon.ps1");
+    let bat_hook = source_dir.join("hooks").join("zircon.bat");
+
+    if ps_hook.exists() {
+        println!("Running zrc build hook (PowerShell)...");
+        // Use Bypass to run local scripts regardless of system execution policy.
+        // This is safe because the script is part of the zrc repo the user cloned.
+        let status = Command::new("powershell")
+            .args(["-ExecutionPolicy", "Bypass", "-File"])
+            .arg(&ps_hook)
+            .env("ZIRCON_TOOLCHAIN_DIR", toolchain_dir)
+            .current_dir(source_dir)
+            .status()?;
+
+        if !status.success() {
+            let exit_code = status.code().unwrap_or(-1);
+            return Err(format!("Hook script failed (exit code: {})", exit_code).into());
+        }
+    } else if bat_hook.exists() {
+        println!("Running zrc build hook (batch)...");
+        let status = Command::new("cmd")
+            .args(["/C"])
+            .arg(&bat_hook)
+            .env("ZIRCON_TOOLCHAIN_DIR", toolchain_dir)
+            .current_dir(source_dir)
+            .status()?;
+
+        if !status.success() {
+            let exit_code = status.code().unwrap_or(-1);
+            return Err(format!("Hook script failed (exit code: {})", exit_code).into());
+        }
+    } else {
+        return Err(format!(
+            "No Windows hook script found at {} or {}. \
+             This version of zrc may not support Windows builds via zircon hooks.",
+            ps_hook.display(),
+            bat_hook.display()
+        )
+        .into());
+    }
+
+    Ok(())
+}

src/cmds/env_cmds.rs

@@ -1,11 +1,10 @@
 //! Commands for environment configuration
 
+use std::{error::Error, path::Path};
+
 use clap::Parser;
-use std::error::Error;
-use std::path::Path;
 
-use crate::cli::DispatchCommand;
-use crate::paths;
+use crate::{cli::DispatchCommand, paths};
 
 /// Output shell environment configuration
 #[derive(Parser)]
@@ -18,7 +17,6 @@ pub struct EnvCmd {
 impl DispatchCommand for EnvCmd {
     fn dispatch(self) -> Result<(), Box<dyn Error>> {
         let bin_dir = paths::bin_dir();
-        let include_dir = paths::include_dir_link();
 
         // Determine shell type
         let shell_type = self
@@ -30,45 +28,55 @@ impl DispatchCommand for EnvCmd {
                 // Fish shell syntax - use double quotes and escape internal quotes
                 let bin_escaped = escape_for_fish(&bin_dir);
                 println!("set -gx PATH {} $PATH;", bin_escaped);
-                if include_dir.exists() {
-                    let include_escaped = escape_for_fish(&include_dir);
-                    println!("set -gx ZIRCO_INCLUDE_PATH {};", include_escaped);
+                // Source the toolchain's env.sh if it exists
+                let toolchain_env_sh = paths::current_toolchain_env_sh();
+                if toolchain_env_sh.exists() {
+                    let env_sh_escaped = escape_for_fish(&toolchain_env_sh);
+                    println!("source {};", env_sh_escaped);
                 }
             }
             "powershell" | "pwsh" => {
                 // PowerShell syntax - double-quote and escape internal double quotes
                 let bin_escaped = escape_for_powershell(&bin_dir);
                 println!("$env:Path = \"{};$env:Path\";", bin_escaped);
-                if include_dir.exists() {
-                    let include_escaped = escape_for_powershell(&include_dir);
-                    println!("$env:ZIRCO_INCLUDE_PATH = \"{}\";", include_escaped);
+                // Source the toolchain's env.ps1 if it exists (PowerShell uses . for sourcing)
+                let toolchain_env_ps1 = paths::current_toolchain_env_ps1();
+                if toolchain_env_ps1.exists() {
+                    let env_ps1_escaped = escape_for_powershell(&toolchain_env_ps1);
+                    println!(". \"{}\";", env_ps1_escaped);
                 }
             }
             "cmd" => {
                 // Windows CMD syntax - escape percent signs and carets
                 let bin_escaped = escape_for_cmd(&bin_dir);
                 println!("set PATH={};%PATH%", bin_escaped);
-                if include_dir.exists() {
-                    let include_escaped = escape_for_cmd(&include_dir);
-                    println!("set ZIRCO_INCLUDE_PATH={}", include_escaped);
+                // Source the toolchain's env.bat if it exists (CMD uses call)
+                let toolchain_env_bat = paths::current_toolchain_env_bat();
+                if toolchain_env_bat.exists() {
+                    let env_bat_escaped = escape_for_cmd(&toolchain_env_bat);
+                    println!("call {}", env_bat_escaped);
                 }
             }
             "zsh" | "bash" | "sh" => {
                 // Bash/Zsh syntax - use single quotes and escape internal single quotes
                 let bin_escaped = escape_for_posix_shell(&bin_dir);
                 println!("export PATH={}:$PATH;", bin_escaped);
-                if include_dir.exists() {
-                    let include_escaped = escape_for_posix_shell(&include_dir);
-                    println!("export ZIRCO_INCLUDE_PATH={};", include_escaped);
+                // Source the toolchain's env.sh if it exists
+                let toolchain_env_sh = paths::current_toolchain_env_sh();
+                if toolchain_env_sh.exists() {
+                    let env_sh_escaped = escape_for_posix_shell(&toolchain_env_sh);
+                    println!("source {};", env_sh_escaped);
                 }
             }
             _ => {
                 // Default for unknown shells - use POSIX syntax
                 let bin_escaped = escape_for_posix_shell(&bin_dir);
                 println!("export PATH={}:$PATH;", bin_escaped);
-                if include_dir.exists() {
-                    let include_escaped = escape_for_posix_shell(&include_dir);
-                    println!("export ZIRCO_INCLUDE_PATH={};", include_escaped);
+                // Source the toolchain's env.sh if it exists
+                let toolchain_env_sh = paths::current_toolchain_env_sh();
+                if toolchain_env_sh.exists() {
+                    let env_sh_escaped = escape_for_posix_shell(&toolchain_env_sh);
+                    println!("source {};", env_sh_escaped);
                 }
             }
         }
@@ -89,7 +97,8 @@ fn escape_for_posix_shell(path: &Path) -> String {
 /// Uses double quotes or falls back to proper escaping
 fn escape_for_fish(path: &Path) -> String {
     let path_str = path.display().to_string();
-    // For fish, we can use double quotes and escape internal double quotes, backslashes, and dollar signs
+    // For fish, we can use double quotes and escape internal double quotes,
+    // backslashes, and dollar signs
     let escaped = path_str
         .replace('\\', "\\\\")
         .replace('"', "\\\"")

src/cmds/self_cmds.rs

@@ -2,8 +2,7 @@
 
 mod cmd_version;
 
-use std::error::Error;
-use std::fs;
+use std::{error::Error, fs};
 
 use clap::{Parser, Subcommand};
 
@@ -57,7 +56,7 @@ fn cmd_self_update(reference: &str) -> Result<(), Box<dyn Error>> {
 
     println!("Building Zircon...");
     build::check_cargo()?;
-    build::build_zrc(&zircon_source)?; // Reuse the build function, it just runs cargo build --release
+    build::build_rust_project(&zircon_source)?;
 
     // Copy the new binary
     let binary_name = if cfg!(windows) {

src/cmds/toolchain_cmds.rs

@@ -1,10 +1,10 @@
 //! Commands for managing toolchains
 
-use clap::Parser;
 use std::error::Error;
 
-use crate::cli::DispatchCommand;
-use crate::{paths, toolchains};
+use clap::Parser;
+
+use crate::{cli::DispatchCommand, paths, toolchains};
 
 /// Switch to a different installed toolchain version
 #[derive(Parser)]
@@ -31,28 +31,6 @@ impl DispatchCommand for SwitchCmd {
         let current_link = paths::current_toolchain_link();
         paths::create_link(&toolchain_dir, &current_link)?;
 
-        // Update bin links
-        let zrc_link = paths::zrc_binary_link();
-        let zrc_binary = paths::toolchain_zrc_binary(&self.version);
-        paths::create_link(&zrc_binary, &zrc_link)?;
-
-        // Update zircop bin link if it exists in the toolchain
-        let zircop_link = paths::zircop_binary_link();
-        let zircop_binary = paths::toolchain_zircop_binary(&self.version);
-        if zircop_binary.exists() {
-            paths::create_link(&zircop_binary, &zircop_link)?;
-        } else {
-            // Remove zircop link if it exists but the new toolchain doesn't have it
-            if zircop_link.exists() || zircop_link.read_link().is_ok() {
-                std::fs::remove_file(&zircop_link).ok();
-            }
-        }
-
-        // Update include link
-        let include_link = paths::include_dir_link();
-        let toolchain_include_dir = paths::toolchain_include_dir(&self.version);
-        paths::create_link(&toolchain_include_dir, &include_link)?;
-
         println!("✓ Switched to toolchain: {}", self.version);
 
         Ok(())