Maintain/Build/Rhai/

ScriptRunner.rs

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

use rhai::{Engine, AST, Dynamic, Scope};
use std::path::Path;
use std::collections::HashMap;

//=============================================================================
// 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 execute_profile_script(
	engine: &Engine,
	script_path: &str,
	context: &ScriptContext,
) -> Result<ScriptResult, String> {
	let ast = load_script(engine, script_path)?;
	let mut scope = create_scope(context);

	// Execute the script
	let execution_result = engine.run_ast_with_scope(&mut scope, &ast);

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

	if let Err(e) = execution_result {
		result.error = Some(e.to_string());
		result.pre_build_continue = false;
		return Ok(result);
	}

	// Extract environment variables from script result
	if let Ok(env_map) = engine.call_fn(&mut scope, &ast, "get_env_vars", ()) {
		result.env_vars = extract_env_map(env_map);
	}

	// Extract feature flags if the function exists
	if let Ok(feature_map) = engine.call_fn(&mut scope, &ast, "get_features", ()) {
		result.features = extract_feature_map(feature_map);
	}

	// 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(continue_result) = engine.call_fn::<bool>(&mut scope, &ast, "pre_build_continue", ()) {
		result.pre_build_continue = continue_result;
	}

	// 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 load_script(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(|e| format!("Failed to read script: {}", e))?;

	let ast = engine.compile(&content)
		.map_err(|e| format!("Failed to compile script: {}", e))?;

	Ok(ast)
}

/// Creates a Rhai engine configured for build scripts.
///
/// # Returns
///
/// Configured Rhai engine instance
pub fn create_engine() -> 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 create_scope(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 features_map = rhai::Map::new();
	for (key, value) in &context.features {
		features_map.insert(key.into(), (*value).into());
	}
	scope.push("features", features_map);

	scope
}

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

	if let Some(map) = dynamic.try_cast::<rhai::Map>() {
		for (key, value) in map {
			if value.is_string() {
				env_map.insert(key.to_string(), value.to_string());
			} else if value.is_int() {
				env_map.insert(key.to_string(), value.as_int().unwrap_or(0).to_string());
			} else if value.is_bool() {
				env_map.insert(key.to_string(), value.as_bool().unwrap_or(false).to_string());
			} else {
				env_map.insert(key.to_string(), value.to_string());
			}
		}
	}

	env_map
}

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

	if let Some(map) = dynamic.try_cast::<rhai::Map>() {
		for (key, value) in map {
			if value.is_bool() {
				feature_map.insert(key.to_string(), value.as_bool().unwrap_or(false));
			}
		}
	}

	feature_map
}

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

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

	#[test]
	fn test_create_engine() {
		let engine = create_engine();
		// 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 = extract_env_map(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 = extract_feature_map(dynamic);

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