Add _js module and fix imports

coolreader18 · coolreader18 · commit 56bcb02a5e22 · 2019-06-21T20:20:20.000-05:00
diff --git a/wasm/lib/src/js_module.rs b/wasm/lib/src/js_module.rs
@@ -0,0 +1,198 @@
+use crate::convert;
+use js_sys::{Array, Object, Reflect};
+use rustpython_vm::function::Args;
+use rustpython_vm::obj::{objfloat::PyFloatRef, objstr::PyStringRef, objtype::PyClassRef};
+use rustpython_vm::pyobject::{PyClassImpl, PyObjectRef, PyRef, PyResult, PyValue, TryFromObject};
+use rustpython_vm::VirtualMachine;
+use wasm_bindgen::{prelude::*, JsCast};
+
+// I don't know why there is no other option for this
+#[wasm_bindgen(inline_js = "export function type_of(a) { return typeof a; }")]
+extern "C" {
+    #[wasm_bindgen]
+    fn type_of(a: JsValue) -> String;
+}
+
+#[pyclass(name = "JsValue")]
+#[derive(Debug)]
+pub struct PyJsValue {
+    value: JsValue,
+}
+type PyJsValueRef = PyRef<PyJsValue>;
+
+impl PyValue for PyJsValue {
+    fn class(vm: &VirtualMachine) -> PyClassRef {
+        vm.class("_js", "JsValue")
+    }
+}
+
+enum JsProperty {
+    Str(PyStringRef),
+    Js(PyJsValueRef),
+}
+
+impl TryFromObject for JsProperty {
+    fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
+        PyStringRef::try_from_object(vm, obj.clone())
+            .map(JsProperty::Str)
+            .or_else(|_| PyJsValueRef::try_from_object(vm, obj).map(JsProperty::Js))
+    }
+}
+
+impl JsProperty {
+    fn to_jsvalue(self) -> JsValue {
+        match self {
+            JsProperty::Str(s) => s.as_str().into(),
+            JsProperty::Js(value) => value.value.clone(),
+        }
+    }
+}
+
+#[pyimpl]
+impl PyJsValue {
+    #[inline]
+    pub fn new(value: impl Into<JsValue>) -> PyJsValue {
+        PyJsValue {
+            value: value.into(),
+        }
+    }
+
+    #[pyclassmethod]
+    fn null(cls: PyClassRef, vm: &VirtualMachine) -> PyResult<PyJsValueRef> {
+        PyJsValue::new(JsValue::NULL).into_ref_with_type(vm, cls)
+    }
+
+    #[pyclassmethod]
+    fn undefined(cls: PyClassRef, vm: &VirtualMachine) -> PyResult<PyJsValueRef> {
+        PyJsValue::new(JsValue::UNDEFINED).into_ref_with_type(vm, cls)
+    }
+
+    #[pyclassmethod]
+    fn fromstr(cls: PyClassRef, s: PyStringRef, vm: &VirtualMachine) -> PyResult<PyJsValueRef> {
+        PyJsValue::new(s.as_str()).into_ref_with_type(vm, cls)
+    }
+
+    #[pyclassmethod]
+    fn fromfloat(cls: PyClassRef, n: PyFloatRef, vm: &VirtualMachine) -> PyResult<PyJsValueRef> {
+        PyJsValue::new(n.to_f64()).into_ref_with_type(vm, cls)
+    }
+
+    #[pyclassmethod]
+    fn new_object(
+        cls: PyClassRef,
+        opts: NewObjectOptions,
+        vm: &VirtualMachine,
+    ) -> PyResult<PyJsValueRef> {
+        let value = if let Some(proto) = opts.prototype {
+            if let Some(proto) = proto.value.dyn_ref::<Object>() {
+                Object::create(proto)
+            } else if proto.value.is_null() {
+                Object::create(proto.value.unchecked_ref())
+            } else {
+                return Err(vm.new_value_error(format!("prototype must be an Object or null")));
+            }
+        } else {
+            Object::new()
+        };
+        PyJsValue::new(value).into_ref_with_type(vm, cls)
+    }
+
+    #[pymethod]
+    fn get_prop(&self, name: JsProperty, vm: &VirtualMachine) -> PyResult<PyJsValue> {
+        let name = &name.to_jsvalue();
+        if Reflect::has(&self.value, name).map_err(|err| convert::js_to_py(vm, err))? {
+            Reflect::get(&self.value, name)
+                .map(PyJsValue::new)
+                .map_err(|err| convert::js_to_py(vm, err))
+        } else {
+            Err(vm.new_attribute_error(format!("No attribute {:?} on JS value", name)))
+        }
+    }
+
+    #[pymethod]
+    fn set_prop(
+        &self,
+        name: JsProperty,
+        value: PyJsValueRef,
+        vm: &VirtualMachine,
+    ) -> PyResult<PyJsValue> {
+        Reflect::set(&self.value, &name.to_jsvalue(), &value.value)
+            .map(PyJsValue::new)
+            .map_err(|err| convert::js_to_py(vm, err))
+    }
+
+    #[pymethod]
+    fn as_str(&self, _vm: &VirtualMachine) -> Option<String> {
+        self.value.as_string()
+    }
+
+    #[pymethod]
+    fn as_float(&self, _vm: &VirtualMachine) -> Option<f64> {
+        self.value.as_f64()
+    }
+
+    #[pymethod]
+    /// Checks that `typeof self == "object" && self !== null`. Use instead
+    /// of `value.typeof() == "object"`
+    fn is_object(&self, _vm: &VirtualMachine) -> bool {
+        self.value.is_object()
+    }
+
+    #[pymethod]
+    fn call(
+        &self,
+        args: Args<PyJsValueRef>,
+        opts: CallOptions,
+        vm: &VirtualMachine,
+    ) -> PyResult<PyJsValue> {
+        let func = self
+            .value
+            .dyn_ref::<js_sys::Function>()
+            .ok_or_else(|| vm.new_type_error("JS value is not callable".to_string()))?;
+        let this = opts
+            .this
+            .map(|this| this.value.clone())
+            .unwrap_or(JsValue::UNDEFINED);
+        let js_args = Array::new();
+        for arg in args {
+            js_args.push(&arg.value);
+        }
+        Reflect::apply(func, &this, &js_args)
+            .map(PyJsValue::new)
+            .map_err(|err| convert::js_to_py(vm, err))
+    }
+
+    #[pymethod(name = "typeof")]
+    fn type_of(&self, _vm: &VirtualMachine) -> String {
+        type_of(self.value.clone())
+    }
+
+    #[pymethod(name = "__repr__")]
+    fn repr(&self, _vm: &VirtualMachine) -> String {
+        format!("{:?}", self.value)
+    }
+}
+
+#[derive(FromArgs)]
+struct CallOptions {
+    #[pyarg(keyword_only, default = "None")]
+    this: Option<PyJsValueRef>,
+}
+
+#[derive(FromArgs)]
+struct NewObjectOptions {
+    #[pyarg(keyword_only, default = "None")]
+    prototype: Option<PyJsValueRef>,
+}
+
+pub fn make_module(vm: &VirtualMachine) -> PyObjectRef {
+    py_module!(vm, "_js", {
+      "JsValue" => PyJsValue::make_class(&vm.ctx),
+    })
+}
+
+pub fn setup_js_module(vm: &VirtualMachine) {
+    vm.stdlib_inits
+        .borrow_mut()
+        .insert("_js".to_string(), Box::new(make_module));
+}
diff --git a/wasm/lib/src/lib.rs b/wasm/lib/src/lib.rs
@@ -1,5 +1,6 @@
 pub mod browser_module;
 pub mod convert;
