Add eval_ruby_script_float, _string, _bool functions

- Refactor common Ruby script execution into eval_ruby_script()
- Add eval_ruby_script_float: returns f64 (NaN on error)
- Add eval_ruby_script_string: returns C string pointer
- Add eval_ruby_script_bool: returns 0 or 1
- Update EXPORTED_FUNCTIONS and add UTF8ToString
- Add JavaScript wrapper functions in main.js

Co-authored-by: Copilot <198982749+Copilot@users.noreply.github.com>

Author: udzura

.cargo/config.toml

@@ -3,9 +3,9 @@ rustflags = [
     "-C",
     "link-args=-o out.js",
     "-C",
-    "link-args=-s EXPORTED_FUNCTIONS=['_eval_ruby_script_int','_main']",
+    "link-args=-s EXPORTED_FUNCTIONS=['_eval_ruby_script_int','_eval_ruby_script_float','_eval_ruby_script_string','_eval_ruby_script_bool','_main']",
     "-C",
-    "link-args=-s EXPORTED_RUNTIME_METHODS=['ccall','cwrap']",
+    "link-args=-s EXPORTED_RUNTIME_METHODS=['ccall','cwrap','UTF8ToString']",
     "-C",
     "link-args=-s MODULARIZE=0",
     "-C",

Cargo.lock

@@ -7,7 +7,7 @@ edition = "2024"
 mrubyedge = { version = "1.1.8", default-features = false }
 mruby-compiler2-sys = { path = "/Users/udzura/ghq/github.com/mrubyedge/mruby-compiler2-sys", default-features = false }
 # mruby-compiler2-sys = { version = "0.3.0", default-features = false }
-# mruby-math = "0.1.0"
+mrubyedge-math = "0.1.0"
 
 [profile.dev]
 # FIXME: unccomment 

Cargo.toml

@@ -1,7 +1,7 @@
 /**
  * eval ruby script and return integer value
  * @param {string} input ruby code.
- * @return The input multiplied by 2.
+ * @return The integer result of the Ruby script.
  * @customfunction
 */
 function EVAL_RUBY_SCRIPT_INT(text) {
@@ -12,3 +12,53 @@ function EVAL_RUBY_SCRIPT_INT(text) {
         [text]
     );
 }
+
+/**
+ * eval ruby script and return float value
+ * @param {string} input ruby code.
+ * @return The float result of the Ruby script.
+ * @customfunction
+*/
+function EVAL_RUBY_SCRIPT_FLOAT(text) {
+    return Module.ccall(
+        'eval_ruby_script_float',
+        'number',
+        ['string'],
+        [text]
+    );
+}
+
+/**
+ * eval ruby script and return boolean value
+ * @param {string} input ruby code.
+ * @return The boolean result of the Ruby script.
+ * @customfunction
+*/
+function EVAL_RUBY_SCRIPT_BOOL(text) {
+    var result = Module.ccall(
+        'eval_ruby_script_bool',
+        'number',
+        ['string'],
+        [text]
+    );
+    return result !== 0;
+}
+
+/**
+ * eval ruby script and return string value
+ * @param {string} input ruby code.
+ * @return The string result of the Ruby script.
+ * @customfunction
+*/
+function EVAL_RUBY_SCRIPT_STRING(text) {
+    var ptr = Module.ccall(
+        'eval_ruby_script_string',
+        'number',
+        ['string'],
+        [text]
+    );
+    if (ptr === 0) {
+        return "";
+    }
+    return Module.UTF8ToString(ptr);
+}

combined.js

@@ -1,53 +1,117 @@
 #![allow(clippy::not_unsafe_ptr_arg_deref)]
-use std::ffi::CStr;
+use std::ffi::{CStr, CString};
 use std::os::raw::c_char;
+use std::rc::Rc;
 
 use mruby_compiler2_sys::MRubyCompiler2Context;
+use mrubyedge::yamrb::value::RObject;
 
 fn main() {}
 
+/// Execute Ruby script and return the result as Rc<RObject>
+/// Returns None if compilation or execution fails
+fn eval_ruby_script(text: &str) -> Option<Rc<RObject>> {
+    let mut context = unsafe { MRubyCompiler2Context::new() };
+
+    // Compile the Ruby script
+    let mrb = match unsafe { context.compile(text) } {
+        Ok(bytecode) => bytecode,
+        Err(e) => {
+            eprintln!("Compilation error: {}", e);
+            eprintln!("Please check your Ruby code and try again");
+            return None;
+        }
+    };
+
+    // Load and execute the bytecode
+    let mut rite = match mrubyedge::rite::load(&mrb) {
+        Ok(r) => r,
+        Err(e) => {
+            eprintln!("Failed to load bytecode: {:?}", e);
+            return None;
+        }
+    };
+
+    let mut vm = mrubyedge::yamrb::vm::VM::open(&mut rite);
+
+    // Execute the script and handle exceptions
+    match vm.run() {
+        Ok(r) => Some(r),
+        Err(e) => {
+            eprintln!("Runtime error: {:?}", e);
+            None
+        }
+    }
+}
+
+/// Convert C string pointer to Rust &str
+unsafe fn cstr_to_str<'a>(text_ptr: *const c_char) -> &'a str {
+    let c_str = CStr::from_ptr(text_ptr);
+    c_str.to_str().unwrap_or("")
+}
+
 // Function called from JavaScript
-// Receives Ruby script, executes it, and outputs the result
+// Receives Ruby script, executes it, and returns integer result
 #[unsafe(no_mangle)]
 pub extern "C" fn eval_ruby_script_int(text_ptr: *const c_char) -> i32 {
     unsafe {
-        // Convert C string to Rust string
-        let c_str = CStr::from_ptr(text_ptr);
-        let text = c_str.to_str().unwrap_or("");
-
-        let mut context = MRubyCompiler2Context::new();
-
-        // Compile the Ruby script
-        let mrb = match context.compile(text) {
-            Ok(bytecode) => bytecode,
-            Err(e) => {
-                eprintln!("Compilation error: {}", e);
-                eprintln!("Please check your Ruby code and try again");
-                return -1;
-            }
-        };
-
-        // Load and execute the bytecode
-        let mut rite = match mrubyedge::rite::load(&mrb) {
-            Ok(r) => r,
-            Err(e) => {
-                eprintln!("Failed to load bytecode: {:?}", e);
-                return -1;
-            }
-        };
+        let text = cstr_to_str(text_ptr);
+        match eval_ruby_script(text) {
+            Some(result) => (&*result).try_into().unwrap_or(-1),
+            None => -1,
+        }
+    }
+}
 
-        let mut vm = mrubyedge::yamrb::vm::VM::open(&mut rite);
-        // mruby_math::init_math(&mut vm);
+// Receives Ruby script, executes it, and returns float result
+#[unsafe(no_mangle)]
+pub extern "C" fn eval_ruby_script_float(text_ptr: *const c_char) -> f64 {
+    unsafe {
+        let text = cstr_to_str(text_ptr);
+        match eval_ruby_script(text) {
+            Some(result) => (&*result).try_into().unwrap_or(f64::NAN),
+            None => f64::NAN,
+        }
+    }
+}
 
-        // Execute the script and handle exceptions
-        let result = match vm.run() {
-            Ok(r) => r,
-            Err(e) => {
-                eprintln!("Runtime error: {:?}", e);
-                return -1;
+// Receives Ruby script, executes it, and returns boolean result (0 or 1)
+#[unsafe(no_mangle)]
+pub extern "C" fn eval_ruby_script_bool(text_ptr: *const c_char) -> i32 {
+    unsafe {
+        let text = cstr_to_str(text_ptr);
+        match eval_ruby_script(text) {
+            Some(result) => {
+                let b: bool = (&*result).try_into().unwrap_or(false);
+                if b { 1 } else { 0 }
             }
-        };
+            None => 0,
+        }
+    }
+}
+
+// Receives Ruby script, executes it, and returns string result
+// Returns a pointer to a null-terminated C string (caller should NOT free it)
+// The returned string is valid until the next call to this function
+static mut LAST_STRING_RESULT: Option<CString> = None;
 
-        result.as_ref().try_into().unwrap_or(-1)
+#[unsafe(no_mangle)]
+pub extern "C" fn eval_ruby_script_string(text_ptr: *const c_char) -> *const c_char {
+    unsafe {
+        let text = cstr_to_str(text_ptr);
+        match eval_ruby_script(text) {
+            Some(result) => {
+                let s: String = (&*result).try_into().unwrap_or_default();
+                match CString::new(s) {
+                    Ok(cstring) => {
+                        let ptr = cstring.as_ptr();
+                        LAST_STRING_RESULT = Some(cstring);
+                        ptr
+                    }
+                    Err(_) => std::ptr::null(),
+                }
+            }
+            None => std::ptr::null(),
+        }
     }
 }