Maintain/Build/Rhai/

ScriptRunner.rs

//=============================================================================//
// Module: ScriptRunner - Executes Rhai scripts for dynamic configuration
//=============================================================================//

use std::{collections::HashMap, path::Path};

use rhai::{AST, Dynamic, Engine, Scope};

//=============================================================================
// Result Types
//=============================================================================

#[derive(Debug, Clone)]
pub struct ScriptResult {
	/// Environment variables generated by the script
	pub env_vars:HashMap<String, String>,
	/// Whether the script executed successfully
	pub success:bool,
	/// Error message if execution failed
	pub error:Option<String>,
	/// Whether to continue with pre-build steps
	pub pre_build_continue:bool,
	/// Output from post-build steps
	pub post_build_output:Option<String>,
	/// Feature flags generated by the script
	pub features:HashMap<String, bool>,
	/// Workbench type recommended by the script
	pub workbench:Option<String>,
}

#[derive(Debug, Clone)]
pub struct ScriptContext {
	/// Name of the profile being executed
	pub profile_name:String,
	/// Current working directory
	pub cwd:String,
	/// Manifest directory
	pub manifest_dir:String,
	/// Target triple for cross-compilation
	pub target_triple:Option<String>,
	/// Workbench type for this profile
	pub workbench_type:Option<String>,
	/// Feature flags for this profile
	pub features:HashMap<String, bool>,
}

//=============================================================================
// Public API
//=============================================================================

/// Executes a profile's Rhai script and returns the results.
///
/// # Arguments
///
/// * `engine` - The Rhai engine instance
/// * `script_path` - Path to the Rhai script
/// * `context` - Script execution context
///
/// # Returns
///
/// Result containing the script execution results
pub fn ExecuteProfileScript(engine:&Engine, script_path:&str, context:&ScriptContext) -> Result<ScriptResult, String> {
	let Ast = LoadScript(engine, script_path)?;
	let mut Scope = CreateScope(context);

	// Execute the script
	let ExecutionResult = engine.run_ast_with_scope(&mut Scope, &Ast);

	let mut Result = ScriptResult {
		env_vars:HashMap::new(),
		success:ExecutionResult.is_ok(),
		error:None,
		pre_build_continue:true,
		post_build_output:None,
		features:HashMap::new(),
		workbench:None,
	};

	if let Err(Error) = ExecutionResult {
		Result.error = Some(Error.to_string());
		Result.pre_build_continue = false;
		return Ok(Result);
	}

	// Extract environment variables from script result
	if let Ok(EnvMap) = engine.call_fn(&mut Scope, &Ast, "get_env_vars", ()) {
		Result.env_vars = ExtractEnvMap(EnvMap);
	}

	// Extract feature flags if the function exists
	if let Ok(FeatureMap) = engine.call_fn(&mut Scope, &Ast, "get_features", ()) {
		Result.features = ExtractFeatureMap(FeatureMap);
	}

	// Extract workbench type if the function exists
	if let Ok(Workbench) = engine.call_fn::<String>(&mut Scope, &Ast, "get_workbench", ()) {
		Result.workbench = Some(Workbench);
	}

	// Check if pre-build should continue
	if let Ok(ContinueResult) = engine.call_fn::<bool>(&mut Scope, &Ast, "pre_build_continue", ()) {
		Result.pre_build_continue = ContinueResult;
	}

	// Get post-build output if available
	if let Ok(Output) = engine.call_fn::<String>(&mut Scope, &Ast, "post_build_output", ()) {
		Result.post_build_output = Some(Output);
	}

	Ok(Result)
}

/// Loads and compiles a Rhai script.
///
/// # Arguments
///
/// * `engine` - The Rhai engine instance
/// * `script_path` - Path to the script file
///
/// # Returns
///
/// Result containing the compiled AST
pub fn LoadScript(engine:&Engine, script_path:&str) -> Result<AST, String> {
	if !Path::new(script_path).exists() {
		return Err(format!("Script file not found: {}", script_path));
	}

	let Content = std::fs::read_to_string(script_path).map_err(|Error| format!("Failed to read script: {}", Error))?;

	let Ast = engine
		.compile(&Content)
		.map_err(|Error| format!("Failed to compile script: {}", Error))?;

	Ok(Ast)
}

