...

src/rhai/process.rs

@@ -0,0 +1,138 @@
+//! Rhai wrappers for Process module functions
+//!
+//! This module provides Rhai wrappers for the functions in the Process module.
+
+use rhai::{Engine, EvalAltResult, Array, Dynamic};
+use crate::process::{self, CommandResult, ProcessInfo, RunError, ProcessError};
+
+/// Register Process module functions with the Rhai engine
+///
+/// # Arguments
+///
+/// * `engine` - The Rhai engine to register the functions with
+///
+/// # Returns
+///
+/// * `Result<(), Box<EvalAltResult>>` - Ok if registration was successful, Err otherwise
+pub fn register_process_module(engine: &mut Engine) -> Result<(), Box<EvalAltResult>> {
+    // Register types
+    register_process_types(engine)?;
+    
+    // Register run functions
+    engine.register_fn("run_command", run_command);
+    engine.register_fn("run_silent", run_silent);
+    
+    // Register process management functions
+    engine.register_fn("which", which);
+    engine.register_fn("kill", kill);
+    engine.register_fn("process_list", process_list);
+    engine.register_fn("process_get", process_get);
+    
+    Ok(())
+}
+
+/// Register Process module types with the Rhai engine
+fn register_process_types(engine: &mut Engine) -> Result<(), Box<EvalAltResult>> {
+    // Register CommandResult type and methods
+    engine.register_type_with_name::<CommandResult>("CommandResult");
+    
+    // Register getters for CommandResult properties
+    engine.register_get("stdout", |r: &mut CommandResult| r.stdout.clone());
+    engine.register_get("stderr", |r: &mut CommandResult| r.stderr.clone());
+    engine.register_get("success", |r: &mut CommandResult| r.success);
+    engine.register_get("code", |r: &mut CommandResult| r.code);
+    
+    // Register ProcessInfo type and methods
+    engine.register_type_with_name::<ProcessInfo>("ProcessInfo");
+    
+    // Register getters for ProcessInfo properties
+    engine.register_get("pid", |p: &mut ProcessInfo| p.pid);
+    engine.register_get("name", |p: &mut ProcessInfo| p.name.clone());
+    engine.register_get("memory", |p: &mut ProcessInfo| p.memory);
+    engine.register_get("cpu", |p: &mut ProcessInfo| p.cpu);
+    
+    // Register error conversion functions
+    engine.register_fn("to_string", |err: &str| err.to_string());
+    
+    Ok(())
+}
+
+// Helper functions for error conversion
+fn run_error_to_rhai_error<T>(result: Result<T, RunError>) -> Result<T, Box<EvalAltResult>> {
+    result.map_err(|e| {
+        Box::new(EvalAltResult::ErrorRuntime(
+            format!("Run error: {}", e).into(),
+            rhai::Position::NONE
+        ))
+    })
+}
+
+fn process_error_to_rhai_error<T>(result: Result<T, ProcessError>) -> Result<T, Box<EvalAltResult>> {
+    result.map_err(|e| {
+        Box::new(EvalAltResult::ErrorRuntime(
+            format!("Process error: {}", e).into(),
+            rhai::Position::NONE
+        ))
+    })
+}
+
+//
+// Run Function Wrappers
+//
+
+/// Wrapper for process::run_command
+///
+/// Run a command or multiline script with arguments.
+pub fn run_command(command: &str) -> Result<CommandResult, Box<EvalAltResult>> {
+    run_error_to_rhai_error(process::run_command(command))
+}
+
+/// Wrapper for process::run_silent
+///
+/// Run a command or multiline script with arguments silently.
+pub fn run_silent(command: &str) -> Result<CommandResult, Box<EvalAltResult>> {
+    run_error_to_rhai_error(process::run_silent(command))
+}
+
+//
+// Process Management Function Wrappers
+//
+
+/// Wrapper for process::which
+///
+/// Check if a command exists in PATH.
+pub fn which(cmd: &str) -> Dynamic {
+    match process::which(cmd) {
+        Some(path) => path.into(),
+        None => Dynamic::UNIT
+    }
+}
+
+/// Wrapper for process::kill
+///
+/// Kill processes matching a pattern.
+pub fn kill(pattern: &str) -> Result<String, Box<EvalAltResult>> {
+    process_error_to_rhai_error(process::kill(pattern))
+}
+
+/// Wrapper for process::process_list
+///
+/// List processes matching a pattern (or all if pattern is empty).
+pub fn process_list(pattern: &str) -> Result<Array, Box<EvalAltResult>> {
+    let processes = process_error_to_rhai_error(process::process_list(pattern))?;
+    
+    // Convert Vec<ProcessInfo> to Rhai Array
+    let mut array = Array::new();
+    for process in processes {
+        array.push(Dynamic::from(process));
+    }
+    
+    Ok(array)
+}
+
+/// Wrapper for process::process_get
+///
+/// Get a single process matching the pattern (error if 0 or more than 1 match).
+pub fn process_get(pattern: &str) -> Result<ProcessInfo, Box<EvalAltResult>> {
+    process_error_to_rhai_error(process::process_get(pattern))
+}