Refactor CLI: Move binaries to examples and use clap for command-line interface

- Move qjs and rust_qjs from bin/ to examples/
- Add clap library for generating CLI in examples
- Update Cargo.toml to include examples and clap dependency
- Remove unused functions in core.rs and js_regexp.rs
- Fix imports in test files to use public API

Author: ssrlive

Cargo.toml

@@ -3,17 +3,8 @@ name = "javascript"
 version = "0.1.0"
 edition = "2021"
 
-[[bin]]
-name = "qjs"
-path = "bin/qjs.rs"
-
-[[bin]]
-name = "rust_qjs"
-path = "bin/rust_qjs.rs"
-
 [dependencies]
 chrono = { version = "0.4", features = ["serde"] }
-env_logger = { version = "0.11", optional = true }
 libc = "0.2.177"
 log = "0.4"
 regex = "1.12.2"
@@ -24,5 +15,14 @@ thiserror = "2.0.17"
 windows-sys = { version = "0.61.2", features = ["Win32_System_Threading", "Win32_System_Diagnostics_ToolHelp", "Win32_Foundation"] }
 
 [dev-dependencies]
+clap = { version = "4.5.53", features = ["derive"] }
 ctor = "0.6"
 env_logger = { version = "0.11" }
+
+[[example]]
+name = "js"
+path = "examples/js.rs"
+
+[[example]]
+name = "rust_js"
+path = "examples/rust_js.rs"

bin/qjs.rs examples/js.rsbin/qjs.rs renamed to examples/js.rs

@@ -1,8 +1,17 @@
-use javascript::core::*;
-use std::env;
-use std::fs;
+use javascript::*;
 use std::process;
 
