rust_zw3d_build/

lib.rs

use dirs::home_dir;
use serde::Deserialize;
use std::collections::HashSet;
use std::env;
use std::fmt;
use std::fs;
use std::path::{Path, PathBuf};
use std::process::Command;
use thiserror::Error;

/// SDK 配置解析错误
#[derive(Debug, Error)]
pub enum ConfigError {
    #[error("未找到 zw3d.toml，已检查: {0}")]
    NotFound(String),
    #[error("读取配置失败 {path}")]
    Io {
        path: PathBuf,
        #[source]
        source: std::io::Error,
    },
    #[error("解析配置失败 {path}")]
    Parse {
        path: PathBuf,
        #[source]
        source: toml::de::Error,
    },
    #[error("配置无效: {0}")]
    Invalid(String),
    #[error("环境变量未设置: {0}")]
    MissingEnv(String),
}

/// 解析后的 SDK 配置
#[derive(Debug, Clone)]
pub struct SdkConfig {
    pub lib_dir: PathBuf,
    pub include_dir: PathBuf,
    pub version: String,
    pub config_path: Option<PathBuf>,
}

impl fmt::Display for SdkConfig {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(
            f,
            "version={}, lib_dir={}, include_dir={}",
            self.version,
            self.lib_dir.display(),
            self.include_dir.display()
        )
    }
}

#[derive(Debug, Deserialize)]
struct RawConfig {
    zw3d: Zw3dSection,
}

#[derive(Debug, Deserialize)]
struct Zw3dSection {
    path: String,
    #[serde(default)]
    include: Option<String>,
    #[serde(default)]
    version: Option<String>,
}

/// 解析并校验 SDK 配置；失败时返回详细错误
pub fn resolve_sdk() -> Result<SdkConfig, ConfigError> {
    match find_config_path() {
        Ok(path) => resolve_from_path(&path),
        Err(ConfigError::NotFound(searched)) => match resolve_from_env() {
            Ok(cfg) => Ok(cfg),
            Err(ConfigError::MissingEnv(var)) => Err(ConfigError::NotFound(format!(
                "{}；未设置环境变量 {}",
                searched, var
            ))),
            Err(other) => Err(other),
        },
        Err(err) => Err(err),
    }
}

/// 解析配置并在失败时 panic，适用于 build.rs
pub fn ensure_sdk() -> SdkConfig {
    match resolve_sdk() {
        Ok(cfg) => cfg,
        Err(err) => panic!("无法解析 ZW3D SDK 配置: {}", err),
    }
}

fn find_config_path() -> Result<PathBuf, ConfigError> {
    let mut searched = Vec::new();
    let mut seen = HashSet::new();

    if let Ok(custom) = env::var("ZW3D_TOML") {
        let cwd = env::current_dir().unwrap_or_else(|_| PathBuf::from("."));
        let path = expand_path(PathBuf::from(custom), &cwd);
        if path.is_file() {
            return Ok(path);
        }
        searched.push(path.clone());
        seen.insert(path);
    }

    let start_dir = env::var("CARGO_MANIFEST_DIR")
        .map(PathBuf::from)
        .ok()
        .or_else(|| env::current_dir().ok())
        .unwrap_or_else(|| PathBuf::from("."));

    let mut current = start_dir.as_path();
    loop {
        let candidate = current.join("zw3d.toml");
        if candidate.is_file() {
            return Ok(candidate);
        }
        if seen.insert(candidate.clone()) {
            searched.push(candidate);
        }
        if let Some(parent) = current.parent() {
            current = parent;
        } else {
            break;
        }
    }

    if let Ok(out_dir) = env::var("OUT_DIR") {
        let mut current = PathBuf::from(out_dir);
        while let Some(parent) = current.parent() {
            current = parent.to_path_buf();
            let candidate = current.join("zw3d.toml");
            if candidate.is_file() {
                return Ok(candidate);
            }
            if seen.insert(candidate.clone()) {
                searched.push(candidate);
            }
        }
    }

    let joined = if searched.is_empty() {
        format!(
            "{}",
            start_dir
                .ancestors()
                .map(|p| p.join("zw3d.toml").display().to_string())
                .collect::<Vec<_>>()
                .join(", ")
        )
    } else {
        searched
            .iter()
            .map(|p| p.display().to_string())
            .collect::<Vec<_>>()
            .join(", ")
    };

    Err(ConfigError::NotFound(joined))
}

fn resolve_from_path(config_path: &Path) -> Result<SdkConfig, ConfigError> {
    let contents = fs::read_to_string(config_path).map_err(|source| ConfigError::Io {
        path: config_path.to_path_buf(),
        source,
    })?;

    let raw: RawConfig = toml::from_str(&contents).map_err(|source| ConfigError::Parse {
        path: config_path.to_path_buf(),
        source,
    })?;

    let base_dir = config_path
        .parent()
        .map(Path::to_path_buf)
        .unwrap_or_else(|| PathBuf::from("."));

    build_sdk_config(raw, &base_dir, Some(config_path.to_path_buf()))
}

