Merge branch 'master' into wasm-vm-exec_single

Author: coolreader18

tests/snippets/mro.py

@@ -18,3 +18,5 @@ class C(A, B):
     pass
 
 assert (C, A, B, X, Y, object) == C.__mro__
+
+assert type.__mro__ == (type, object)

vm/src/obj/objproperty.rs

@@ -119,7 +119,7 @@ impl<'a, T> PropertyBuilder<'a, T> {
         }
     }
 
-    pub fn add_setter<I, F: IntoPyNativeFunc<(I, T), PyResult>>(self, func: F) -> Self {
+    pub fn add_setter<I, V, F: IntoPyNativeFunc<(I, V), PyResult>>(self, func: F) -> Self {
         let func = self.ctx.new_rustfunc(func);
         Self {
             ctx: self.ctx,

vm/src/obj/objtype.rs

@@ -9,6 +9,7 @@ use crate::vm::VirtualMachine;
 
 use super::objdict;
 use super::objlist::PyList;
+use super::objproperty::PropertyBuilder;
 use super::objstr::{self, PyStringRef};
 use super::objtuple::PyTuple;
 
@@ -78,6 +79,10 @@ impl PyClassRef {
         PyTuple::from(elements)
     }
 
+    fn set_mro(self, _value: PyObjectRef, vm: &mut VirtualMachine) -> PyResult {
+        Err(vm.new_attribute_error("read-only attribute".to_string()))
+    }
+
     fn dir(self, vm: &mut VirtualMachine) -> PyList {
         let attributes = get_attributes(self);
         let attributes: Vec<PyObjectRef> = attributes
@@ -116,7 +121,11 @@ pub fn init(ctx: &PyContext) {
     extend_class!(&ctx, &ctx.type_type, {
         "__call__" => ctx.new_rustfunc(type_call),
         "__new__" => ctx.new_rustfunc(type_new),
-        "__mro__" => ctx.new_property(PyClassRef::mro),
+        "__mro__" =>
+            PropertyBuilder::new(ctx)
+                .add_getter(PyClassRef::mro)
+                .add_setter(PyClassRef::set_mro)
+                .create(),
         "__repr__" => ctx.new_rustfunc(PyClassRef::repr),
         "__prepare__" => ctx.new_rustfunc(PyClassRef::prepare),
         "__getattribute__" => ctx.new_rustfunc(type_getattribute),

wasm/demo/src/main.js

@@ -36,7 +36,15 @@ function runCodeFromTextarea() {
     const code = editor.getValue();
     try {
         const result = rp.pyEval(code, {
-            stdout: '#console'
+            stdout: output => {
+                const shouldScroll =
+                    consoleElement.scrollHeight - consoleElement.scrollTop ===
+                    consoleElement.clientHeight;
+                consoleElement.value += output;
+                if (shouldScroll) {
+                    consoleElement.scrollTop = consoleElement.scrollHeight;
+                }
+            }
         });
         if (result !== null) {
             consoleElement.value += `\n${result}\n`;

wasm/lib/Cargo.toml

@@ -26,7 +26,6 @@ features = [
     "console",
     "Document",
     "Element",
-    "HtmlTextAreaElement",
     "Window",
     "Headers",
     "Request",

wasm/lib/src/vm_class.rs

@@ -11,7 +11,7 @@ use rustpython_vm::{
 use std::cell::RefCell;
 use std::collections::HashMap;
 use std::rc::{Rc, Weak};
-use wasm_bindgen::prelude::*;
+use wasm_bindgen::{prelude::*, JsCast};
 
 pub trait HeldRcInner {}
 
@@ -266,13 +266,15 @@ impl WASMVirtualMachine {
     #[wasm_bindgen(js_name = setStdout)]
     pub fn set_stdout(&self, stdout: JsValue) -> Result<(), JsValue> {
         self.with(move |StoredVirtualMachine { ref mut vm, .. }| {
+            fn error() -> JsValue {
+                TypeError::new("Unknown stdout option, please pass a function or 'console'").into()
+            }
             let print_fn: Box<Fn(&mut VirtualMachine, PyFuncArgs) -> PyResult> =
-                if let Some(selector) = stdout.as_string() {
-                    Box::new(
-                        move |vm: &mut VirtualMachine, args: PyFuncArgs| -> PyResult {
-                            wasm_builtins::builtin_print_html(vm, args, &selector)
-                        },
-                    )
+                if let Some(s) = stdout.as_string() {
+                    match s.as_str() {
+                        "console" => Box::new(wasm_builtins::builtin_print_console),
+                        _ => return Err(error()),
+                    }
                 } else if stdout.is_function() {
                     let func = js_sys::Function::from(stdout);
                     Box::new(
@@ -286,11 +288,12 @@ impl WASMVirtualMachine {
                         },
                     )
                 } else if stdout.is_undefined() || stdout.is_null() {
-                    Box::new(wasm_builtins::builtin_print_console)
+                    fn noop(vm: &mut VirtualMachine, _args: PyFuncArgs) -> PyResult {
+                        Ok(vm.get_none())
+                    }
+                    Box::new(noop)
                 } else {
-                    return Err(
-                        TypeError::new("stdout must be null, a function or a css selector").into(),
-                    );
+                    return Err(error());
                 };
             let rustfunc = vm.ctx.new_rustfunc(print_fn);
             vm.ctx.set_attr(&vm.builtins, "print", rustfunc);

wasm/lib/src/wasm_builtins.rs

@@ -4,43 +4,16 @@
 //! desktop.
 //! Implements functions listed here: https://docs.python.org/3/library/builtins.html.
 
-use crate::convert;
 use js_sys::{self, 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 web_sys::{self, console, HtmlTextAreaElement};
+use web_sys::{self, console};
 
 pub(crate) fn window() -> web_sys::Window {
     web_sys::window().expect("Window to be available")
 }
 
-// The HTML id of the textarea element that act as our STDOUT
-
-pub fn print_to_html(text: &str, selector: &str) -> Result<(), JsValue> {
-    let document = window().document().expect("Document to be available");
-    let element = document
-        .query_selector(selector)?
-        .ok_or_else(|| js_sys::TypeError::new("Couldn't get element"))?;
-    let textarea = element
-        .dyn_ref::<HtmlTextAreaElement>()
-        .ok_or_else(|| js_sys::TypeError::new("Element must be a textarea"))?;
-
-    let value = textarea.value();
-
-    let scroll_height = textarea.scroll_height();
-    let scrolled_to_bottom = scroll_height - textarea.scroll_top() == textarea.client_height();
-
-    textarea.set_value(&format!("{}{}", value, text));
-
-    if scrolled_to_bottom {
-        textarea.scroll_with_x_and_y(0.0, scroll_height.into());
-    }
-
-    Ok(())
-}
-
 pub fn format_print_args(vm: &mut VirtualMachine, args: PyFuncArgs) -> Result<String, PyObjectRef> {
     // Handle 'sep' kwarg:
     let sep_arg = args
@@ -93,12 +66,6 @@ pub fn format_print_args(vm: &mut VirtualMachine, args: PyFuncArgs) -> Result<St
     Ok(output)
 }
 
-pub fn builtin_print_html(vm: &mut VirtualMachine, args: PyFuncArgs, selector: &str) -> PyResult {
-    let output = format_print_args(vm, args)?;
-    print_to_html(&output, selector).map_err(|err| convert::js_to_py(vm, err))?;
-    Ok(vm.get_none())
-}
-
 pub fn builtin_print_console(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
     let arr = Array::new();
     for arg in args.args {