scriptit 0.3.0

scriptit is a simple way to run JavaScript code in Rust (native+wasm)
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

use crate::core::{error::ScriptError, value::ScriptValue, ScriptingEnvironment};
use std::{cell::RefCell, collections::HashMap, rc::Rc};
use wasm_bindgen::prelude::*;

#[wasm_bindgen]
extern "C" {
    #[wasm_bindgen(js_name = eval, catch)]
    fn bootstrap_eval(s: &str) -> Result<BootstrapResult, Error>;

    type Error;

    #[wasm_bindgen(method, getter)]
    fn message(this: &Error) -> String;

    type BootstrapResult;
    type CompiledFunction;

    #[wasm_bindgen(method, catch)]
    fn compile(his: &BootstrapResult, s: &str) -> Result<CompiledFunction, Error>;

    #[wasm_bindgen(method, catch)]
    fn run(this: &BootstrapResult, fun: &CompiledFunction) -> Result<JsValue, Error>;

    #[wasm_bindgen(js_name = setCallToRust, method)]
    fn set_call_to_rust(this: &BootstrapResult, fun: JsValue);
}

fn js_bootstrap() -> BootstrapResult {
    let wasm_bootstrap_res = bootstrap_eval(include_str!("./wasm_bootstrap.js"))
        .map_err(|e| e.message())
        .unwrap();
    let shared_bootstrap_src = wasm_bootstrap_res
        .compile(include_str!("../js/shared_bootstrap.js"))
        .map_err(|e| e.message())
        .unwrap();
    wasm_bootstrap_res
        .run(&shared_bootstrap_src)
        .map_err(|e| e.message())
        .unwrap();
    wasm_bootstrap_res
}

fn jsvalue_to_scriptvalue(value: JsValue) -> Result<ScriptValue, ScriptError> {
    value
        .into_serde()
        .map_err(|e| ScriptError::SerializationError(e.to_string()))
}

fn jsvalue_to_script_compile_error(error: Error) -> ScriptError {
    ScriptError::CompileError(error.message())
}

fn jsvalue_to_script_runtime_error(error: Error) -> ScriptError {
    ScriptError::RuntimeError(error.message())
}

pub struct WASMScriptingEnvironment {
    bootstrapped: BootstrapResult,
    handlers: Rc<RefCell<HashMap<String, Box<dyn FnMut(&str) -> String>>>>,
}

impl WASMScriptingEnvironment {
    pub fn new() -> WASMScriptingEnvironment {
        let handlers = Rc::new(RefCell::new(HashMap::new()));
        let wse = WASMScriptingEnvironment {
            bootstrapped: js_bootstrap(),
            handlers: Rc::clone(&handlers),
        };

        let closure_handlers = Rc::clone(&handlers);
        let closure = Closure::wrap(Box::new(move |handler_name: JsValue, data: JsValue| {
            if let (Some(handler_name), Some(data)) = (handler_name.as_string(), data.as_string()) {
                let mut handlers = closure_handlers.borrow_mut();
                let handler_closure = handlers.get_mut(&handler_name).unwrap();
                let handler_result = handler_closure(&data);
                JsValue::from_str(&handler_result)
            } else {
                panic!("Passed non-string values to ScriptIt.core.callToRust")
            }
        }) as Box<dyn FnMut(JsValue, JsValue) -> JsValue>);

        wse.bootstrapped.set_call_to_rust(closure.into_js_value());

        wse
    }

    fn internal_eval(&mut self, source: &str) -> Result<ScriptValue, ScriptError> {
        let func = self
            .bootstrapped
            .compile(source)
            .map_err(|e| jsvalue_to_script_compile_error(e))?;
        match self.bootstrapped.run(&func) {
            Ok(value) => jsvalue_to_scriptvalue(value),
            Err(value) => Err(jsvalue_to_script_runtime_error(value)),
        }
    }
}

impl ScriptingEnvironment for WASMScriptingEnvironment {
    /// Evaluates a single JS expression
    fn eval_expression(&mut self, source: &str) -> Result<ScriptValue, ScriptError> {
        self.internal_eval(&format!("return {}", source))
    }

    /// Runs JavaScript code
    fn run(&mut self, source: &str) -> Result<(), ScriptError> {
        self.internal_eval(source)?;
        Ok(())
    }

    fn register_core_handler(
        &mut self,
        handler_name: &str,
        handler_closure: Box<dyn FnMut(&str) -> String>,
    ) {
        self.handlers
            .borrow_mut()
            .insert(handler_name.to_string(), handler_closure);
    }
}

pub type PlatformScriptingEnvironment = WASMScriptingEnvironment;