+#[derive(clap::Parser)]
+#[command(name = "js", version, about = "JavaScript Rust Interpreter")]
+struct Cli {
+    /// Execute script
+    #[arg(short, long)]
+    eval: Option<String>,
+
+    /// JavaScript file to execute
+    file: Option<std::path::PathBuf>,
+}
+
 unsafe fn get_js_string(val: &JSValue) -> String {
     if val.get_tag() != JS_TAG_STRING {
         return String::new();
@@ -18,43 +27,28 @@ unsafe fn get_js_string(val: &JSValue) -> String {
 }
 
 fn main() {
-    let args: Vec<String> = env::args().collect();
+    let cli = <Cli as clap::Parser>::parse();
 
     // Initialize logger (controlled by RUST_LOG)
-    #[cfg(feature = "env_logger")]
     env_logger::init();
 
-    if args.len() < 2 {
-        eprintln!("Usage: {} [options] [file.js | -e script]", args[0]);
-        eprintln!("Options:");
-        eprintln!("  -e script    Execute script");
-        eprintln!("  -h           Show this help");
-        process::exit(1);
-    }
-
     let script_content: String;
     let mut filename = "<eval>".to_string();
 
-    if args[1] == "-h" {
-        println!("QuickJS Rust Interpreter");
-        println!("Usage: {} [options] [file.js | -e script]", args[0]);
-        return;
-    } else if args[1] == "-e" {
-        if args.len() < 3 {
-            eprintln!("Error: -e requires a script argument");
-            process::exit(1);
-        }
-        script_content = args[2].clone();
-    } else {
-        // Read from file
-        filename = args[1].clone();
-        match fs::read_to_string(&filename) {
+    if let Some(script) = cli.eval {
+        script_content = script;
+    } else if let Some(file) = cli.file {
+        filename = file.to_string_lossy().to_string();
+        match std::fs::read_to_string(&file) {
             Ok(content) => script_content = content,
             Err(e) => {
-                eprintln!("Error reading file {}: {}", filename, e);
+                eprintln!("Error reading file {}: {}", file.display(), e);
                 process::exit(1);
             }
         }
+    } else {
+        eprintln!("Error: Must provide either --eval or a file");
+        process::exit(1);
     }
 
     unsafe {

bin/rust_qjs.rs examples/rust_js.rsbin/rust_qjs.rs renamed to examples/rust_js.rs

@@ -1,29 +1,36 @@
-use std::env;
+use javascript::*;
 use std::process;
 
-use javascript::core::*;
+#[derive(clap::Parser)]
+#[command(name = "rust_js", version, about = "JavaScript Rust Interpreter with imports")]
+struct Cli {
+    /// Execute script
+    #[arg(short, long)]
+    eval: Option<String>,
+
+    /// JavaScript file to execute
+    file: Option<std::path::PathBuf>,
+}
 
 fn main() {
-    let args: Vec<String> = env::args().collect();
+    let cli = <Cli as clap::Parser>::parse();
 
     // Initialize logger (controlled by RUST_LOG)
-    #[cfg(feature = "env_logger")]
     env_logger::init();
 
     let script: String;
-    if args.len() >= 3 && args[1] == "-e" {
-        script = args[2].clone();
-    } else if args.len() >= 2 && args[1] != "-h" {
-        // Read from file
-        match std::fs::read_to_string(&args[1]) {
+    if let Some(s) = cli.eval {
+        script = s;
+    } else if let Some(file) = cli.file {
+        match std::fs::read_to_string(&file) {
             Ok(content) => script = content,
             Err(e) => {
-                eprintln!("Error reading file {}: {}", args[1], e);
+                eprintln!("Error reading file {}: {}", file.display(), e);
                 process::exit(1);
             }
         }
     } else {
-        eprintln!("Usage: {} [file.js | -e script]", args[0]);
+        eprintln!("Error: Must provide either --eval or a file");
         process::exit(1);
     }
 

src/core.rs

@@ -22,19 +22,19 @@ use std::rc::Rc;
 // Task queue for asynchronous operations
 #[derive(Clone)]
 pub enum Task {
-    PromiseResolve {
+    Resolve {
         promise: Rc<RefCell<JSPromise>>,
         value: Value,
     },
-    PromiseReject {
+    Reject {
         promise: Rc<RefCell<JSPromise>>,
         reason: Value,
     },
-    PromiseResolution {
+    Resolution {
         promise: Rc<RefCell<JSPromise>>,
         callbacks: Vec<(Value, Rc<RefCell<JSPromise>>)>,
     },
-    PromiseRejection {
+    Rejection {
         promise: Rc<RefCell<JSPromise>>,
         callbacks: Vec<(Value, Rc<RefCell<JSPromise>>)>,
     },
@@ -63,7 +63,7 @@ pub fn resolve_promise(promise: Rc<RefCell<JSPromise>>, value: Value) -> Result<
         let callbacks = p.on_fulfilled.clone();
         p.on_fulfilled.clear();
         if !callbacks.is_empty() {
-            queue_task(Task::PromiseResolution {
+            queue_task(Task::Resolution {
                 promise: promise.clone(),
                 callbacks,
             });
@@ -81,7 +81,7 @@ pub fn reject_promise(promise: Rc<RefCell<JSPromise>>, reason: Value) -> Result<
         let callbacks = p.on_rejected.clone();
         p.on_rejected.clear();
         if !callbacks.is_empty() {
-            queue_task(Task::PromiseRejection {
+            queue_task(Task::Rejection {
                 promise: promise.clone(),
                 callbacks,
             });
@@ -4139,10 +4139,6 @@ pub fn env_set_const(env: &JSObjectDataPtr, key: &str, val: Value) {
     env_mut.set_const(key.to_string());
 }
 
-pub fn env_set_rc(env: &JSObjectDataPtr, key: &str, val_rc: Rc<RefCell<Value>>) {
-    env.borrow_mut().insert(key.to_string(), val_rc);
-}
-
 // Higher-level property API that operates on expressions + environment.
 // `get_prop_env` evaluates `obj_expr` in `env` and returns the property's Rc if present.
 pub fn get_prop_env(env: &JSObjectDataPtr, obj_expr: &Expr, prop: &str) -> Result<Option<Rc<RefCell<Value>>>, JSError> {
@@ -6398,7 +6394,7 @@ pub fn handle_promise_method(obj_map: &JSObjectDataPtr, method: &str, args: &[Ex
                 PromiseState::Fulfilled(_) => {
                     // Queue task to execute on_fulfilled callback asynchronously
                     if let Some(fulfilled_callback) = on_fulfilled {
-                        queue_task(Task::PromiseResolution {
+                        queue_task(Task::Resolution {
                             promise: promise.clone(),
                             callbacks: vec![(fulfilled_callback, new_promise.clone())],
                         });
@@ -6411,7 +6407,7 @@ pub fn handle_promise_method(obj_map: &JSObjectDataPtr, method: &str, args: &[Ex
                 PromiseState::Rejected(_) => {
                     // Queue task to execute on_rejected callback asynchronously
                     if let Some(rejected_callback) = on_rejected {
-                        queue_task(Task::PromiseRejection {
+                        queue_task(Task::Rejection {
                             promise: promise.clone(),
                             callbacks: vec![(rejected_callback, new_promise.clone())],
                         });
@@ -6452,7 +6448,7 @@ pub fn handle_promise_method(obj_map: &JSObjectDataPtr, method: &str, args: &[Ex
                 }
                 PromiseState::Rejected(_) => {
                     // Queue task to execute on_rejected callback asynchronously
-                    queue_task(Task::PromiseRejection {
+                    queue_task(Task::Rejection {
                         promise: promise.clone(),
                         callbacks: vec![(on_rejected, new_promise.clone())],
                     });
@@ -6473,7 +6469,7 @@ pub fn run_event_loop() -> Result<(), JSError> {
         let task = GLOBAL_TASK_QUEUE.with(|queue| queue.borrow_mut().pop_front());
 
         match task {
-            Some(Task::PromiseResolve { promise, value }) => {
+            Some(Task::Resolve { promise, value }) => {
                 let mut promise_mut = promise.borrow_mut();
                 if let PromiseState::Pending = promise_mut.state {
                     promise_mut.state = PromiseState::Fulfilled(value.clone());
@@ -6483,14 +6479,14 @@ pub fn run_event_loop() -> Result<(), JSError> {
                     let callbacks = promise_mut.on_fulfilled.clone();
                     promise_mut.on_fulfilled.clear();
                     if !callbacks.is_empty() {
-                        queue_task(Task::PromiseResolution {
+                        queue_task(Task::Resolution {
                             promise: promise.clone(),
                             callbacks,
                         });
                     }
                 }
             }
-            Some(Task::PromiseReject { promise, reason }) => {
+            Some(Task::Reject { promise, reason }) => {
                 let mut promise_mut = promise.borrow_mut();
                 if let PromiseState::Pending = promise_mut.state {
                     promise_mut.state = PromiseState::Rejected(reason.clone());
@@ -6500,14 +6496,14 @@ pub fn run_event_loop() -> Result<(), JSError> {
                     let callbacks = promise_mut.on_rejected.clone();
                     promise_mut.on_rejected.clear();
                     if !callbacks.is_empty() {
-                        queue_task(Task::PromiseRejection {
+                        queue_task(Task::Rejection {
                             promise: promise.clone(),
                             callbacks,
                         });
                     }
                 }
             }
-            Some(Task::PromiseResolution { promise, callbacks }) => {
+            Some(Task::Resolution { promise, callbacks }) => {
                 for (callback, new_promise) in callbacks {
                     // Call the callback and resolve the new promise with the result
                     match evaluate_expr(
@@ -6526,7 +6522,7 @@ pub fn run_event_loop() -> Result<(), JSError> {
                     }
                 }
             }
-            Some(Task::PromiseRejection { promise, callbacks }) => {
+            Some(Task::Rejection { promise, callbacks }) => {
                 for (callback, new_promise) in callbacks {
                     // Call the callback and resolve the new promise with the result
                     match evaluate_expr(

src/js_function.rs

@@ -374,7 +374,7 @@ pub fn handle_global_function(func_name: &str, args: &[Expr], env: &JSObjectData
                     if let Some(promise_val) = crate::core::obj_get_value(env, &promise_key)? {
                         if let Value::Promise(promise_rc) = &*promise_val.borrow() {
                             // Queue asynchronous resolution task
-                            crate::core::queue_task(crate::core::Task::PromiseResolve {
+                            crate::core::queue_task(crate::core::Task::Resolve {
                                 promise: promise_rc.clone(),
                                 value,
                             });
@@ -405,7 +405,7 @@ pub fn handle_global_function(func_name: &str, args: &[Expr], env: &JSObjectData
                     if let Some(promise_val) = crate::core::obj_get_value(env, &promise_key)? {
                         if let Value::Promise(promise_rc) = &*promise_val.borrow() {
                             // Queue asynchronous rejection task
-                            crate::core::queue_task(crate::core::Task::PromiseReject {
+                            crate::core::queue_task(crate::core::Task::Reject {
                                 promise: promise_rc.clone(),
                                 reason,
                             });

src/js_regexp.rs

@@ -358,20 +358,3 @@ pub(crate) fn handle_regexp_method(
         }),
     }
 }
-
-/// Create the RegExp constructor function
-pub fn make_regexp_constructor() -> Result<JSObjectDataPtr, JSError> {
-    let regexp_ctor = Rc::new(RefCell::new(JSObjectData::new()));
-    obj_set_value(&regexp_ctor, "prototype", Value::Object(make_regexp_prototype()?))?;
-    Ok(regexp_ctor)
-}
-
-/// Create the RegExp prototype object
-pub fn make_regexp_prototype() -> Result<JSObjectDataPtr, JSError> {
-    let proto = Rc::new(RefCell::new(JSObjectData::new()));
-    obj_set_value(&proto, "constructor", Value::Function("RegExp".to_string()))?;
-    obj_set_value(&proto, "exec", Value::Function("RegExp.prototype.exec".to_string()))?;
-    obj_set_value(&proto, "test", Value::Function("RegExp.prototype.test".to_string()))?;
-    obj_set_value(&proto, "toString", Value::Function("RegExp.prototype.toString".to_string()))?;
-    Ok(proto)
-}

src/lib.rs

@@ -2,20 +2,32 @@
 // pub mod libregexp;
 // pub mod libunicode;
 // pub mod libunicode_table;
-pub mod core;
-pub mod error;
-pub mod js_array;
-pub mod js_class;
-pub mod js_console;
-pub mod js_date;
-pub mod js_function;
-pub mod js_json;
-pub mod js_math;
-pub mod js_number;
-pub mod js_object;
-pub mod js_os;
-pub mod js_regexp;
-pub mod js_std;
-pub mod js_string;
-pub mod sprintf;
-pub mod tmpfile;
+pub(crate) mod core;
+pub(crate) mod error;
+pub(crate) mod js_array;
+pub(crate) mod js_class;
+pub(crate) mod js_console;
+pub(crate) mod js_date;
+pub(crate) mod js_function;
+pub(crate) mod js_json;
+pub(crate) mod js_math;
+pub(crate) mod js_number;
+pub(crate) mod js_object;
+pub(crate) mod js_os;
+pub(crate) mod js_regexp;
+pub(crate) mod js_std;
+pub(crate) mod js_string;
+pub(crate) mod sprintf;
+pub(crate) mod tmpfile;
+
+pub use core::{
+    evaluate_script, evaluate_script_async, get_prop_env, obj_get_value, tokenize, JSClassDef, JSObject, JSStackFrame, JSString, JSValue,
+    JS_DefinePropertyValue, JS_DupValue, JS_Eval, JS_FreeContext, JS_FreeRuntime, JS_FreeValue, JS_GetProperty, JS_NewContext,
+    JS_NewObject, JS_NewRuntime, JS_NewString, JS_SetProperty, Value,
+};
+pub use core::{
+    JS_FLOAT64_NAN, JS_GC_OBJ_TYPE_ASYNC_FUNCTION, JS_GC_OBJ_TYPE_FUNCTION_BYTECODE, JS_GC_OBJ_TYPE_JS_CONTEXT, JS_GC_OBJ_TYPE_JS_OBJECT,
+    JS_GC_OBJ_TYPE_SHAPE, JS_GC_OBJ_TYPE_VAR_REF, JS_TAG_BOOL, JS_TAG_CATCH_OFFSET, JS_TAG_FLOAT64, JS_TAG_INT, JS_TAG_NULL, JS_TAG_OBJECT,
+    JS_TAG_SHORT_BIG_INT, JS_TAG_STRING, JS_TAG_STRING_ROPE, JS_TAG_UNDEFINED, JS_UNINITIALIZED,
+};
+pub use error::JSError;

tests/array_literals.rs

@@ -1,5 +1,5 @@
-use javascript::core::evaluate_script;
-use javascript::core::Value;
+use javascript::evaluate_script;
+use javascript::Value;
 
 // Initialize logger for this integration test binary so `RUST_LOG` is honored.
 // Using `ctor` ensures initialization runs before tests start.

tests/async_await_tests.rs

@@ -1,4 +1,4 @@
-use javascript::core::{evaluate_script, obj_get_value, Value};
+use javascript::{evaluate_script, obj_get_value, Value};
 
 // Initialize logger for this integration test binary so `RUST_LOG` is honored.
 // Using `ctor` ensures initialization runs before tests start.

tests/basic_arithmetic.rs

@@ -1,5 +1,5 @@
-use javascript::core::evaluate_script;
-use javascript::core::Value;
+use javascript::evaluate_script;
+use javascript::Value;
 
 // Initialize logger for this integration test binary so `RUST_LOG` is honored.
 // Using `ctor` ensures initialization runs before tests start.