/// Creates a Rhai engine configured for build scripts.
///
/// # Returns
///
/// Configured Rhai engine instance
pub fn CreateEngine() -> Engine {
	let mut Engine = Engine::new();

	// Register custom functions for build scripts
	Engine.register_fn("env", |name:&str| -> String { std::env::var(name).unwrap_or_default() });

	Engine.register_fn("env_or", |name:&str, default:&str| -> String {
		std::env::var(name).unwrap_or_else(|_| default.to_string())
	});

	Engine.register_fn("set_env", |name:&str, value:&str| {
		// Safety: set_var is now unsafe in recent Rust versions
		// In a build context, setting environment variables during script execution
		// is acceptable as it doesn't violate memory safety - it just modifies
		// the process environment map.
		unsafe {
			std::env::set_var(name, value);
		}
	});

	Engine.register_fn("log", |message:&str| {
		println!("[Rhai] {}", message);
	});

	Engine.register_fn("log_error", |message:&str| {
		eprintln!("[Rhai ERROR] {}", message);
	});

	Engine.register_fn("log_warn", |message:&str| {
		eprintln!("[Rhai WARN] {}", message);
	});

	// Path manipulation functions
	Engine.register_fn("path_join", |base:&str, suffix:&str| -> String {
		Path::new(base).join(suffix).to_string_lossy().to_string()
	});

	Engine.register_fn("path_exists", |path:&str| -> bool { Path::new(path).exists() });

	// String utilities
	Engine.register_fn("to_uppercase", |s:&str| -> String { s.to_uppercase() });

	Engine.register_fn("to_lowercase", |s:&str| -> String { s.to_lowercase() });

	Engine
}

//=============================================================================
// Helper Functions
//=============================================================================

/// Creates a Rhai scope with the script context.
fn CreateScope(context:&ScriptContext) -> Scope<'_> {
	let mut Scope = Scope::new();

	Scope.push("profile_name", context.profile_name.clone());
	Scope.push("cwd", context.cwd.clone());
	Scope.push("manifest_dir", context.manifest_dir.clone());
	Scope.push("target_triple", context.target_triple.clone().unwrap_or_default());
	Scope.push("workbench_type", context.workbench_type.clone().unwrap_or_default());

	// Add features as a map
	let mut FeaturesMap = rhai::Map::new();
	for (Key, Value) in &context.features {
		FeaturesMap.insert(Key.into(), (*Value).into());
	}
	Scope.push("features", FeaturesMap);

	Scope
}

/// Extracts environment variables from a Rhai dynamic value.
fn ExtractEnvMap(Dynamic:Dynamic) -> HashMap<String, String> {
	let mut EnvMap = HashMap::new();

	if let Some(Map) = Dynamic.try_cast::<rhai::Map>() {
		for (Key, Value) in Map {
			if Value.is_string() {
				EnvMap.insert(Key.to_string(), Value.to_string());
			} else if Value.is_int() {
				EnvMap.insert(Key.to_string(), Value.as_int().unwrap_or(0).to_string());
			} else if Value.is_bool() {
				EnvMap.insert(Key.to_string(), Value.as_bool().unwrap_or(false).to_string());
			} else {
				EnvMap.insert(Key.to_string(), Value.to_string());
			}
		}
	}

	EnvMap
}

/// Extracts feature flags from a Rhai dynamic value.
fn ExtractFeatureMap(Dynamic:Dynamic) -> HashMap<String, bool> {
	let mut FeatureMap = HashMap::new();

	if let Some(Map) = Dynamic.try_cast::<rhai::Map>() {
		for (Key, Value) in Map {
			if Value.is_bool() {
				FeatureMap.insert(Key.to_string(), Value.as_bool().unwrap_or(false));
			}
		}
	}

	FeatureMap
}

//=============================================================================
// Tests
//=============================================================================

#[cfg(test)]
mod tests {
	use super::*;

	#[test]
	fn test_create_engine() {
		let Engine = CreateEngine();
		// Verify engine is created successfully
		assert!(Engine.compile("let x = 1;").is_ok());
	}

	#[test]
	fn test_extract_env_map() {
		let mut map = rhai::Map::new();
		map.insert("KEY1".into(), "value1".into());
		map.insert("KEY2".into(), 42.into());
		map.insert("KEY3".into(), true.into());

		let Dynamic = Dynamic::from(map);
		let Env = ExtractEnvMap(Dynamic);

		assert_eq!(Env.get("KEY1"), Some(&"value1".to_string()));
		assert_eq!(Env.get("KEY2"), Some(&"42".to_string()));
		assert_eq!(Env.get("KEY3"), Some(&"true".to_string()));
	}

	#[test]
	fn test_extract_feature_map() {
		let mut map = rhai::Map::new();
		map.insert("feature1".into(), true.into());
		map.insert("feature2".into(), false.into());

		let Dynamic = Dynamic::from(map);
		let Features = ExtractFeatureMap(Dynamic);

		assert_eq!(Features.get("feature1"), Some(&true));
		assert_eq!(Features.get("feature2"), Some(&false));
	}
}