@tishlang/tish-format 1.0.12 → 1.0.13

package/crates/tish_eval/src/http.rs

@@ -0,0 +1,188 @@
+//! 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)
+}
+
+/// 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<(u16, Vec<(String, String)>, String)> {
+    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()
+        );
+    }
+}

package/crates/tish_eval/src/natives.rs

@@ -0,0 +1,399 @@
+//! Native function implementations for the interpreter.
+
+use crate::value::Value;
+
+fn get_num(v: &Value) -> f64 {
+    match v {
+        Value::Number(n) => *n,
+        _ => f64::NAN,
+    }
+}
+
+pub fn console_debug(args: &[Value]) -> Result<Value, String> {
+    if get_log_level() == 0 {
+        let parts: Vec<String> = args.iter().map(|v| v.to_string()).collect();
+        println!("{}", parts.join(" "));
+    }
+    Ok(Value::Null)
+}
+
+pub fn console_info(args: &[Value]) -> Result<Value, String> {
+    if get_log_level() <= 1 {
+        let parts: Vec<String> = args.iter().map(|v| v.to_string()).collect();
+        println!("{}", parts.join(" "));
+    }
+    Ok(Value::Null)
+}
+
+pub fn console_log(args: &[Value]) -> Result<Value, String> {
+    if get_log_level() <= 2 {
+        let parts: Vec<String> = args.iter().map(|v| v.to_string()).collect();
+        println!("{}", parts.join(" "));
+    }
+    Ok(Value::Null)
+}
+
+pub fn console_warn(args: &[Value]) -> Result<Value, String> {
+    if get_log_level() <= 3 {
+        let parts: Vec<String> = args.iter().map(|v| v.to_string()).collect();
+        eprintln!("{}", parts.join(" "));
+    }
+    Ok(Value::Null)
+}
+
+pub fn console_error(args: &[Value]) -> Result<Value, String> {
+    let parts: Vec<String> = args.iter().map(|v| v.to_string()).collect();
+    eprintln!("{}", parts.join(" "));
+    Ok(Value::Null)
+}
+
+fn get_log_level() -> u8 {
+    std::env::var("TISH_LOG_LEVEL")
+        .ok()
+        .and_then(|s| s.parse().ok())
+        .unwrap_or(2)
+}
+
+pub fn parse_int(args: &[Value]) -> Result<Value, String> {
+    let s = args.first().map(|v| v.to_string()).unwrap_or_default();
+    let s = s.trim();
+    let radix = args
+        .get(1)
+        .and_then(|v| match v {
+            Value::Number(n) => Some(*n as i32),
+            _ => None,
+        })
+        .unwrap_or(10);
+    let n = if (2..=36).contains(&radix) {
+        let prefix: String = s
+            .chars()
+            .take_while(|c| *c == '-' || *c == '+' || c.is_digit(radix as u32))
+            .collect();
+        i64::from_str_radix(&prefix, radix as u32)
+            .ok()
+            .map(|n| n as f64)
+    } else {
+        None
+    };
+    Ok(Value::Number(n.unwrap_or(f64::NAN)))
+}
+
+pub fn parse_float(args: &[Value]) -> Result<Value, String> {
+    let s = args.first().map(|v| v.to_string()).unwrap_or_default();
+    let n: f64 = s.trim().parse().unwrap_or(f64::NAN);
+    Ok(Value::Number(n))
+}
+
+pub fn is_finite(args: &[Value]) -> Result<Value, String> {
+    let b = args
+        .first()
+        .is_some_and(|v| matches!(v, Value::Number(n) if n.is_finite()));
+    Ok(Value::Bool(b))
+}
+
+pub fn is_nan(args: &[Value]) -> Result<Value, String> {
+    let b = args.first().is_none_or(|v| {
+        matches!(v, Value::Number(n) if n.is_nan()) || !matches!(v, Value::Number(_))
+    });
+    Ok(Value::Bool(b))
+}
+
+pub fn boolean_native(args: &[Value]) -> Result<Value, String> {
+    let v = args.first().unwrap_or(&Value::Null);
+    Ok(Value::Bool(v.is_truthy()))
+}
+
+pub fn decode_uri(args: &[Value]) -> Result<Value, String> {
+    let s = args.first().map(|v| v.to_string()).unwrap_or_default();
+    Ok(Value::String(
+        tishlang_core::percent_decode(&s).unwrap_or(s).into(),
+    ))
+}
+
+pub fn encode_uri(args: &[Value]) -> Result<Value, String> {
+    let s = args.first().map(|v| v.to_string()).unwrap_or_default();
+    Ok(Value::String(tishlang_core::percent_encode(&s).into()))
+}
+
+pub fn html_escape(args: &[Value]) -> Result<Value, String> {
+    let input = match args.first() {
+        Some(Value::String(s)) => s.to_string(),
+        Some(v) => v.to_string(),
+        None => return Ok(Value::Null),
+    };
+    let bytes = input.as_bytes();
+    let mut extra = 0usize;
+    for b in bytes {
+        match b {
+            b'&' => extra += 4,
+            b'<' | b'>' => extra += 3,
+            b'"' => extra += 5,
+            b'\'' => extra += 4,
+            _ => {}
+        }
+    }
+    if extra == 0 {
+        return Ok(Value::String(input.into()));
+    }
+    let mut out = String::with_capacity(input.len() + extra);
+    let mut last = 0usize;
+    for (i, b) in bytes.iter().enumerate() {
+        let repl: Option<&'static str> = match b {
+            b'&' => Some("&amp;"),
+            b'<' => Some("&lt;"),
+            b'>' => Some("&gt;"),
+            b'"' => Some("&quot;"),
+            b'\'' => Some("&#39;"),
+            _ => None,
+        };
+        if let Some(r) = repl {
+            out.push_str(&input[last..i]);
+            out.push_str(r);
+            last = i + 1;
+        }
+    }
+    out.push_str(&input[last..]);
+    Ok(Value::String(out.into()))
+}
+
+pub fn math_abs(args: &[Value]) -> Result<Value, String> {
+    Ok(Value::Number(
+        get_num(args.first().unwrap_or(&Value::Null)).abs(),
+    ))
+}
+
+pub fn math_sqrt(args: &[Value]) -> Result<Value, String> {
+    Ok(Value::Number(
+        get_num(args.first().unwrap_or(&Value::Null)).sqrt(),
+    ))
+}
+
+pub fn math_min(args: &[Value]) -> Result<Value, String> {
+    let nums: Vec<f64> = args
+        .iter()
+        .filter_map(|v| match v {
+            Value::Number(n) => Some(*n),
+            _ => None,
+        })
+        .collect();
+    let n = nums.into_iter().fold(f64::INFINITY, f64::min);
+    Ok(Value::Number(if n == f64::INFINITY { f64::NAN } else { n }))
+}
+
+pub fn math_max(args: &[Value]) -> Result<Value, String> {
+    let nums: Vec<f64> = args
+        .iter()
+        .filter_map(|v| match v {
+            Value::Number(n) => Some(*n),
+            _ => None,
+        })
+        .collect();
+    let n = nums.into_iter().fold(f64::NEG_INFINITY, f64::max);
+    Ok(Value::Number(if n == f64::NEG_INFINITY {
+        f64::NAN
+    } else {
+        n
+    }))
+}
+
+pub fn math_floor(args: &[Value]) -> Result<Value, String> {
+    Ok(Value::Number(
+        get_num(args.first().unwrap_or(&Value::Null)).floor(),
+    ))
+}
+
+pub fn math_ceil(args: &[Value]) -> Result<Value, String> {
+    Ok(Value::Number(
+        get_num(args.first().unwrap_or(&Value::Null)).ceil(),
+    ))
+}
+
+pub fn math_round(args: &[Value]) -> Result<Value, String> {
+    Ok(Value::Number(
+        get_num(args.first().unwrap_or(&Value::Null)).round(),
+    ))
+}
+
+pub fn math_random(_args: &[Value]) -> Result<Value, String> {
+    use std::collections::hash_map::RandomState;
+    use std::hash::{BuildHasher, Hasher};
+    let random = RandomState::new().build_hasher().finish() as f64 / u64::MAX as f64;
+    Ok(Value::Number(random))
+}
+
+pub fn math_pow(args: &[Value]) -> Result<Value, String> {
+    let base = get_num(args.first().unwrap_or(&Value::Null));
+    let exp = get_num(args.get(1).unwrap_or(&Value::Null));
+    Ok(Value::Number(base.powf(exp)))
+}
+
+pub fn math_sin(args: &[Value]) -> Result<Value, String> {
+    Ok(Value::Number(
+        get_num(args.first().unwrap_or(&Value::Null)).sin(),
+    ))
+}
+
+pub fn math_cos(args: &[Value]) -> Result<Value, String> {
+    Ok(Value::Number(
+        get_num(args.first().unwrap_or(&Value::Null)).cos(),
+    ))
+}
+
+pub fn math_tan(args: &[Value]) -> Result<Value, String> {
+    Ok(Value::Number(
+        get_num(args.first().unwrap_or(&Value::Null)).tan(),
+    ))
+}
+
+pub fn math_log(args: &[Value]) -> Result<Value, String> {
+    Ok(Value::Number(
+        get_num(args.first().unwrap_or(&Value::Null)).ln(),
+    ))
+}
+
+pub fn math_exp(args: &[Value]) -> Result<Value, String> {
+    Ok(Value::Number(
+        get_num(args.first().unwrap_or(&Value::Null)).exp(),
+    ))
+}
+
+pub fn math_sign(args: &[Value]) -> Result<Value, String> {
+    let n = get_num(args.first().unwrap_or(&Value::Null));
+    let sign = if n.is_nan() {
+        f64::NAN
+    } else if n > 0.0 {
+        1.0
+    } else if n < 0.0 {
+        -1.0
+    } else {
+        0.0
+    };
+    Ok(Value::Number(sign))
+}
+
+pub fn math_trunc(args: &[Value]) -> Result<Value, String> {
+    Ok(Value::Number(
+        get_num(args.first().unwrap_or(&Value::Null)).trunc(),
+    ))
+}
+
+pub fn date_now(_args: &[Value]) -> Result<Value, String> {
+    use std::time::{SystemTime, UNIX_EPOCH};
+    let ms = SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .map(|d| d.as_millis() as f64)
+        .unwrap_or(0.0);
+    Ok(Value::Number(ms))
+}
+
+pub fn array_is_array(args: &[Value]) -> Result<Value, String> {
+    Ok(Value::Bool(matches!(args.first(), Some(Value::Array(_)))))
+}
+
+pub fn string_from_char_code(args: &[Value]) -> Result<Value, String> {
+    let s: String = args
+        .iter()
+        .filter_map(|v| match v {
+            Value::Number(n) => Some(char::from_u32(*n as u32).unwrap_or('\u{FFFD}')),
+            _ => None,
+        })
+        .collect();
+    Ok(Value::String(s.into()))
+}
+
+#[cfg(feature = "process")]
+pub fn process_exit(args: &[Value]) -> Result<Value, String> {
+    let code = args
+        .first()
+        .and_then(|v| match v {
+            Value::Number(n) => Some(*n as i32),
+            _ => None,
+        })
+        .unwrap_or(0);
+    std::process::exit(code);
+}
+
+#[cfg(feature = "process")]
+pub fn process_cwd(_args: &[Value]) -> Result<Value, String> {
+    let cwd = std::env::current_dir()
+        .map(|p| p.to_string_lossy().into_owned())
+        .unwrap_or_default();
+    Ok(Value::String(cwd.into()))
+}
+
+#[cfg(feature = "process")]
+pub fn process_exec(args: &[Value]) -> Result<Value, String> {
+    use std::process::Command;
+    let cmd = args.first().map(|v| v.to_string()).unwrap_or_default();
+    if cmd.is_empty() {
+        return Ok(Value::Number(0.0));
+    }
+    let output = Command::new("sh")
+        .arg("-c")
+        .arg(&cmd)
+        .output()
+        .map_err(|e| format!("exec failed: {}", e))?;
+    let code = output.status.code().unwrap_or(1);
+    Ok(Value::Number(code as f64))
+}
+
+#[cfg(feature = "fs")]
+pub fn read_file(args: &[Value]) -> Result<Value, String> {
+    let path = args.first().map(|v| v.to_string()).unwrap_or_default();
+    match std::fs::read_to_string(&path) {
+        Ok(content) => Ok(Value::String(content.into())),
+        Err(e) => Ok(Value::String(format!("Error: {}", e).into())),
+    }
+}
+
+#[cfg(feature = "fs")]
+pub fn write_file(args: &[Value]) -> Result<Value, String> {
+    let path = args.first().map(|v| v.to_string()).unwrap_or_default();
+    let content = args.get(1).map(|v| v.to_string()).unwrap_or_default();
+    match std::fs::write(&path, content) {
+        Ok(_) => Ok(Value::Bool(true)),
+        Err(_) => Ok(Value::Bool(false)),
+    }
+}
+
+#[cfg(feature = "fs")]
+pub fn file_exists(args: &[Value]) -> Result<Value, String> {
+    let path = args.first().map(|v| v.to_string()).unwrap_or_default();
+    Ok(Value::Bool(std::path::Path::new(&path).exists()))
+}
+
+#[cfg(feature = "fs")]
+pub fn is_dir(args: &[Value]) -> Result<Value, String> {
+    let path = args.first().map(|v| v.to_string()).unwrap_or_default();
+    Ok(Value::Bool(std::path::Path::new(&path).is_dir()))
+}
+
+#[cfg(feature = "fs")]
+pub fn read_dir(args: &[Value]) -> Result<Value, String> {
+    use std::cell::RefCell;
+    use std::rc::Rc;
+
+    let path = args.first().map(|v| v.to_string()).unwrap_or_default();
+    match std::fs::read_dir(&path) {
+        Ok(entries) => {
+            let items: Vec<Value> = entries
+                .filter_map(|e| e.ok())
+                .map(|e| Value::String(e.file_name().to_string_lossy().into()))
+                .collect();
+            Ok(Value::Array(Rc::new(RefCell::new(items))))
+        }
+        Err(_) => Ok(Value::Array(Rc::new(RefCell::new(Vec::new())))),
+    }
+}
+
+#[cfg(feature = "fs")]
+pub fn mkdir(args: &[Value]) -> Result<Value, String> {
+    let path = args.first().map(|v| v.to_string()).unwrap_or_default();
+    let recursive = args.get(1).map(|v| v.is_truthy()).unwrap_or(false);
+    let result = if recursive {
+        std::fs::create_dir_all(&path)
+    } else {
+        std::fs::create_dir(&path)
+    };
+    Ok(Value::Bool(result.is_ok()))
+}