fn resolve_from_env() -> Result<SdkConfig, ConfigError> {
    let dir = env::var("ZW3D_DIR").map_err(|_| ConfigError::MissingEnv("ZW3D_DIR".into()))?;
    let lib_dir = PathBuf::from(dir);
    let include_dir = env::var("ZW3D_INCLUDE").ok().map(PathBuf::from);
    let version = env::var("ZW3D_VERSION").unwrap_or_else(|_| "26".into());

    validate_and_build_config(lib_dir, include_dir, version, None)
}

fn build_sdk_config(
    raw: RawConfig,
    base_dir: &Path,
    config_path: Option<PathBuf>,
) -> Result<SdkConfig, ConfigError> {
    let path_str = expand_env_vars(&raw.zw3d.path)?;
    let lib_dir = expand_path(PathBuf::from(path_str), base_dir);

    let include_dir = if let Some(include_raw) = raw.zw3d.include {
        let include_str = expand_env_vars(&include_raw)?;
        Some(expand_path(PathBuf::from(include_str), base_dir))
    } else {
        None
    };

    let version_raw = raw.zw3d.version.unwrap_or_else(|| "26".into());
    let version = expand_env_vars(&version_raw)?;

    validate_and_build_config(lib_dir, include_dir, version, config_path)
}

/// 验证并构建 SDK 配置
fn validate_and_build_config(
    lib_dir: PathBuf,
    include_dir: Option<PathBuf>,
    version: String,
    config_path: Option<PathBuf>,
) -> Result<SdkConfig, ConfigError> {
    // 验证 ZW3D.lib 存在
    let lib_file = lib_dir.join("ZW3D.lib");
    if !lib_file.exists() {
        return Err(ConfigError::Invalid(format!(
            "在 `{}` 下未找到 ZW3D.lib",
            lib_dir.display()
        )));
    }

    // 确定 include 目录
    let include_dir = if let Some(dir) = include_dir {
        if !dir.exists() {
            return Err(ConfigError::Invalid(format!(
                "头文件目录不存在: {}",
                dir.display()
            )));
        }
        dir
    } else {
        // 默认使用 ${lib_dir}/api/inc
        let candidate = lib_dir.join("api").join("inc");
        if !candidate.exists() {
            return Err(ConfigError::Invalid(format!(
                "未设置 include 路径，且 `{}` 下找不到 api/inc",
                lib_dir.display()
            )));
        }
        candidate
    };

    Ok(SdkConfig {
        lib_dir,
        include_dir,
        version,
        config_path,
    })
}

fn expand_env_vars(value: &str) -> Result<String, ConfigError> {
    let mut result = String::new();
    let mut chars = value.chars().peekable();

    while let Some(ch) = chars.next() {
        if ch == '$' && matches!(chars.peek(), Some('{')) {
            chars.next(); // consume '{'
            let mut key = String::new();
            while let Some(&c) = chars.peek() {
                chars.next();
                if c == '}' {
                    break;
                }
                key.push(c);
            }

            if key.is_empty() {
                return Err(ConfigError::Invalid(format!(
                    "环境变量占位符格式无效: {}",
                    value
                )));
            }

            let env_val = env::var(&key).map_err(|_| ConfigError::MissingEnv(key.clone()))?;
            result.push_str(&env_val);
        } else {
            result.push(ch);
        }
    }

    Ok(result)
}

/// 检查是否存在 ui/*.ui 文件，如果存在则调用 zrc.exe 工具编译它们
/// 假设 zrc.exe 在 SDK 工具目录下
pub fn build_ui_resources(sdk_config: &SdkConfig) -> Result<(), ConfigError> {
    let manifest_dir = env::var("CARGO_MANIFEST_DIR")
        .map(PathBuf::from)
        .ok()
        .or_else(|| env::current_dir().ok())
        .unwrap_or_else(|| PathBuf::from("."));
    
    let ui_dir = manifest_dir.join("ui");
    
    // 检查是否存在 .ui 文件
    if let Ok(entries) = fs::read_dir(&ui_dir) {
        let ui_files: Vec<_> = entries
            .filter_map(|entry| entry.ok())
            .filter(|entry| {
                entry.path().is_file() && 
                entry.path().extension().map_or(false, |ext| ext == "ui")
            })
            .collect();
        
        if !ui_files.is_empty() {
            // 获取目标目录（target/debug 或 target/release）
            let target_dir: PathBuf = env::var("CARGO_TARGET_DIR")
                .map(PathBuf::from)
                .unwrap_or_else(|_| manifest_dir.join("target"));
            
            // 获取构建配置（debug 或 release）
            let profile = env::var("PROFILE")
                .unwrap_or_else(|_| "debug".to_string());
            
            // 获取目标名称（假设是 crate 名称）
            let target_name = env::var("CARGO_PKG_NAME")
                .map_err(|_| ConfigError::Invalid("CARGO_PKG_NAME not set".into()))?;
            
            // 构建输出目录
            let out_dir = target_dir.join(profile);
            
            // 构建 zrc.exe 路径
            let zrc_path = sdk_config.lib_dir
                .parent()
                .ok_or_else(|| ConfigError::Invalid(format!("无法获取 SDK 根目录: {}", sdk_config.lib_dir.display())))?
                .join("tools")
                .join("zrc")
                .join("zrc.exe");
            
            if !zrc_path.exists() {
                return Err(ConfigError::Invalid(format!("zrc.exe 不存在: {}", zrc_path.display())));
            }
            
            // 构建输出文件路径
            let output_file = out_dir.join(format!("{}.zrc", target_name));
            
            // 调用 zrc.exe 命令
            let status = Command::new(zrc_path)
                .arg("ui/")
                .arg("-o")
                .arg(&output_file)
                .current_dir(&manifest_dir)
                .status()
                .map_err(|e| ConfigError::Invalid(format!("调用 zrc.exe 失败: {}", e)))?;
            
            if !status.success() {
                return Err(ConfigError::Invalid(format!("zrc.exe 执行失败，退出代码: {:?}", status.code())));
            }
            
            // 告诉 cargo 当 ui 文件变化时重新构建
            for ui_file in ui_files {
                println!("cargo:rerun-if-changed={}", ui_file.path().display());
            }
            
            // 告诉 cargo 输出文件位置
            println!("cargo:rustc-env=ZW3D_UI_RESOURCE={}", output_file.display());
        }
    }
    
    Ok(())
}

