@tishlang/tish 1.0.7 → 1.0.11

package/crates/tish_eval/src/regex.rs

@@ -0,0 +1,298 @@
+//! JavaScript-compatible regular expression support for Tish.
+//!
+//! Re-exports core types from tish_core and provides interpreter-specific functionality.
+
+use std::cell::RefCell;
+use std::collections::HashMap;
+use std::rc::Rc;
+use std::sync::Arc;
+
+pub use tish_core::{RegExpFlags, TishRegExp};
+
+use crate::value::Value;
+
+/// RegExp.prototype.exec(string) - returns match object (array-like with index) or null
+pub fn regexp_exec(re: &mut TishRegExp, input: &str) -> Value {
+    let start = if re.flags.global || re.flags.sticky {
+        re.last_index
+    } else {
+        0
+    };
+
+    let char_count = input.chars().count();
+    if start > char_count {
+        if re.flags.global || re.flags.sticky {
+            re.last_index = 0;
+        }
+        return Value::Null;
+    }
+
+    let byte_start: usize = input.chars().take(start).map(|c| c.len_utf8()).sum();
+    let search_str = &input[byte_start..];
+
+    match re.regex.captures(search_str) {
+        Ok(Some(caps)) => {
+            let full_match = caps.get(0).unwrap();
+
+            if re.flags.sticky && full_match.start() != 0 {
+                re.last_index = 0;
+                return Value::Null;
+            }
+
+            let match_byte_start = byte_start + full_match.start();
+            let match_char_index = input[..match_byte_start].chars().count();
+
+            let mut obj: HashMap<Arc<str>, Value> = HashMap::new();
+            obj.insert(Arc::from("0"), Value::String(full_match.as_str().into()));
+            for i in 1..caps.len() {
+                let val = match caps.get(i) {
+                    Some(m) => Value::String(m.as_str().into()),
+                    None => Value::Null,
+                };
+                obj.insert(Arc::from(i.to_string().as_str()), val);
+            }
+            obj.insert(Arc::from("index"), Value::Number(match_char_index as f64));
+
+            if re.flags.global || re.flags.sticky {
+                let match_end_chars = input[..byte_start + full_match.end()].chars().count();
+                re.last_index = if full_match.start() == full_match.end() {
+                    match_end_chars + 1
+                } else {
+                    match_end_chars
+                };
+            }
+
+            Value::Object(Rc::new(RefCell::new(obj)))
+        }
+        Ok(None) | Err(_) => {
+            if re.flags.global || re.flags.sticky {
+                re.last_index = 0;
+            }
+            Value::Null
+        }
+    }
+}
+
+/// Create a RegExp Value from pattern and flags
+pub fn create_regexp(pattern: &str, flags: &str) -> Result<Value, String> {
+    let re = TishRegExp::new(pattern, flags)?;
+    Ok(Value::RegExp(Rc::new(RefCell::new(re))))
+}
+
+/// RegExp constructor function - handles `new RegExp(pattern, flags)` or `RegExp(pattern, flags)`
+pub fn regexp_constructor(args: &[Value]) -> Result<Value, String> {
+    let pattern = match args.first() {
+        Some(Value::String(s)) => s.to_string(),
+        Some(Value::RegExp(re)) => {
+            if args.get(1).is_none() {
+                let re = re.borrow();
+                return create_regexp(&re.source, &re.flags_string());
+            }
+            re.borrow().source.clone()
+        }
+        Some(v) => v.to_string(),
+        None => String::new(),
+    };
+
+    let flags = match args.get(1) {
+        Some(Value::String(s)) => s.to_string(),
+        Some(Value::Null) | None => String::new(),
+        Some(v) => v.to_string(),
+    };
+
+    create_regexp(&pattern, &flags)
+}
+
+// ============== String methods with regex support ==============
+
+/// String.prototype.match(regexp) - returns array of matches or null
+pub fn string_match(input: &str, regexp: &Value) -> Value {
+    match regexp {
+        Value::RegExp(re) => {
+            let mut re = re.borrow_mut();
+
+            if re.flags.global {
+                let mut matches = Vec::new();
+                re.last_index = 0;
+
+                while let Ok(Some(m)) = re.regex.find_from_pos(input, re.last_index) {
+                    matches.push(Value::String(m.as_str().into()));
+                    if m.start() == m.end() {
+                        re.last_index = m.end() + 1;
+                    } else {
+                        re.last_index = m.end();
+                    }
+                    if re.last_index > input.len() {
+                        break;
+                    }
+                }
+
+                re.last_index = 0;
+
+                if matches.is_empty() {
+                    Value::Null
+                } else {
+                    Value::Array(Rc::new(RefCell::new(matches)))
+                }
+            } else {
+                regexp_exec(&mut re, input)
+            }
+        }
+        Value::String(pattern) => match TishRegExp::new(pattern, "") {
+            Ok(mut re) => regexp_exec(&mut re, input),
+            Err(_) => Value::Null,
+        },
+        _ => Value::Null,
+    }
+}
+
+/// String.prototype.replace(searchValue, replaceValue)
+pub fn string_replace(input: &str, search: &Value, replace: &Value) -> Value {
+    let replacement = match replace {
+        Value::String(s) => s.to_string(),
+        v => v.to_string(),
+    };
+
+    match search {
+        Value::RegExp(re) => {
+            let re = re.borrow();
+            if re.flags.global {
+                match re.regex.replace_all(input, replacement.as_str()) {
+                    std::borrow::Cow::Borrowed(s) => Value::String(s.into()),
+                    std::borrow::Cow::Owned(s) => Value::String(s.into()),
+                }
+            } else {
+                match re.regex.replace(input, replacement.as_str()) {
+                    std::borrow::Cow::Borrowed(s) => Value::String(s.into()),
+                    std::borrow::Cow::Owned(s) => Value::String(s.into()),
+                }
+            }
+        }
+        Value::String(pattern) => {
+            Value::String(input.replacen(pattern.as_ref(), &replacement, 1).into())
+        }
+        _ => Value::String(input.into()),
+    }
+}
+
+/// Replace regex matches using a callback. Callback receives (match, g1, g2, ..., index, fullString).
+pub fn string_replace_regex_with_fn<F>(
+    input: &str,
+    re: &TishRegExp,
+    invoke: &mut F,
+) -> Result<Value, String>
+where
+    F: FnMut(&[Value]) -> Result<String, String>,
+{
+    let limit = if re.flags.global { usize::MAX } else { 1 };
+    let mut result = String::new();
+    let mut last_end: usize = 0;
+    for (count, cap_result) in re.regex.captures_iter(input).enumerate() {
+        if count >= limit {
+            break;
+        }
+        let caps = cap_result.map_err(|e| format!("Regex error: {}", e))?;
+        let full = caps.get(0).unwrap();
+        let match_str = full.as_str();
+        let byte_start = full.start();
+        let char_index = input[..byte_start].chars().count();
+
+        let mut args = vec![Value::String(match_str.into())];
+        for i in 1..caps.len() {
+            let val = match caps.get(i) {
+                Some(m) => Value::String(m.as_str().into()),
+                None => Value::Null,
+            };
+            args.push(val);
+        }
+        args.push(Value::Number(char_index as f64));
+        args.push(Value::String(input.into()));
+
+        let repl = invoke(&args)?;
+        result.push_str(&input[last_end..byte_start]);
+        result.push_str(&repl);
+        last_end = full.end();
+    }
+
+    result.push_str(&input[last_end..]);
+    Ok(Value::String(result.into()))
+}
+
+/// String.prototype.search(regexp) - returns index of first match or -1
+pub fn string_search(input: &str, regexp: &Value) -> Value {
+    match regexp {
+        Value::RegExp(re) => {
+            let re = re.borrow();
+            match re.regex.find(input) {
+                Ok(Some(m)) => {
+                    let char_index = input[..m.start()].chars().count();
+                    Value::Number(char_index as f64)
+                }
+                _ => Value::Number(-1.0),
+            }
+        }
+        Value::String(pattern) => match TishRegExp::new(pattern, "") {
+            Ok(re) => match re.regex.find(input) {
+                Ok(Some(m)) => {
+                    let char_index = input[..m.start()].chars().count();
+                    Value::Number(char_index as f64)
+                }
+                _ => Value::Number(-1.0),
+            },
+            Err(_) => Value::Number(-1.0),
+        },
+        _ => Value::Number(-1.0),
+    }
+}
+
+/// String.prototype.split(separator, limit) - split string by regex or string
+pub fn string_split(input: &str, separator: &Value, limit: Option<usize>) -> Value {
+    let max = limit.unwrap_or(usize::MAX);
+
+    if max == 0 {
+        return Value::Array(Rc::new(RefCell::new(Vec::new())));
+    }
+
+    match separator {
+        Value::RegExp(re) => {
+            let re = re.borrow();
+            let mut result = Vec::new();
+            let mut last_end = 0;
+
+            for mat in re.regex.find_iter(input) {
+                match mat {
+                    Ok(m) => {
+                        if result.len() >= max - 1 {
+                            break;
+                        }
+                        result.push(Value::String(input[last_end..m.start()].into()));
+                        last_end = m.end();
+                    }
+                    Err(_) => break,
+                }
+            }
+
+            if result.len() < max {
+                result.push(Value::String(input[last_end..].into()));
+            }
+
+            Value::Array(Rc::new(RefCell::new(result)))
+        }
+        Value::String(sep) => {
+            let parts: Vec<Value> = input
+                .splitn(max, sep.as_ref())
+                .map(|s| Value::String(s.into()))
+                .collect();
+            Value::Array(Rc::new(RefCell::new(parts)))
+        }
+        Value::Null => Value::Array(Rc::new(RefCell::new(vec![Value::String(input.into())]))),
+        _ => {
+            let sep_str = separator.to_string();
+            let parts: Vec<Value> = input
+                .splitn(max, &sep_str)
+                .map(|s| Value::String(s.into()))
+                .collect();
+            Value::Array(Rc::new(RefCell::new(parts)))
+        }
+    }
+}

