@tishlang/tish-format 1.0.12 → 1.0.13

package/crates/tish_eval/src/promise.rs

@@ -0,0 +1,179 @@
+//! ECMA-262 §27.2 Promise implementation for Tish interpreter.
+//! Requires tokio (http feature) for block_on and microtask scheduling.
+
+use std::cell::RefCell;
+use std::collections::VecDeque;
+use std::rc::Rc;
+
+use tokio::sync::oneshot;
+
+use crate::value::Value;
+
+/// A reaction from .then or .finally.
+pub enum Reaction {
+    Then(
+        Option<Value>,   // onFulfilled
+        Option<Value>,   // onRejected
+        PromiseResolver, // resolve
+        PromiseResolver, // reject
+    ),
+    Finally(Value, PromiseResolver, PromiseResolver), // onFinally, resolve, reject
+}
+
+/// Promise state: Pending, Fulfilled, or Rejected.
+pub enum PromiseState {
+    Pending {
+        tx: Option<oneshot::Sender<Result<Value, Value>>>,
+        reactions: VecDeque<Reaction>,
+    },
+    Fulfilled(Value),
+    Rejected(Value),
+}
+
+/// Internal state for a Promise, shared via Rc<RefCell<>>.
+pub type PromiseStateRef = Rc<RefCell<PromiseState>>;
+
+/// Receiver for blocking until a promise settles.
+pub type PromiseRx = Rc<RefCell<Option<oneshot::Receiver<Result<Value, Value>>>>>;
+
+/// A promise value holds state and the receiver for blocking until settled.
+#[derive(Clone)]
+pub struct PromiseRef {
+    pub state: PromiseStateRef,
+    pub rx: PromiseRx,
+}
+
+/// Data for resolve/reject callables passed to executor.
+#[derive(Clone)]
+pub struct PromiseResolver {
+    pub state: PromiseStateRef,
+    pub is_resolve: bool,
+}
+
+/// Extract PromiseResolver from Value::PromiseResolver. Panics if not.
+pub fn extract_resolvers(resolve: &Value, reject: &Value) -> (PromiseResolver, PromiseResolver) {
+    let r = match resolve {
+        Value::PromiseResolver(x) => x.clone(),
+        _ => panic!("expected PromiseResolver"),
+    };
+    let j = match reject {
+        Value::PromiseResolver(x) => x.clone(),
+        _ => panic!("expected PromiseResolver"),
+    };
+    (r, j)
+}
+
+/// Create a new pending Promise. Returns (promise_value, resolve_value, reject_value).
+/// The executor will be called with (resolve, reject). Resolve/reject can only be called once.
+pub fn create_promise() -> (Value, Value, Value) {
+    let (tx, rx) = oneshot::channel();
+    let state = Rc::new(RefCell::new(PromiseState::Pending {
+        tx: Some(tx),
+        reactions: VecDeque::new(),
+    }));
+    let rx_cell = Rc::new(RefCell::new(Some(rx)));
+    let resolve = Value::PromiseResolver(PromiseResolver {
+        state: Rc::clone(&state),
+        is_resolve: true,
+    });
+    let reject = Value::PromiseResolver(PromiseResolver {
+        state: Rc::clone(&state),
+        is_resolve: false,
+    });
+    let promise = Value::Promise(PromiseRef {
+        state: Rc::clone(&state),
+        rx: rx_cell,
+    });
+    (promise, resolve, reject)
+}
+
+/// Result of settling: reactions to run (caller must run them with evaluator).
+pub type SettleResult = (Value, bool, Vec<Reaction>);
+
+/// Settle the promise (resolve or reject). Called when PromiseResolver is invoked.
+/// Returns Ok((value, is_fulfilled, reactions)) if settled; reactions should be run by caller.
+/// Returns Err(msg) if already settled.
+pub fn settle_promise(
+    resolver: &PromiseResolver,
+    value: Value,
+    is_resolve: bool,
+) -> Result<SettleResult, String> {
+    let (tx, reactions) = {
+        let mut state = resolver.state.borrow_mut();
+        match std::mem::replace(&mut *state, PromiseState::Fulfilled(Value::Null)) {
+            PromiseState::Pending { tx, reactions } => {
+                *state = if is_resolve {
+                    PromiseState::Fulfilled(value.clone())
+                } else {
+                    PromiseState::Rejected(value.clone())
+                };
+                (tx, reactions.into_iter().collect())
+            }
+            s @ PromiseState::Fulfilled(_) | s @ PromiseState::Rejected(_) => {
+                *state = s;
+                return Err("Promise already settled".to_string());
+            }
+        }
+    };
+    if let Some(tx) = tx {
+        let result = if is_resolve {
+            Ok(value.clone())
+        } else {
+            Err(value.clone())
+        };
+        let _ = tx.send(result);
+    }
+    Ok((value, is_resolve, reactions))
+}
+
+/// Add a reaction to a pending promise. Caller must ensure promise is Pending.
+pub fn add_reaction(state: &PromiseStateRef, reaction: Reaction) {
+    let mut s = state.borrow_mut();
+    if let PromiseState::Pending { reactions, .. } = &mut *s {
+        reactions.push_back(reaction);
+    }
+}
+
+// Clone for Reaction
+impl Clone for Reaction {
+    fn clone(&self) -> Self {
+        match self {
+            Reaction::Then(a, b, r1, r2) => {
+                Reaction::Then(a.clone(), b.clone(), r1.clone(), r2.clone())
+            }
+            Reaction::Finally(f, r1, r2) => Reaction::Finally(f.clone(), r1.clone(), r2.clone()),
+        }
+    }
+}
+
+/// Result of awaiting a promise: fulfilled value, or rejection/error.
+#[derive(Debug)]
+pub enum PromiseAwaitResult {
+    Fulfilled(Value),
+    Rejected(Value),
+    Error(String),
+}
+
+/// Block until the promise settles.
+pub fn block_until_settled(promise_ref: &PromiseRef) -> PromiseAwaitResult {
+    let maybe_rx = promise_ref.rx.borrow_mut().take();
+    if let Some(rx) = maybe_rx {
+        let result = crate::http::RUNTIME.with(|rt| rt.block_on(rx));
+        match result {
+            Ok(Ok(v)) => PromiseAwaitResult::Fulfilled(v),
+            Ok(Err(v)) => PromiseAwaitResult::Rejected(v),
+            Err(_) => {
+                PromiseAwaitResult::Error("Promise channel dropped before settlement".to_string())
+            }
+        }
+    } else {
+        let state = promise_ref.state.borrow();
+        match &*state {
+            PromiseState::Fulfilled(v) => PromiseAwaitResult::Fulfilled(v.clone()),
+            PromiseState::Rejected(v) => PromiseAwaitResult::Rejected(v.clone()),
+            PromiseState::Pending { .. } => {
+                PromiseAwaitResult::Error("Promise receiver already consumed".to_string())
+            }
+        }
+    }
+}

package/crates/tish_eval/src/regex.rs

@@ -0,0 +1,299 @@
+//! JavaScript-compatible regular expression support for Tish.
+//!
+//! Re-exports core types from tishlang_core and provides interpreter-specific functionality.
+
+use std::cell::RefCell;
+use std::rc::Rc;
+use std::sync::Arc;
+
+pub use tishlang_core::{RegExpFlags, TishRegExp};
+
+use crate::value::PropMap;
+
+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: PropMap = PropMap::default();
+            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(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,120 @@
+//! 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::sync::atomic::{AtomicU64, Ordering};
+use std::time::{Duration, Instant};
+
+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()
+    })
+}