@tishlang/tish 1.0.6 → 1.0.10

package/crates/tish_runtime/tests/fetch_readable_stream.rs

@@ -0,0 +1,99 @@
+//! ReadableStream + reader.read() chunk boundaries over local HTTP.
+#![cfg(feature = "http")]
+
+use std::io::{Read, Write};
+use std::net::TcpListener;
+use std::thread;
+use std::time::Duration;
+
+use tish_core::Value;
+use tish_runtime::{await_promise, fetch_promise};
+
+fn chunked_body_server(listener: TcpListener) {
+    let (mut stream, _) = listener.accept().expect("accept");
+    let _ = stream.set_read_timeout(Some(Duration::from_secs(2)));
+    let mut buf = vec![0u8; 512];
+    let _ = stream.read(&mut buf);
+
+    let _ = stream.write_all(b"HTTP/1.1 200 OK\r\nTransfer-Encoding: chunked\r\n\r\n");
+    let _ = stream.write_all(b"3\r\nabc\r\n");
+    let _ = stream.flush();
+    thread::sleep(Duration::from_millis(40));
+    let _ = stream.write_all(b"3\r\ndef\r\n0\r\n\r\n");
+    let _ = stream.flush();
+}
+
+fn byte_array_to_vec(v: &Value) -> Vec<u8> {
+    match v {
+        Value::Array(a) => a
+            .borrow()
+            .iter()
+            .filter_map(|x| match x {
+                Value::Number(n) => Some(*n as u8),
+                _ => None,
+            })
+            .collect(),
+        _ => vec![],
+    }
+}
+
+#[test]
+fn fetch_readable_stream_read_chunks() {
+    let listener = TcpListener::bind("127.0.0.1:0").expect("bind");
+    let port = listener.local_addr().unwrap().port();
+    let th = thread::spawn(move || chunked_body_server(listener));
+
+    let url = format!("http://127.0.0.1:{}/c", port);
+    let prom = fetch_promise(vec![Value::String(url.into())]);
+    let resp = await_promise(prom);
+
+    let obj = match &resp {
+        Value::Object(o) => o.borrow(),
+        _ => panic!("expected object response, got {:?}", resp),
+    };
+    assert!(obj.get(&std::sync::Arc::from("ok")).map(|v| matches!(v, Value::Bool(true))).unwrap_or(false));
+
+    let body = obj.get(&std::sync::Arc::from("body")).expect("body");
+    let stream = match body {
+        Value::Opaque(s) => s.as_ref(),
+        _ => panic!("expected ReadableStream opaque"),
+    };
+    let reader_val = stream
+        .get_method("getReader")
+        .expect("getReader")(&[]);
+    let reader = match reader_val {
+        Value::Opaque(r) => r,
+        _ => panic!("expected reader opaque, got {:?}", reader_val),
+    };
+
+    let mut acc = Vec::new();
+    loop {
+        let read_p = reader.get_method("read").expect("read")(&[]);
+        let chunk = await_promise(read_p);
+        let (done, chunk_bytes) = match chunk {
+            Value::Object(o) => {
+                let m = o.borrow();
+                let done = m
+                    .get(&std::sync::Arc::from("done"))
+                    .and_then(|v| match v {
+                        Value::Bool(b) => Some(*b),
+                        _ => None,
+                    })
+                    .unwrap_or(true);
+                let bytes = m
+                    .get(&std::sync::Arc::from("value"))
+                    .map(|v| byte_array_to_vec(v))
+                    .unwrap_or_default();
+                (done, bytes)
+            }
+            _ => panic!("expected read result object"),
+        };
+        if done {
+            break;
+        }
+        acc.extend(chunk_bytes);
+    }
+
+    th.join().expect("server");
+    assert_eq!(acc, b"abcdef");
+}

package/crates/tish_vm/Cargo.toml

@@ -0,0 +1,31 @@
+[package]
+name = "tish_vm"
+version = "0.1.0"
+edition = "2021"
+description = "Bytecode VM for Tish"
+
+[features]
+default = []
+regex = ["tish_core/regex"]
+# For wasm32 target: use web_sys console for output
+wasm = ["dep:wasm-bindgen"]
+# Built-in modules: fs, http, process (for bytecode LoadNativeExport)
+fs = ["tish_runtime/fs"]
+process = ["tish_runtime/process"]
+http = ["tish_runtime/http"]
+ws = ["tish_runtime/ws"]
+
+[dependencies]
+tish_ast = { path = "../tish_ast" }
+tish_builtins = { path = "../tish_builtins" }
+tish_bytecode = { path = "../tish_bytecode" }
+tish_core = { path = "../tish_core" }
+tish_runtime = { path = "../tish_runtime", optional = true }
+rand = "0.10"
+wasm-bindgen = { version = "0.2", optional = true }
+
+[dev-dependencies]
+tish_parser = { path = "../tish_parser" }
+
+[target.'cfg(target_arch = "wasm32")'.dependencies]
+getrandom = { version = "0.4", features = ["wasm_js"] }

package/crates/tish_vm/src/lib.rs

@@ -0,0 +1,39 @@
+//! Bytecode VM for Tish execution.
+
+mod vm;
+
+pub use vm::{run, Vm};
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn bytecode_for_of_break_continue_switch_try() {
+        let src = r#"
+let sum = 0;
+for (let x of [1, 2, 3]) { sum = sum + x; }
+console.log(sum);
+let n = 0;
+do { n = n + 1; } while (n < 3);
+console.log(n);
+const k = 2;
+switch (k) {
+  case 1: console.log(1); break;
+  case 2: console.log(2); break;
+  default: console.log(0);
+}
+        try { throw "ok"; } catch (e) { console.log(e); }
+        let x = 10;
+        x++;
+        ++x;
+        x += 3;
+        console.log(x);
+        fn f(a, b, ...rest) { return rest.length; }
+        console.log(f(1,2,3,4));
+"#;
+        let program = tish_parser::parse(src).expect("parse");
+        let chunk = tish_bytecode::compile(&program).expect("compile");
+        let _ = run(&chunk).expect("run");
+    }
+}