+pub mod js_module;
 pub mod vm_class;
 pub mod wasm_builtins;
 
diff --git a/wasm/lib/src/vm_class.rs b/wasm/lib/src/vm_class.rs
@@ -8,11 +8,12 @@ use wasm_bindgen::prelude::*;
 use rustpython_vm::compile;
 use rustpython_vm::frame::{NameProtocol, Scope};
 use rustpython_vm::function::PyFuncArgs;
-use rustpython_vm::pyobject::{PyObject, PyObjectPayload, PyObjectRef, PyResult};
+use rustpython_vm::pyobject::{PyObject, PyObjectPayload, PyObjectRef, PyResult, PyValue};
 use rustpython_vm::VirtualMachine;
 
 use crate::browser_module::setup_browser_module;
 use crate::convert;
+use crate::js_module;
 use crate::wasm_builtins;
 
 pub(crate) struct StoredVirtualMachine {
@@ -26,11 +27,24 @@ pub(crate) struct StoredVirtualMachine {
 impl StoredVirtualMachine {
     fn new(id: String, inject_browser_module: bool) -> StoredVirtualMachine {
         let mut vm = VirtualMachine::new();
+        vm.wasm_id = Some(id);
         let scope = vm.new_scope_with_builtins();
+
+        js_module::setup_js_module(&vm);
         if inject_browser_module {
+            vm.stdlib_inits.borrow_mut().insert(
+                "_window".to_string(),
+                Box::new(|vm| {
+                    py_module!(vm, "_window", {
+                        "window" => js_module::PyJsValue::new(wasm_builtins::window()).into_ref(vm),
+                    })
+                }),
+            );
             setup_browser_module(&vm);
         }
-        vm.wasm_id = Some(id);
+
+        *vm.import_func.borrow_mut() = vm.ctx.new_rustfunc(wasm_builtins::builtin_import);
+
         StoredVirtualMachine {
             vm,
             scope: RefCell::new(scope),
diff --git a/wasm/lib/src/wasm_builtins.rs b/wasm/lib/src/wasm_builtins.rs
@@ -7,9 +7,13 @@
 use js_sys::{self, Array};
 use web_sys::{self, console};
 
-use rustpython_vm::function::PyFuncArgs;
-use rustpython_vm::obj::{objstr, objtype};
-use rustpython_vm::pyobject::{IdProtocol, PyObjectRef, PyResult, TypeProtocol};
+use rustpython_vm::function::{Args, KwArgs, PyFuncArgs};
+use rustpython_vm::import;
+use rustpython_vm::obj::{
+    objstr::{self, PyStringRef},
+    objtype,
+};
+use rustpython_vm::pyobject::{IdProtocol, ItemProtocol, PyObjectRef, PyResult, TypeProtocol};
 use rustpython_vm::VirtualMachine;
 
 pub(crate) fn window() -> web_sys::Window {
@@ -76,3 +80,29 @@ pub fn builtin_print_console(vm: &VirtualMachine, args: PyFuncArgs) -> PyResult
     console::log(&arr);
     Ok(vm.get_none())
 }
+
+pub fn builtin_import(
+    module_name: PyStringRef,
+    _args: Args,
+    _kwargs: KwArgs,
+    vm: &VirtualMachine,
+) -> PyResult<PyObjectRef> {
+    let module_name = module_name.as_str();
+
+    let sys_modules = vm.get_attribute(vm.sys_module.clone(), "modules").unwrap();
+
+    // First, see if we already loaded the module:
+    if let Ok(module) = sys_modules.get_item(module_name.to_string(), vm) {
+        Ok(module)
+    } else if vm.frozen.borrow().contains_key(module_name) {
+        import::import_frozen(vm, module_name)
+    } else if vm.stdlib_inits.borrow().contains_key(module_name) {
+        import::import_builtin(vm, module_name)
+    } else {
+        let notfound_error = vm.context().exceptions.module_not_found_error.clone();
+        Err(vm.new_exception(
+            notfound_error,
+            format!("Module {:?} not found", module_name),
+        ))
+    }
+}
