@tishlang/tish-format 1.0.12 → 2.0.1

package/crates/tish_eval/src/http.rs

@@ -0,0 +1,191 @@
+//! HTTP server for the Tish interpreter. Client `fetch` uses `tishlang_runtime` from eval.
+
+use crate::value::{PropMap, Value};
+use std::fs::File;
+use std::sync::Arc;
+
+use tokio::runtime::Runtime;
+
+thread_local! {
+    pub(crate) static RUNTIME: Runtime = tokio::runtime::Builder::new_multi_thread()
+        .worker_threads(4)
+        .enable_all()
+        .build()
+        .expect("Failed to create tokio runtime");
+}
+
+/// Create an HTTP server that listens on the given port.
+pub fn create_server(port: u16) -> Result<tiny_http::Server, String> {
+    let addr = format!("0.0.0.0:{}", port);
+    tiny_http::Server::http(&addr).map_err(|e| format!("Failed to start server: {}", e))
+}
+
+/// Convert a tiny_http::Request into a Tish Value object.
+pub fn request_to_value(request: &mut tiny_http::Request) -> Value {
+    let mut obj: PropMap = PropMap::with_capacity(6);
+
+    obj.insert(
+        Arc::from("method"),
+        Value::String(request.method().to_string().into()),
+    );
+    obj.insert(
+        Arc::from("url"),
+        Value::String(request.url().to_string().into()),
+    );
+
+    let path = request.url().split('?').next().unwrap_or("/");
+    obj.insert(Arc::from("path"), Value::String(path.into()));
+
+    let query_string = request.url().split('?').nth(1).unwrap_or("");
+    obj.insert(Arc::from("query"), Value::String(query_string.into()));
+
+    let mut headers_obj: PropMap = PropMap::with_capacity(request.headers().len());
+    for header in request.headers() {
+        headers_obj.insert(
+            Arc::from(header.field.as_str().as_str()),
+            Value::String(header.value.as_str().into()),
+        );
+    }
+    obj.insert(Arc::from("headers"), Value::object(headers_obj));
+
+    let mut body = String::new();
+    let _ = request.as_reader().read_to_string(&mut body);
+    obj.insert(Arc::from("body"), Value::String(body.into()));
+
+    Value::object(obj)
+}
+
+/// Extract response data from a Tish Value object.
+pub fn value_to_response(value: &Value) -> (u16, Vec<(String, String)>, String) {
+    let default_status = 200u16;
+    let default_body = String::new();
+
+    let (status, headers, body) = match value {
+        Value::Object(obj) => {
+            let obj_ref = obj.borrow();
+
+            let status = obj_ref
+                .strings
+                .get("status")
+                .and_then(|v| match v {
+                    Value::Number(n) => Some(*n as u16),
+                    _ => None,
+                })
+                .unwrap_or(default_status);
+
+            let body = obj_ref
+                .strings
+                .get("body")
+                .map(|v| v.to_string())
+                .unwrap_or_default();
+
+            let headers = obj_ref
+                .strings
+                .get("headers")
+                .and_then(|v| match v {
+                    Value::Object(h) => Some(
+                        h.borrow()
+                            .strings
+                            .iter()
+                            .map(|(k, v)| (k.to_string(), v.to_string()))
+                            .collect(),
+                    ),
+                    _ => None,
+                })
+                .unwrap_or_default();
+
+            (status, headers, body)
+        }
+        Value::String(s) => (default_status, vec![], s.to_string()),
+        _ => (default_status, vec![], default_body),
+    };
+
+    (status, headers, body)
+}
+
+/// `(status, headers, file path)` extracted from a response object's `file` key.
+type FileResponse = (u16, Vec<(String, String)>, String);
+
+/// If the response value has a `file` key, stream that path (binary-safe). Matches `tishlang_runtime` HTTP behavior.
+pub(crate) fn extract_file_from_response(
+    value: &Value,
+) -> Option<FileResponse> {
+    let Value::Object(obj) = value else {
+        return None;
+    };
+    let obj_ref = obj.borrow();
+    let file_val = obj_ref.strings.get("file")?;
+    let Value::String(file_path) = file_val else {
+        return None;
+    };
+    let file_path = file_path.to_string();
+    let status = obj_ref
+        .strings
+        .get("status")
+        .and_then(|v| match v {
+            Value::Number(n) => Some(*n as u16),
+            _ => None,
+        })
+        .unwrap_or(200);
+    let headers = obj_ref
+        .strings
+        .get("headers")
+        .and_then(|v| match v {
+            Value::Object(h) => Some(
+                h.borrow()
+                    .strings
+                    .iter()
+                    .map(|(k, v)| (k.to_string(), v.to_string()))
+                    .collect(),
+            ),
+            _ => None,
+        })
+        .unwrap_or_default();
+    Some((status, headers, file_path))
+}
+
+pub(crate) fn send_file_response(
+    request: tiny_http::Request,
+    status: u16,
+    headers: Vec<(String, String)>,
+    file_path: String,
+) {
+    let file = match File::open(&file_path) {
+        Ok(f) => f,
+        Err(e) => {
+            eprintln!("Failed to open file {}: {}", file_path, e);
+            let fallback =
+                tiny_http::Response::from_string(format!("File not found: {}", file_path))
+                    .with_status_code(tiny_http::StatusCode(500));
+            let _ = request.respond(fallback);
+            return;
+        }
+    };
+    let status_code = tiny_http::StatusCode(status);
+    let mut response = tiny_http::Response::from_file(file).with_status_code(status_code);
+    for (key, value) in headers {
+        if let Ok(header) = tiny_http::Header::from_bytes(key.as_bytes(), value.as_bytes()) {
+            response = response.with_header(header);
+        }
+    }
+    let _ = request.respond(response);
+}
+
+/// Send a response using tiny_http.
+pub fn send_response(
+    request: tiny_http::Request,
+    status: u16,
+    headers: Vec<(String, String)>,
+    body: String,
+) {
+    let status_code = tiny_http::StatusCode(status);
+    let mut response = tiny_http::Response::from_string(body).with_status_code(status_code);
+
+    for (key, value) in headers {
+        if let Ok(header) = tiny_http::Header::from_bytes(key.as_bytes(), value.as_bytes()) {
+            response = response.with_header(header);
+        }
+    }
+
+    let _ = request.respond(response);
+}

