working on promises/modules/eventqueue

Author: andrieshiemstra

Cargo.toml

@@ -14,7 +14,8 @@ categories = ["development-tools"]
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-quick-js = "0.3.3"
+#quick-js = "0.3.3"
+quick-js = {path = "../quickjs-rs"}
 lazy_static = "1.4.0"
 log = "0.4.11"
 simple-logging = "2.0.2"

README.md

@@ -1 +1,9 @@
-# quick_es_runtime
+# quick_es_runtime
+
+Same goals as es_runtime but with using quickjs
+
+so 
+* slower js 
+* smaller footprint 
+* much faster compilation
+

src/esruntime.rs

@@ -4,6 +4,7 @@ use crate::esscript::EsScript;
 use crate::quickjsruntime::QuickJsRuntime;
 use quick_js::{ExecutionError, JsValue};
 use std::sync::Arc;
+use log::error;
 
 pub struct EsRuntime {
     event_queue: Arc<EsEventQueue>,
@@ -38,9 +39,19 @@ impl EsRuntime {
 
     pub fn gc_sync() {}
 
-    pub fn load_module() {}
+    pub fn eval_module(&self, script: EsScript) {
+        self.add_to_event_queue(|qjs_rt| {
+            let res = qjs_rt.eval_module(script);
+            match res {
+                Ok(_) => {}
+                Err(e) => log::error!("error in async eval {}", e),
+            }
+        });
+    }
 
-    pub fn load_module_sync() {}
+    pub fn eval_module_sync(&self, script: EsScript) -> Result<JsValue, ExecutionError> {
+        self.add_to_event_queue_sync(|qjs_rt| qjs_rt.eval_module(script))
+    }
 
     pub fn new_class_builder() {}
 
@@ -50,27 +61,49 @@ impl EsRuntime {
     {
         self.event_queue
             .add_task(|| QuickJsRuntime::do_with(consumer));
+        self._add_job_run_task();
     }
 
     pub fn add_to_event_queue_sync<C, R>(&self, consumer: C) -> R
     where
         C: FnOnce(&QuickJsRuntime) -> R + Send + 'static,
         R: Send + 'static,
     {
-        self.event_queue
-            .exe_task(|| QuickJsRuntime::do_with(consumer))
+        let res = self.event_queue
+            .exe_task(|| QuickJsRuntime::do_with(consumer));
+        self._add_job_run_task();
+        res
     }
 
     pub fn add_helper_task() {}
+
+    fn _add_job_run_task(&self) {
+        self.event_queue.add_task(|| {
+            QuickJsRuntime::do_with(|quick_js_rt| {
+                while quick_js_rt.has_pending_jobs() {
+
+                    let res = quick_js_rt.run_pending_job();
+                    match res {
+                        Ok(_) => {},
+                        Err(e) => {
+                            error!("job run failed: {}", e);
+                        },
+                    }
+
+                }
+            })
+        });
+    }
 }
 
 #[cfg(test)]
 pub mod tests {
     use crate::esruntime::EsRuntime;
     use crate::esscript::EsScript;
     use log::LevelFilter;
-    use quick_js::JsValue;
+    use quick_js::{JsValue, ExecutionError};
     use std::sync::Arc;
+    use::log::debug;
 
     lazy_static! {
         pub static ref TEST_ESRT: Arc<EsRuntime> = init();
@@ -83,13 +116,17 @@ pub mod tests {
         EsRuntime::builder().build()
     }
 
+
+
     #[test]
     fn test_eval_sync() {
         let rt = &TEST_ESRT;
-        rt.eval(EsScript::new(
+        rt.eval_sync(EsScript::new(
             "test.es".to_string(),
             "console.log('foo bar');".to_string(),
-        ));
+        )).ok().expect("eval script failed");
+
+
 
         let res = rt
             .eval_sync(EsScript::new("test.es".to_string(), "(2 * 7);".to_string()))
@@ -98,4 +135,50 @@ pub mod tests {
 
         assert_eq!(res, JsValue::Int(14));
     }
+
+    #[test]
+    fn test_promise(){
+        let rt = &TEST_ESRT;
+
+        rt.eval_sync(EsScript::new(
+            "testp2.es".to_string(),
+            "let r = {a: 1};console.log('setting up prom');let p = new Promise((res, rej) => {console.log('before res');res(123);console.log('after res');return 456;}).then((a) => {r.a = 2;console.log('prom ressed to ' + a);}).catch((x) => {console.log('p.ca ex=' + x);});".to_string(),
+        )).ok().expect("eval script failed");
+
+        rt.eval_sync(EsScript::new(
+            "testp2.es".to_string(),
+            "console.log('r.a = ' + r.a + ' p= ' + p);".to_string(),
+        )).ok().expect("eval script failed");
+    }
+
+    #[test]
+    fn test_module_sync() {
+        let rt = &TEST_ESRT;
+        debug!("test static import");
+        let res: Result<JsValue, ExecutionError> = rt.eval_module_sync(EsScript::new(
+            "test.es".to_string(),
+            "import {some} from 'test_module.mes';\n console.log(some.foo);".to_string(),
+        ));
+
+        match res {
+            Ok(_) => {},
+            Err(e) => {
+                log::error!("static import failed: {}", e);
+            },
+        }
+
+        debug!("test dynamic import");
+        let res: Result<JsValue, ExecutionError> = rt.eval_module_sync(EsScript::new(
+            "test.es".to_string(),
+            "console.log('about to load dynamic module');import('test_module.mes').then((some) => {console.log('after dyn ' + some);console.log(some.mltpl(1, 2));}).catch((x) => {console.log('imp.cat x=' + x);});".to_string(),
+        ));
+
+        match res {
+            Ok(_) => {},
+            Err(e) => {
+                log::error!("dynamic import failed: {}", e);
+            },
+        }
+
+    }
 }

src/esruntimebuilder.rs

@@ -11,3 +11,9 @@ impl EsRuntimeBuilder {
         Self {}
     }
 }
+
+impl Default for EsRuntimeBuilder {
+    fn default() -> Self {
+        EsRuntimeBuilder::new()
+    }
+}

src/lib.rs

@@ -1,3 +1,4 @@
+#[allow(unused_imports)]
 #[macro_use]
 extern crate lazy_static;
 

src/quickjsruntime.rs

@@ -4,6 +4,7 @@ use crate::esscript::EsScript;
 use crate::quickjsconsole::QuickJsConsole;
 use quick_js::{Context, ExecutionError, JsValue};
 use std::cell::RefCell;
+use log::trace;
 
 thread_local! {
    /// the thread-local SpiderMonkeyRuntime
@@ -29,6 +30,10 @@ impl QuickJsRuntime {
         self.context.eval(script.get_code())
     }
 
+    pub fn eval_module(&self, script: EsScript) -> Result<JsValue, ExecutionError> {
+        self.context.eval_module(script.get_path(), script.get_code())
+    }
+
     pub(crate) fn do_with<C, R>(task: C) -> R
     where
         C: FnOnce(&QuickJsRuntime) -> R + Send + 'static,
@@ -39,4 +44,19 @@ impl QuickJsRuntime {
             task(qjs_rt)
         })
     }
+
+    pub fn has_pending_jobs(&self) -> bool {
+
+        let res = self.context.has_pending_jobs();
+        trace!("QuickJSRuntime::has_pending_jobs = {}", res);
+        res
+
+    }
+
+    pub fn run_pending_job(&self)  -> Result<(), ExecutionError>{
+        let res = self.context.run_pending_job();
+        trace!("QuickJSRuntime::run_pending_job ok = {}", res.is_ok());
+        res
+    }
+
 }

src/taskmanager.rs

@@ -61,7 +61,7 @@ mod tests {
 
         assert_eq!(s, "res");
 
-        for _x in 0..1000 {
+        for _x in 0..5 {
             let s = tm.run_task_blocking(|| "res");
 
             assert_eq!(s, "res");

test.mes

@@ -0,0 +1,5 @@
+import {mltpl} from "test_module.mes";
+
+console.info("hello world from test.mes, 5 * 6 = %s", mltpl(5, 6));
+
+

test_module.mes

@@ -0,0 +1,3 @@
+export function mltpl(a, b) {
+    return a * b;
+}