package/crates/tish_eval/src/timers.rs

@@ -0,0 +1,111 @@
+//! setTimeout, setInterval, clearTimeout, clearInterval.
+//! Non-blocking: setTimeout returns immediately; callbacks run in a drain phase
+//! after the script yields (when run() finishes the synchronous program).
+
+use std::cell::RefCell;
+use std::collections::HashMap;
+use std::time::{Duration, Instant};
+use std::sync::atomic::{AtomicU64, Ordering};
+
+use crate::value::Value;
+
+static NEXT_ID: AtomicU64 = AtomicU64::new(1);
+
+struct TimerEntry {
+    due: Instant,
+    callback: Value,
+    args: Vec<Value>,
+    interval_ms: u64,
+}
+
+thread_local! {
+    static REGISTRY: RefCell<HashMap<u64, TimerEntry>> = RefCell::new(HashMap::new());
+}
+
+fn next_id() -> u64 {
+    NEXT_ID.fetch_add(1, Ordering::SeqCst)
+}
+
+/// Register a one-shot timer. Returns immediately with timer id.
+#[allow(non_snake_case)]
+pub fn setTimeout(callback: Value, args: Vec<Value>, delay_ms: u64) -> u64 {
+    let id = next_id();
+    let due = Instant::now() + Duration::from_millis(delay_ms);
+    REGISTRY.with(|r| {
+        r.borrow_mut().insert(id, TimerEntry {
+            due,
+            callback,
+            args,
+            interval_ms: 0,
+        });
+    });
+    id
+}
+
+/// Register a repeating timer. Returns immediately with timer id.
+#[allow(non_snake_case)]
+pub fn setInterval(callback: Value, args: Vec<Value>, delay_ms: u64) -> u64 {
+    let id = next_id();
+    let due = Instant::now() + Duration::from_millis(delay_ms);
+    REGISTRY.with(|r| {
+        r.borrow_mut().insert(id, TimerEntry {
+            due,
+            callback,
+            args,
+            interval_ms: delay_ms,
+        });
+    });
+    id
+}
+
+/// Remove a timer. No-op if already fired or invalid.
+#[allow(non_snake_case)]
+pub fn clearTimer(id: u64) {
+    REGISTRY.with(|r| {
+        r.borrow_mut().remove(&id);
+    });
+}
+
+/// Take all due timers and return (id, callback, args, interval_ms). Removes them from registry.
+/// Caller should run callbacks; for interval_ms > 0, caller should re-register.
+pub fn take_due_timers() -> Vec<(u64, Value, Vec<Value>, u64)> {
+    let now = Instant::now();
+    REGISTRY.with(|r| {
+        let mut reg = r.borrow_mut();
+        let due: Vec<_> = reg
+            .iter()
+            .filter(|(_, e)| e.due <= now)
+            .map(|(id, e)| (*id, e.callback.clone(), e.args.clone(), e.interval_ms))
+            .collect();
+        for (id, _, _, _) in &due {
+            reg.remove(id);
+        }
+        due
+    })
+}
+
+/// Re-register an interval timer (called after running its callback).
+pub fn re_register_interval(id: u64, callback: Value, args: Vec<Value>, interval_ms: u64) {
+    let due = Instant::now() + Duration::from_millis(interval_ms);
+    REGISTRY.with(|r| {
+        r.borrow_mut().insert(id, TimerEntry {
+            due,
+            callback,
+            args,
+            interval_ms,
+        });
+    });
+}
+
+/// Check if any timers are still pending.
+pub fn has_pending_timers() -> bool {
+    REGISTRY.with(|r| !r.borrow().is_empty())
+}
+
+/// Return the instant when the next timer is due, or None if registry is empty.
+pub fn next_due_instant() -> Option<Instant> {
+    REGISTRY.with(|r| {
+        let reg = r.borrow();
+        reg.values().map(|e| e.due).min()
+    })
+}

