Remove WASM fetch builtin

RustPython · windelbouwman · Feb 23, 2019 · Jan 30, 2019 · Jan 30, 2019 · Jan 30, 2019
commit 634571fd2ecac71a7e9fc32807d9acd13b8ab183
diff --git a/wasm/lib/src/lib.rs b/wasm/lib/src/lib.rs
@@ -1,13 +1,11 @@
-mod convert;
-mod vm_class;
-mod wasm_builtins;
+pub mod convert;
+pub mod vm_class;
+pub mod wasm_builtins;
 
+extern crate futures;
 extern crate js_sys;
-#[macro_use]
 extern crate rustpython_vm;
-extern crate futures;
 extern crate wasm_bindgen;
-extern crate wasm_bindgen_futures;
 extern crate web_sys;
 
 use js_sys::{Object, Reflect, TypeError};

diff --git a/wasm/lib/src/vm_class.rs b/wasm/lib/src/vm_class.rs
@@ -93,7 +93,7 @@ impl VMStore {
 }
 
 #[derive(Clone)]
-pub(crate) struct AccessibleVM {
+pub struct AccessibleVM {
     weak: Weak<RefCell<StoredVirtualMachine>>,
     id: String,
 }
@@ -148,7 +148,7 @@ impl From<&WASMVirtualMachine> for AccessibleVM {
     }
 }
 
-pub(crate) struct AccessibleVMPtr<'a> {
+pub struct AccessibleVMPtr<'a> {
     id: String,
     top_level: bool,
     inner: &'a mut VirtualMachine,

diff --git a/wasm/lib/src/wasm_builtins.rs b/wasm/lib/src/wasm_builtins.rs
@@ -8,17 +8,14 @@
 extern crate futures;
 extern crate js_sys;
 extern crate wasm_bindgen;
-extern crate wasm_bindgen_futures;
 extern crate web_sys;
 
-use crate::{convert, vm_class::AccessibleVM};
-use futures::{future, Future};
-use js_sys::{Array, Promise};
+use crate::convert;
+use js_sys::Array;
 use rustpython_vm::obj::{objstr, objtype};
 use rustpython_vm::pyobject::{IdProtocol, PyFuncArgs, PyObjectRef, PyResult, TypeProtocol};
 use rustpython_vm::VirtualMachine;
 use wasm_bindgen::{prelude::*, JsCast};
-use wasm_bindgen_futures::{future_to_promise, JsFuture};
 use web_sys::{console, HtmlTextAreaElement};
 
 fn window() -> web_sys::Window {
@@ -107,116 +104,7 @@ pub fn builtin_print_console(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyRes
     Ok(vm.get_none())
 }
 
-enum FetchResponseFormat {
-    Json,
-    Text,
-    ArrayBuffer,
-}
-
-impl FetchResponseFormat {
-    fn from_str(vm: &mut VirtualMachine, s: &str) -> Result<Self, PyObjectRef> {
-        match s {
-            "json" => Ok(FetchResponseFormat::Json),
-            "text" => Ok(FetchResponseFormat::Text),
-            "array_buffer" => Ok(FetchResponseFormat::ArrayBuffer),
-            _ => Err(vm.new_type_error("Unkown fetch response_format".into())),
-        }
-    }
-    fn get_response(&self, response: &web_sys::Response) -> Result<Promise, JsValue> {
-        match self {
-            FetchResponseFormat::Json => response.json(),
-            FetchResponseFormat::Text => response.text(),
-            FetchResponseFormat::ArrayBuffer => response.array_buffer(),
-        }
-    }
-}
-
-fn builtin_fetch(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
-    arg_check!(
-        vm,
-        args,
-        required = [
-            (url, Some(vm.ctx.str_type())),
-            (handler, Some(vm.ctx.function_type()))
-        ],
-        // TODO: use named parameters for these
-        optional = [
-            (reject_handler, Some(vm.ctx.function_type())),
-            (response_format, Some(vm.ctx.str_type())),
-            (method, Some(vm.ctx.str_type())),
-            (headers, Some(vm.ctx.dict_type()))
-        ]
-    );
-
-    let response_format = match response_format {
-        Some(s) => FetchResponseFormat::from_str(vm, &objstr::get_value(s))?,
-        None => FetchResponseFormat::Text,
-    };
-
-    let mut opts = web_sys::RequestInit::new();
-
-    match method {
-        Some(s) => opts.method(&objstr::get_value(s)),
-        None => opts.method("GET"),
-    };
-
-    let request = web_sys::Request::new_with_str_and_init(&objstr::get_value(url), &opts)
-        .map_err(|err| convert::js_py_typeerror(vm, err))?;
-
-    if let Some(headers) = headers {
-        use rustpython_vm::obj::objdict;
-        let h = request.headers();
-        for (key, value) in objdict::get_key_value_pairs(headers) {
-            let key = objstr::get_value(&vm.to_str(&key)?);
-            let value = objstr::get_value(&vm.to_str(&value)?);
-            h.set(&key, &value)
-                .map_err(|err| convert::js_py_typeerror(vm, err))?;
-        }
-    }
-
-    let window = window();
-    let request_prom = window.fetch_with_request(&request);
-
-    let handler = handler.clone();
-    let reject_handler = reject_handler.cloned();
-
-    let acc_vm = AccessibleVM::from_vm(vm);
-
-    let future = JsFuture::from(request_prom)
-        .and_then(move |val| {
-            let response = val
-                .dyn_into::<web_sys::Response>()
-                .expect("val to be of type Response");
-            response_format.get_response(&response)
-        })
-        .and_then(|prom| JsFuture::from(prom))
-        .then(move |val| {
-            let vm = &mut acc_vm
-                .upgrade()
-                .expect("that the VM *not* be destroyed while promise is being resolved");
-            match val {
-                Ok(val) => {
-                    let val = convert::js_to_py(vm, val);
-                    let args = PyFuncArgs::new(vec![val], vec![]);
-                    let _ = vm.invoke(handler, args);
-                }
-                Err(val) => {
-                    if let Some(reject_handler) = reject_handler {
-                        let val = convert::js_to_py(vm, val);
-                        let args = PyFuncArgs::new(vec![val], vec![]);
-                        let _ = vm.invoke(reject_handler, args);
-                    }
-                }
-            }
-            future::ok(JsValue::UNDEFINED)
-        });
-    future_to_promise(future);
-
-    Ok(vm.get_none())
-}
-
 pub fn setup_wasm_builtins(vm: &mut VirtualMachine, scope: &PyObjectRef) {
     let ctx = vm.context();
     ctx.set_attr(scope, "print", ctx.new_rustfunc(builtin_print_console));
-    ctx.set_attr(scope, "fetch", ctx.new_rustfunc(builtin_fetch));
 }