fn expand_path(path: PathBuf, base: &Path) -> PathBuf {
    if let Some(str_path) = path.to_str() {
        if let Some(stripped) = str_path.strip_prefix('~') {
            if let Some(home) = home_dir() {
                let rest = stripped.strip_prefix(['/', '\\']).unwrap_or(stripped);
                return home.join(rest);
            }
        }
    }

    if path.is_absolute() {
        path
    } else {
        base.join(path)
    }
}


#[cfg(test)]
mod tests {
    use super::*;
    use serial_test::serial;
    use std::io::Write;

    #[test]
    #[serial]
    fn parse_valid_config_with_env_expansion() {
        // 清理所有可能的环境变量污染
        unsafe {
            env::remove_var("ZW3D_TOML");
            env::remove_var("ZW3D_DIR");
            env::remove_var("ZW3D_INCLUDE");
            env::remove_var("ZW3D_VERSION");
        }

        let dir = tempfile::tempdir().unwrap();
        let lib_dir = dir.path().join("lib");
        let include_dir = dir.path().join("include");
        fs::create_dir_all(&lib_dir).unwrap();
        fs::create_dir_all(&include_dir).unwrap();
        fs::write(lib_dir.join("ZW3D.lib"), b"").unwrap();

        let config_path = dir.path().join("zw3d.toml");
        let mut file = fs::File::create(&config_path).unwrap();

        // 环境变量中直接设置路径，不需要转义
        unsafe {
            env::set_var("ZW3D_DIR", &lib_dir);
            env::set_var("ZW3D_INCLUDE", &include_dir);
            env::set_var("ZW3D_VERSION", "26");
        }

        write!(
            file,
            "[zw3d]\npath = \"${{ZW3D_DIR}}\"\ninclude = \"${{ZW3D_INCLUDE}}\"\nversion = \"${{ZW3D_VERSION}}\"\n",
        )
        .unwrap();

        unsafe {
            env::set_var("ZW3D_TOML", config_path.to_string_lossy().to_string());
        }
        let resolved = resolve_sdk().unwrap();

        assert_eq!(resolved.lib_dir, lib_dir);
        assert_eq!(resolved.include_dir, include_dir);
        assert_eq!(resolved.version, "26");
        assert_eq!(resolved.config_path.as_ref().unwrap(), &config_path);

        unsafe {
            env::remove_var("ZW3D_TOML");
            env::remove_var("ZW3D_DIR");
            env::remove_var("ZW3D_INCLUDE");
            env::remove_var("ZW3D_VERSION");
        }
    }

    #[test]
    #[serial]
    fn resolve_from_environment_only() {
        // 清理所有可能的环境变量污染
        unsafe {
            env::remove_var("ZW3D_TOML");
            env::remove_var("ZW3D_DIR");
            env::remove_var("ZW3D_INCLUDE");
            env::remove_var("ZW3D_VERSION");
        }

        let dir = tempfile::tempdir().unwrap();
        let lib_dir = dir.path().join("lib");
        let include_dir = lib_dir.join("api").join("inc");
        fs::create_dir_all(&lib_dir).unwrap();
        fs::create_dir_all(&include_dir).unwrap();
        fs::write(lib_dir.join("ZW3D.lib"), b"").unwrap();

        unsafe {
            // ZW3D_DIR 直接指向包含 ZW3D.lib 的目录
            env::set_var("ZW3D_DIR", &lib_dir);
            env::set_var("ZW3D_VERSION", "25");
        }

        let cfg = resolve_from_env().unwrap();
        assert_eq!(cfg.lib_dir, lib_dir);
        assert_eq!(cfg.include_dir, include_dir);
        assert_eq!(cfg.version, "25");
        assert!(cfg.config_path.is_none());

        unsafe {
            env::remove_var("ZW3D_DIR");
            env::remove_var("ZW3D_VERSION");
        }
    }
}