package/crates/tish_eval/src/lib.rs

@@ -0,0 +1,99 @@
+//! Tish tree-walk interpreter.
+
+mod eval;
+#[cfg(feature = "http")]
+mod http;
+mod natives;
+#[cfg(feature = "http")]
+mod promise;
+#[cfg(feature = "regex")]
+pub mod regex;
+#[cfg(feature = "timers")]
+mod timers;
+mod value;
+pub mod value_convert;
+
+pub use eval::Evaluator;
+pub use value::PropMap;
+pub use value::Value;
+
+/// Trait for pluggable native modules (e.g. Polars). Implement to register
+/// globals with the interpreter. Return a map of (global_name, Value).
+pub trait TishNativeModule: Send + Sync {
+    fn name(&self) -> &'static str;
+    fn register(&self) -> std::collections::HashMap<std::sync::Arc<str>, Value>;
+
+    /// Virtual `tish:*` modules for `import { x } from 'tish:…'` (e.g. `tish:polars`).
+    /// Return `(specifier, exports_object)` pairs. Default: none.
+    fn virtual_builtin_modules(&self) -> Vec<(&'static str, Value)> {
+        vec![]
+    }
+}
+#[cfg(feature = "regex")]
+pub use regex::TishRegExp;
+
+pub fn run(source: &str) -> Result<Value, String> {
+    let program = tishlang_parser::parse(source)?;
+    let mut eval = Evaluator::new();
+    let result = eval.eval_program(&program)?;
+    #[cfg(feature = "timers")]
+    eval.run_timer_phase()?;
+    Ok(result)
+}
+
+/// Run a Tish file with import/export support. Resolves relative imports from the file's directory.
+/// Format an interpreter value for console output (Node/Bun-style colors when `colors` is true).
+pub fn format_value_for_console(value: &Value, colors: bool) -> String {
+    match value_convert::eval_to_core(value) {
+        Ok(core_val) => tishlang_core::format_value_styled(&core_val, colors),
+        Err(_) => value.to_string(),
+    }
+}
+
+/// Run a Tish file with import/export support. Resolves relative imports from the file's directory.
+pub fn run_file(
+    path: &std::path::Path,
+    project_root: Option<&std::path::Path>,
+) -> Result<Value, String> {
+    let path = path
+        .canonicalize()
+        .map_err(|e| format!("Cannot canonicalize {}: {}", path.display(), e))?;
+    let source = std::fs::read_to_string(&path)
+        .map_err(|e| format!("Cannot read {}: {}", path.display(), e))?;
+    let program = tishlang_parser::parse(&source)?;
+    let mut eval = Evaluator::new();
+    eval.set_current_dir(project_root.or(path.parent()));
+    let result = eval.eval_program(&program)?;
+    #[cfg(feature = "timers")]
+    eval.run_timer_phase()?;
+    Ok(result)
+}
+
+#[cfg(test)]
+mod global_scope_tests {
+    use super::*;
+
+    #[test]
+    fn symbol_global_loads() {
+        let mut e = Evaluator::new();
+        let program = tishlang_parser::parse("Symbol").expect("parse");
+        let r = e.eval_program(&program);
+        assert!(
+            r.is_ok(),
+            "expected Symbol global, got {:?}",
+            r.as_ref().err()
+        );
+    }
+
+    #[test]
+    fn symbol_call_under_typeof_loads() {
+        let mut e = Evaluator::new();
+        let program = tishlang_parser::parse("typeof Symbol(\"z\")").expect("parse");
+        let r = e.eval_program(&program);
+        assert!(
+            r.is_ok(),
+            "expected Symbol global for typeof Symbol(\"z\"), got {:?}",
+            r.as_ref().err()
+        );
+    }
+}