Add convenience functions

Author: coolreader18

vm/src/lib.rs

@@ -53,9 +53,9 @@ mod frozen;
 pub mod function;
 pub mod import;
 pub mod obj;
+pub mod py_serde;
 mod pyhash;
 pub mod pyobject;
-pub mod ser_de;
 pub mod stdlib;
 mod sysmodule;
 mod traceback;

vm/src/ser_de.rs renamed to vm/src/py_serde.rs

@@ -1,8 +1,8 @@
 use std::fmt;
 
 use serde;
-use serde::de::Visitor;
-use serde::ser::{SerializeMap, SerializeSeq};
+use serde::de::{DeserializeSeed, Visitor};
+use serde::ser::{Serialize, SerializeMap, SerializeSeq};
 
 use crate::obj::{
     objbool,
@@ -15,6 +15,29 @@ use crate::pyobject::{IdProtocol, ItemProtocol, PyObjectRef, TypeProtocol};
 use crate::VirtualMachine;
 use num_traits::cast::ToPrimitive;
 
+#[inline]
+pub fn serialize<S>(
+    vm: &VirtualMachine,
+    pyobject: &PyObjectRef,
+    serializer: S,
+) -> Result<S::Ok, S::Error>
+where
+    S: serde::Serializer,
+{
+    PyObjectSerializer { vm, pyobject }.serialize(serializer)
+}
+
+#[inline]
+pub fn deserialize<'de, D>(
+    vm: &'de VirtualMachine,
+    deserializer: D,
+) -> Result<<PyObjectDeserializer as DeserializeSeed>::Value, D::Error>
+where
+    D: serde::Deserializer<'de>,
+{
+    PyObjectDeserializer { vm }.deserialize(deserializer)
+}
+
 // We need to have a VM available to serialise a PyObject based on its subclass, so we implement
 // PyObject serialisation via a proxy object which holds a reference to a VM
 pub struct PyObjectSerializer<'s> {
@@ -24,7 +47,7 @@ pub struct PyObjectSerializer<'s> {
 
 impl<'s> PyObjectSerializer<'s> {
     pub fn new(vm: &'s VirtualMachine, pyobject: &'s PyObjectRef) -> Self {
-        PyObjectSerializer { pyobject, vm }
+        PyObjectSerializer { vm, pyobject }
     }
 
     fn clone_with_object(&self, pyobject: &'s PyObjectRef) -> PyObjectSerializer {
@@ -97,7 +120,7 @@ impl<'c> PyObjectDeserializer<'c> {
     }
 }
 
-impl<'de> serde::de::DeserializeSeed<'de> for PyObjectDeserializer<'de> {
+impl<'de> DeserializeSeed<'de> for PyObjectDeserializer<'de> {
     type Value = PyObjectRef;
 
     fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>

vm/src/stdlib/json.rs

@@ -1,39 +1,36 @@
 use crate::obj::objstr::PyStringRef;
+use crate::py_serde;
 use crate::pyobject::{create_type, ItemProtocol, PyObjectRef, PyResult};
-use crate::ser_de::{PyObjectDeserializer, PyObjectSerializer};
 use crate::VirtualMachine;
-use serde::de::DeserializeSeed;
 use serde_json;
 
 /// Implement json.dumps
 pub fn json_dumps(obj: PyObjectRef, vm: &VirtualMachine) -> PyResult<String> {
-    let serializer = PyObjectSerializer::new(vm, &obj);
+    let serializer = py_serde::PyObjectSerializer::new(vm, &obj);
     serde_json::to_string(&serializer).map_err(|err| vm.new_type_error(err.to_string()))
 }
 
 /// Implement json.loads
 pub fn json_loads(string: PyStringRef, vm: &VirtualMachine) -> PyResult {
     // TODO: Implement non-trivial deserialization case
+    let de_result =
+        py_serde::deserialize(vm, &mut serde_json::Deserializer::from_str(string.as_str()));
 
-    let de = PyObjectDeserializer::new(vm);
-
-    // TODO: Support deserializing string sub-classes
-    de.deserialize(&mut serde_json::Deserializer::from_str(string.as_str()))
-        .map_err(|err| {
-            let module = vm
-                .get_attribute(vm.sys_module.clone(), "modules")
-                .unwrap()
-                .get_item("json", vm)
-                .unwrap();
-            let json_decode_error = vm.get_attribute(module, "JSONDecodeError").unwrap();
-            let json_decode_error = json_decode_error.downcast().unwrap();
-            let exc = vm.new_exception(json_decode_error, format!("{}", err));
-            vm.set_attr(&exc, "lineno", vm.ctx.new_int(err.line()))
-                .unwrap();
-            vm.set_attr(&exc, "colno", vm.ctx.new_int(err.column()))
-                .unwrap();
-            exc
-        })
+    de_result.map_err(|err| {
+        let module = vm
+            .get_attribute(vm.sys_module.clone(), "modules")
+            .unwrap()
+            .get_item("json", vm)
+            .unwrap();
+        let json_decode_error = vm.get_attribute(module, "JSONDecodeError").unwrap();
+        let json_decode_error = json_decode_error.downcast().unwrap();
+        let exc = vm.new_exception(json_decode_error, format!("{}", err));
+        vm.set_attr(&exc, "lineno", vm.ctx.new_int(err.line()))
+            .unwrap();
+        vm.set_attr(&exc, "colno", vm.ctx.new_int(err.column()))
+            .unwrap();
+        exc
+    })
 }
 
 pub fn make_module(vm: &VirtualMachine) -> PyObjectRef {

wasm/lib/src/convert.rs

@@ -1,11 +1,11 @@
 use js_sys::{Array, ArrayBuffer, Object, Promise, Reflect, Uint8Array};
 use num_traits::cast::ToPrimitive;
-use serde::{de::DeserializeSeed, ser::Serialize};
 use serde_wasm_bindgen;
 use wasm_bindgen::{closure::Closure, prelude::*, JsCast};
 
 use rustpython_vm::function::PyFuncArgs;
 use rustpython_vm::obj::{objbytes, objint, objsequence, objtype};
+use rustpython_vm::py_serde;
 use rustpython_vm::pyobject::{ItemProtocol, PyObjectRef, PyResult, PyValue};
 use rustpython_vm::VirtualMachine;
 
@@ -132,8 +132,7 @@ pub fn py_to_js(vm: &VirtualMachine, py_obj: PyObjectRef) -> JsValue {
             view.slice(0, bytes.len() as u32).into()
         }
     } else {
-        rustpython_vm::ser_de::PyObjectSerializer::new(vm, &py_obj)
-            .serialize(&serde_wasm_bindgen::Serializer::new())
+        py_serde::serialize(vm, &py_obj, &serde_wasm_bindgen::Serializer::new())
             .unwrap_or(JsValue::UNDEFINED)
     }
 }
@@ -225,8 +224,7 @@ pub fn js_to_py(vm: &VirtualMachine, js_val: JsValue) -> PyObjectRef {
         // Because `JSON.stringify(undefined)` returns undefined
         vm.get_none()
     } else {
-        rustpython_vm::ser_de::PyObjectDeserializer::new(vm)
-            .deserialize(serde_wasm_bindgen::Deserializer::from(js_val))
+        py_serde::deserialize(vm, serde_wasm_bindgen::Deserializer::from(js_val))
             .unwrap_or_else(|_| vm.get_none())
     }
 }