package/crates/tish_eval/src/value.rs

@@ -0,0 +1,224 @@
+//! Runtime values for the Tish interpreter.
+//!
+//! This module defines the interpreter's `Value` type, which includes variants
+//! like `Function`, `Native`, and `Serve` that hold AST or interpreter-specific
+//! data. The compiled runtime uses `tish_core::Value` instead, which has a
+//! different shape (no AST-carrying variants). The split is intentional.
+
+use std::cell::RefCell;
+use std::collections::HashMap;
+use std::rc::Rc;
+use std::sync::Arc;
+
+use tish_ast::{Expr, Statement};
+#[cfg(any(feature = "http", feature = "ws"))]
+use tish_core::NativeFn as CoreNativeFn;
+#[cfg(feature = "http")]
+use tish_core::TishPromise;
+use tish_core::TishOpaque;
+
+#[cfg(feature = "http")]
+pub use crate::promise::PromiseResolver;
+#[cfg(feature = "regex")]
+pub use crate::regex::TishRegExp;
+
+/// Native function type - takes args, returns Result<Value, String>
+pub type NativeFn = fn(&[Value]) -> Result<Value, String>;
+
+#[derive(Clone)]
+pub enum Value {
+    Number(f64),
+    String(Arc<str>),
+    Bool(bool),
+    Null,
+    Array(Rc<RefCell<Vec<Value>>>),
+    Object(Rc<RefCell<HashMap<Arc<str>, Value>>>),
+    /// User-defined function with AST body
+    Function {
+        params: Arc<[Arc<str>]>,
+        defaults: Arc<[Option<Expr>]>,
+        rest_param: Option<Arc<str>>,
+        body: Arc<Statement>,
+    },
+    /// Native/builtin function
+    Native(NativeFn),
+    /// HTTP serve function (needs special handling for callbacks)
+    #[cfg(feature = "http")]
+    Serve,
+    #[cfg(feature = "regex")]
+    RegExp(Rc<RefCell<TishRegExp>>),
+    /// Promise (ECMA-262 §27.2). Requires http feature for tokio.
+    #[cfg(feature = "http")]
+    Promise(crate::promise::PromiseRef),
+    /// Internal: resolve/reject functions passed to executor. Not user-facing.
+    #[cfg(feature = "http")]
+    PromiseResolver(PromiseResolver),
+    /// Promise constructor: Promise(executor). Requires special call handling.
+    #[cfg(feature = "http")]
+    PromiseConstructor,
+    /// Bound promise method: promise.then/catch/finally - captures the promise for the call.
+    #[cfg(feature = "http")]
+    BoundPromiseMethod(crate::promise::PromiseRef, std::sync::Arc<str>),
+    /// Timer builtins: setTimeout, setInterval. Need evaluator for callback.
+    #[cfg(feature = "http")]
+    TimerBuiltin(std::sync::Arc<str>),
+    /// Native `tish_core` Promise (fetch / reader.read / response.text).
+    #[cfg(feature = "http")]
+    CorePromise(Arc<dyn TishPromise>),
+    /// `tish_core::Value::Function` (e.g. response.text/json, ws send/receive) callable from eval.
+    #[cfg(any(feature = "http", feature = "ws"))]
+    CoreFn(CoreNativeFn),
+    /// Opaque handle to a native Rust type (e.g. Polars DataFrame).
+    Opaque(Arc<dyn TishOpaque>),
+    /// Bound method on an opaque value (opaque, method_name). Callable.
+    OpaqueMethod(Arc<dyn TishOpaque>, Arc<str>),
+}
+
+impl std::fmt::Debug for Value {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Value::Number(n) => write!(f, "Number({})", n),
+            Value::String(s) => write!(f, "String({:?})", s.as_ref()),
+            Value::Bool(b) => write!(f, "Bool({})", b),
+            Value::Null => write!(f, "Null"),
+            Value::Array(arr) => write!(f, "Array({:?})", arr.borrow()),
+            Value::Object(obj) => write!(f, "Object({:?})", obj.borrow()),
+            Value::Function { .. } => write!(f, "Function"),
+            Value::Native(_) => write!(f, "Native"),
+            #[cfg(feature = "http")]
+            Value::Serve => write!(f, "Serve"),
+            #[cfg(feature = "regex")]
+            Value::RegExp(re) => write!(f, "RegExp(/{}/{})", re.borrow().source, re.borrow().flags_string()),
+            #[cfg(feature = "http")]
+            Value::Promise(_) => write!(f, "Promise"),
+            #[cfg(feature = "http")]
+            Value::PromiseResolver(_) => write!(f, "[PromiseResolver]"),
+            #[cfg(feature = "http")]
+            Value::PromiseConstructor => write!(f, "[Function: Promise]"),
+            #[cfg(feature = "http")]
+            Value::BoundPromiseMethod(_, _) | Value::TimerBuiltin(_) => write!(f, "[Function]"),
+            #[cfg(feature = "http")]
+            Value::CorePromise(_) => write!(f, "Promise"),
+            #[cfg(any(feature = "http", feature = "ws"))]
+            Value::CoreFn(_) => write!(f, "CoreFn"),
+            Value::Opaque(o) => write!(f, "{}(opaque)", o.type_name()),
+            Value::OpaqueMethod(_, _) => write!(f, "[Function]"),
+        }
+    }
+}
+
+impl std::fmt::Display for Value {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Value::Number(n) => {
+                if n.is_nan() {
+                    write!(f, "NaN")
+                } else if *n == f64::INFINITY {
+                    write!(f, "Infinity")
+                } else if *n == f64::NEG_INFINITY {
+                    write!(f, "-Infinity")
+                } else {
+                    write!(f, "{}", n)
+                }
+            }
+            Value::String(s) => write!(f, "{}", s),
+            Value::Bool(b) => write!(f, "{}", b),
+            Value::Null => write!(f, "null"),
+            Value::Array(arr) => {
+                let inner: Vec<String> = arr.borrow().iter().map(|v| v.to_string()).collect();
+                write!(f, "[{}]", inner.join(", "))
+            }
+            Value::Object(obj) => {
+                let inner: Vec<String> = obj
+                    .borrow()
+                    .iter()
+                    .map(|(k, v)| format!("{}: {}", k.as_ref(), v))
+                    .collect();
+                write!(f, "{{{}}}", inner.join(", "))
+            }
+            Value::Function { .. } => write!(f, "[Function]"),
+            Value::Native(_) => write!(f, "[NativeFunction]"),
+            #[cfg(feature = "http")]
+            Value::Serve => write!(f, "[NativeFunction: serve]"),
+            #[cfg(feature = "regex")]
+            Value::RegExp(re) => {
+                let re = re.borrow();
+                write!(f, "/{}/{}", re.source, re.flags_string())
+            }
+            #[cfg(feature = "http")]
+            Value::Promise(_) => write!(f, "[Promise]"),
+            #[cfg(feature = "http")]
+            Value::PromiseResolver(_) => write!(f, "[Function]"),
+            #[cfg(feature = "http")]
+            Value::PromiseConstructor => write!(f, "function Promise() {{ [native code] }}"),
+            #[cfg(feature = "http")]
+            Value::BoundPromiseMethod(_, _) | Value::TimerBuiltin(_) => write!(f, "[Function]"),
+            #[cfg(feature = "http")]
+            Value::CorePromise(_) => write!(f, "[Promise]"),
+            #[cfg(any(feature = "http", feature = "ws"))]
+            Value::CoreFn(_) => write!(f, "[Function]"),
+            Value::Opaque(o) => write!(f, "[object {}]", o.type_name()),
+            Value::OpaqueMethod(_, _) => write!(f, "[Function]"),
+        }
+    }
+}
+
+impl Value {
+    pub fn is_truthy(&self) -> bool {
+        match self {
+            Value::Null => false,
+            Value::Bool(b) => *b,
+            Value::Number(n) => *n != 0.0 && !n.is_nan(),
+            Value::String(s) => !s.is_empty(),
+            _ => true,
+        }
+    }
+
+    pub fn strict_eq(&self, other: &Value) -> bool {
+        match (self, other) {
+            (Value::Number(a), Value::Number(b)) => {
+                if a.is_nan() || b.is_nan() {
+                    false
+                } else {
+                    a == b
+                }
+            }
+            (Value::String(a), Value::String(b)) => a == b,
+            (Value::Bool(a), Value::Bool(b)) => a == b,
+            (Value::Null, Value::Null) => true,
+            (Value::Array(a), Value::Array(b)) => Rc::ptr_eq(a, b),
+            (Value::Object(a), Value::Object(b)) => Rc::ptr_eq(a, b),
+            (Value::Opaque(a), Value::Opaque(b)) => Arc::ptr_eq(a, b),
+            (Value::OpaqueMethod(a, ak), Value::OpaqueMethod(b, bk)) => Arc::ptr_eq(a, b) && ak == bk,
+            _ => false,
+        }
+    }
+
+    /// Create a new array Value from a Vec.
+    pub fn array(items: Vec<Value>) -> Self {
+        Value::Array(Rc::new(RefCell::new(items)))
+    }
+
+    /// Create a new object Value from a HashMap.
+    pub fn object(map: HashMap<Arc<str>, Value>) -> Self {
+        Value::Object(Rc::new(RefCell::new(map)))
+    }
+
+    /// Create an empty array Value.
+    pub fn empty_array() -> Self {
+        Value::Array(Rc::new(RefCell::new(Vec::new())))
+    }
+
+    /// Create an empty object Value.
+    pub fn empty_object() -> Self {
+        Value::Object(Rc::new(RefCell::new(HashMap::new())))
+    }
+
+    /// Extract the number value, if this is a Number.
+    pub fn as_number(&self) -> Option<f64> {
+        match self {
+            Value::Number(n) => Some(*n),
+            _ => None,
+        }
+    }
+}