sal-rhai 0.1.0

SAL Rhai - Rhai scripting integration for the System Abstraction Layer
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269

//! Tests for sal-rhai core module functionality
//!
//! These tests verify the core Rhai integration functions work correctly.

use rhai::Engine;
use sal_rhai::{error::ToRhaiError, register};
use std::fs;
use tempfile::TempDir;

/// Test the ToRhaiError trait implementation
#[test]
fn test_to_rhai_error_trait() {
    // Test with a standard Result<T, E> where E implements std::error::Error
    let io_error = std::io::Error::new(std::io::ErrorKind::NotFound, "File not found");
    let result: Result<String, std::io::Error> = Err(io_error);

    let rhai_result = result.to_rhai_error();
    assert!(rhai_result.is_err(), "Should convert to Rhai error");

    let error = rhai_result.unwrap_err();
    let error_str = error.to_string();
    assert!(
        error_str.contains("File not found"),
        "Error message should be preserved: {}",
        error_str
    );
}

/// Test the ToRhaiError trait with successful result
#[test]
fn test_to_rhai_error_success() {
    let result: Result<String, std::io::Error> = Ok("success".to_string());
    let rhai_result = result.to_rhai_error();
    assert!(rhai_result.is_ok(), "Should preserve successful result");
    assert_eq!(rhai_result.unwrap(), "success", "Value should be preserved");
}

/// Test core module registration
#[test]
fn test_core_module_registration() {
    let mut engine = Engine::new();

    // Register only the core module
    let result = sal_rhai::core::register_core_module(&mut engine);
    assert!(
        result.is_ok(),
        "Core module registration should succeed: {:?}",
        result
    );

    // Verify exec function is registered
    let script = r#"exec("42")"#;
    let result = engine.eval::<i64>(script);
    assert!(
        result.is_ok(),
        "Exec function should be available: {:?}",
        result
    );
    assert_eq!(
        result.unwrap(),
        42,
        "Exec should return the evaluated result"
    );
}

/// Test exec function with direct code execution
#[test]
fn test_exec_direct_code() {
    let mut engine = Engine::new();
    register(&mut engine).expect("Failed to register SAL modules");

    // Test simple arithmetic
    let result = engine.eval::<i64>(r#"exec("10 + 20")"#);
    assert!(result.is_ok(), "Direct code execution failed: {:?}", result);
    assert_eq!(result.unwrap(), 30, "Should return 30");

    // Test string operations
    let result = engine.eval::<String>(r#"exec(`"Hello" + " " + "World"`)"#);
    assert!(result.is_ok(), "String operation failed: {:?}", result);
    assert_eq!(result.unwrap(), "Hello World", "Should concatenate strings");

    // Test variable assignment and usage
    let result = engine.eval::<i64>(r#"exec("let x = 5; let y = 10; x * y")"#);
    assert!(result.is_ok(), "Variable operations failed: {:?}", result);
    assert_eq!(result.unwrap(), 50, "Should return 5 * 10 = 50");
}

/// Test exec function with file execution
#[test]
fn test_exec_file_execution() {
    let mut engine = Engine::new();
    register(&mut engine).expect("Failed to register SAL modules");

    let temp_dir = TempDir::new().expect("Failed to create temp directory");
    let script_file = temp_dir.path().join("test_exec.rhai");

    // Create a test script file
    let script_content = r#"
        let numbers = [1, 2, 3, 4, 5];
        let sum = 0;
        for num in numbers {
            sum += num;
        }
        sum
    "#;

    fs::write(&script_file, script_content).expect("Failed to write script file");

    // Execute the script file
    let exec_script = format!(r#"exec("{}")"#, script_file.display());
    let result = engine.eval::<i64>(&exec_script);
    assert!(result.is_ok(), "File execution failed: {:?}", result);
    assert_eq!(result.unwrap(), 15, "Should return sum of 1+2+3+4+5 = 15");
}

/// Test exec function with non-existent file
#[test]
fn test_exec_nonexistent_file() {
    let mut engine = Engine::new();
    register(&mut engine).expect("Failed to register SAL modules");

    // Try to execute a non-existent file
    let result = engine.eval::<i64>(r#"exec(`nonexistent_file_xyz123.rhai`)"#);
    assert!(result.is_err(), "Should fail for non-existent file");

    let error = result.unwrap_err();
    let error_str = error.to_string();
    assert!(
        error_str.contains("No files found")
            || error_str.contains("File not found")
            || error_str.contains("File system error")
            || error_str.contains("Variable not found"),
        "Error should indicate file not found: {}",
        error_str
    );
}

/// Test exec function with malformed Rhai code
#[test]
fn test_exec_malformed_code() {
    let mut engine = Engine::new();
    register(&mut engine).expect("Failed to register SAL modules");

    // Test with syntax error
    let result = engine.eval::<i64>(r#"exec("let x = ; // malformed")"#);
    assert!(result.is_err(), "Should fail for malformed code");

    // Test with undefined variable
    let result = engine.eval::<i64>(r#"exec("undefined_variable")"#);
    assert!(result.is_err(), "Should fail for undefined variable");
}

/// Test exec function with complex nested operations
#[test]
fn test_exec_complex_operations() {
    let mut engine = Engine::new();
    register(&mut engine).expect("Failed to register SAL modules");

    let complex_script = r#"
        exec(`
            fn factorial(n) {
                if n <= 1 {
                    1
                } else {
                    n * factorial(n - 1)
                }
            }
            factorial(5)
        `)
    "#;

    let result = engine.eval::<i64>(complex_script);
    assert!(result.is_ok(), "Complex operation failed: {:?}", result);
    assert_eq!(result.unwrap(), 120, "Should return 5! = 120");
}

/// Test exec function with SAL functions
#[test]
fn test_exec_with_sal_functions() {
    let mut engine = Engine::new();
    register(&mut engine).expect("Failed to register SAL modules");

    // Test using SAL functions within exec
    let script = r#"exec(`exist("Cargo.toml")`)"#;
    let result = engine.eval::<bool>(script);
    assert!(result.is_ok(), "SAL function in exec failed: {:?}", result);
    assert!(result.unwrap(), "Cargo.toml should exist");
}

/// Test exec function return types
#[test]
fn test_exec_return_types() {
    let mut engine = Engine::new();
    register(&mut engine).expect("Failed to register SAL modules");

    // Test boolean return
    let result = engine.eval::<bool>(r#"exec("true")"#);
    assert!(
        result.is_ok() && result.unwrap(),
        "Should return boolean true"
    );

    // Test string return
    let result = engine.eval::<String>(r#"exec(`"test string"`)"#);
    assert!(result.is_ok(), "String return failed: {:?}", result);
    assert_eq!(
        result.unwrap(),
        "test string",
        "Should return correct string"
    );

    // Test array return
    let result = engine.eval::<rhai::Array>(r#"exec("[1, 2, 3]")"#);
    assert!(result.is_ok(), "Array return failed: {:?}", result);
    let array = result.unwrap();
    assert_eq!(array.len(), 3, "Array should have 3 elements");

    // Test unit return (no return value)
    let result = engine.eval::<()>(r#"exec("let x = 42;")"#);
    assert!(result.is_ok(), "Unit return failed: {:?}", result);
}

/// Test error propagation in exec function
#[test]
fn test_exec_error_propagation() {
    let mut engine = Engine::new();
    register(&mut engine).expect("Failed to register SAL modules");

    // Test that errors from executed code are properly propagated
    let result = engine.eval::<i64>(r#"exec("1 / 0")"#);
    assert!(result.is_err(), "Division by zero should cause error");

    // Test that runtime errors are caught
    let result = engine.eval::<i64>(r#"exec("throw 'Custom error'")"#);
    assert!(result.is_err(), "Thrown errors should be caught");
}

/// Test exec function with file containing SAL operations
#[test]
fn test_exec_file_with_sal_operations() {
    let mut engine = Engine::new();
    register(&mut engine).expect("Failed to register SAL modules");

    let temp_dir = TempDir::new().expect("Failed to create temp directory");
    let script_file = temp_dir.path().join("sal_operations.rhai");

    // Create a script that uses SAL functions
    let script_content = r#"
        // Test text processing
        let text = "    indented text    ";
        let processed = dedent(text);
        let prefixed = prefix(processed, ">> ");
        
        // Return length of processed text
        prefixed.len()
    "#;

    fs::write(&script_file, script_content).expect("Failed to write script file");

    // Execute the script file
    let exec_script = format!(r#"exec("{}")"#, script_file.display());
    let result = engine.eval::<i64>(&exec_script);
    assert!(
        result.is_ok(),
        "SAL operations in file failed: {:?}",
        result
    );
    assert!(result.unwrap() > 0, "Should return positive length");
}