@tishlang/tish 1.5.0 → 1.7.0

package/crates/tish_eval/src/lib.rs

@@ -3,15 +3,15 @@
 mod eval;
 #[cfg(feature = "http")]
 mod http;
-pub mod value_convert;
+mod natives;
 #[cfg(feature = "http")]
 mod promise;
-#[cfg(feature = "http")]
-mod timers;
-mod natives;
 #[cfg(feature = "regex")]
 pub mod regex;
+#[cfg(feature = "http")]
+mod timers;
 mod value;
+pub mod value_convert;
 
 pub use eval::Evaluator;
 pub use value::PropMap;
@@ -51,11 +51,15 @@ pub fn format_value_for_console(value: &Value, colors: bool) -> 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> {
+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 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()));

package/crates/tish_eval/src/natives.rs

@@ -57,16 +57,21 @@ fn get_log_level() -> u8 {
 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 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)
+        i64::from_str_radix(&prefix, radix as u32)
+            .ok()
+            .map(|n| n as f64)
     } else {
         None
     };
@@ -80,12 +85,16 @@ pub fn parse_float(args: &[Value]) -> Result<Value, String> {
 }
 
 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()));
+    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(_)));
+    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))
 }
 
@@ -96,7 +105,9 @@ pub fn boolean_native(args: &[Value]) -> Result<Value, String> {
 
 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()))
+    Ok(Value::String(
+        tishlang_core::percent_decode(&s).unwrap_or(s).into(),
+    ))
 }
 
 pub fn encode_uri(args: &[Value]) -> Result<Value, String> {
@@ -105,41 +116,61 @@ pub fn encode_uri(args: &[Value]) -> Result<Value, String> {
 }
 
 pub fn math_abs(args: &[Value]) -> Result<Value, String> {
-    Ok(Value::Number(get_num(args.first().unwrap_or(&Value::Null)).abs()))
+    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()))
+    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 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 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 }))
+    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()))
+    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()))
+    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()))
+    Ok(Value::Number(
+        get_num(args.first().unwrap_or(&Value::Null)).round(),
+    ))
 }
 
 pub fn math_random(_args: &[Value]) -> Result<Value, String> {
@@ -156,33 +187,53 @@ pub fn math_pow(args: &[Value]) -> Result<Value, String> {
 }
 
 pub fn math_sin(args: &[Value]) -> Result<Value, String> {
-    Ok(Value::Number(get_num(args.first().unwrap_or(&Value::Null)).sin()))
+    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()))
+    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()))
+    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()))
+    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()))
+    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 };
+    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()))
+    Ok(Value::Number(
+        get_num(args.first().unwrap_or(&Value::Null)).trunc(),
+    ))
 }
 
 pub fn date_now(_args: &[Value]) -> Result<Value, String> {
@@ -199,19 +250,25 @@ pub fn array_is_array(args: &[Value]) -> Result<Value, String> {
 }
 
 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();
+    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);
+    let code = args
+        .first()
+        .and_then(|v| match v {
+            Value::Number(n) => Some(*n as i32),
+            _ => None,
+        })
+        .unwrap_or(0);
     std::process::exit(code);
 }
 
@@ -274,7 +331,7 @@ pub fn is_dir(args: &[Value]) -> Result<Value, String> {
 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) => {

package/crates/tish_eval/src/promise.rs

@@ -116,7 +116,11 @@ pub fn settle_promise(
         }
     };
     if let Some(tx) = tx {
-        let result = if is_resolve { Ok(value.clone()) } else { Err(value.clone()) };
+        let result = if is_resolve {
+            Ok(value.clone())
+        } else {
+            Err(value.clone())
+        };
         let _ = tx.send(result);
     }
     Ok((value, is_resolve, reactions))
@@ -134,7 +138,9 @@ pub fn add_reaction(state: &PromiseStateRef, reaction: 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::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()),
         }
     }
@@ -156,18 +162,18 @@ pub fn block_until_settled(promise_ref: &PromiseRef) -> PromiseAwaitResult {
         match result {
             Ok(Ok(v)) => PromiseAwaitResult::Fulfilled(v),
             Ok(Err(v)) => PromiseAwaitResult::Rejected(v),
-            Err(_) => PromiseAwaitResult::Error(
-                "Promise channel dropped before settlement".to_string(),
-            ),
+            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(),
-            ),
+            PromiseState::Pending { .. } => {
+                PromiseAwaitResult::Error("Promise receiver already consumed".to_string())
+            }
         }
     }
 }

package/crates/tish_eval/src/timers.rs

@@ -4,8 +4,8 @@
 
 use std::cell::RefCell;
 use std::collections::HashMap;
-use std::time::{Duration, Instant};
 use std::sync::atomic::{AtomicU64, Ordering};
+use std::time::{Duration, Instant};
 
 use crate::value::Value;
 
@@ -32,12 +32,15 @@ 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,
-        });
+        r.borrow_mut().insert(
+            id,
+            TimerEntry {
+                due,
+                callback,
+                args,
+                interval_ms: 0,
+            },
+        );
     });
     id
 }
@@ -48,12 +51,15 @@ 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,
-        });
+        r.borrow_mut().insert(
+            id,
+            TimerEntry {
+                due,
+                callback,
+                args,
+                interval_ms: delay_ms,
+            },
+        );
     });
     id
 }
@@ -88,12 +94,15 @@ pub fn take_due_timers() -> Vec<(u64, Value, Vec<Value>, u64)> {
 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,
-        });
+        r.borrow_mut().insert(
+            id,
+            TimerEntry {
+                due,
+                callback,
+                args,
+                interval_ms,
+            },
+        );
     });
 }
 

package/crates/tish_eval/src/value.rs

@@ -15,9 +15,9 @@ use tishlang_core::NativeFn as CoreNativeFn;
 
 /// Property map for interpreter `Value::Object` (uses `eval::Value`, not `tishlang_core::Value`).
 pub type PropMap = AHashMap<Arc<str>, Value>;
+use tishlang_core::TishOpaque;
 #[cfg(feature = "http")]
 use tishlang_core::TishPromise;
-use tishlang_core::TishOpaque;
 
 #[cfg(feature = "http")]
 pub use crate::promise::PromiseResolver;
@@ -88,7 +88,12 @@ impl std::fmt::Debug for Value {
             #[cfg(feature = "http")]
             Value::Serve => write!(f, "Serve"),
             #[cfg(feature = "regex")]
-            Value::RegExp(re) => write!(f, "RegExp(/{}/{})", re.borrow().source, re.borrow().flags_string()),
+            Value::RegExp(re) => write!(
+                f,
+                "RegExp(/{}/{})",
+                re.borrow().source,
+                re.borrow().flags_string()
+            ),
             #[cfg(feature = "http")]
             Value::Promise(_) => write!(f, "Promise"),
             #[cfg(feature = "http")]
@@ -187,7 +192,9 @@ impl Value {
             (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,
+            (Value::OpaqueMethod(a, ak), Value::OpaqueMethod(b, bk)) => {
+                Arc::ptr_eq(a, b) && ak == bk
+            }
             _ => false,
         }
     }

package/crates/tish_fmt/src/lib.rs

@@ -2,9 +2,9 @@
 
 use tishlang_ast::{
     ArrayElement, ArrowBody, BinOp, CallArg, CompoundOp, DestructElement, DestructPattern,
-    ExportDeclaration, Expr, FunParam, ImportSpecifier, JsxAttrValue, JsxChild, JsxProp,
-    Literal, LogicalAssignOp, MemberProp, ObjectProp, Program, Statement, TypeAnnotation,
-    TypedParam, UnaryOp,
+    ExportDeclaration, Expr, FunParam, ImportSpecifier, JsxAttrValue, JsxChild, JsxProp, Literal,
+    LogicalAssignOp, MemberProp, ObjectProp, Program, Statement, TypeAnnotation, TypedParam,
+    UnaryOp,
 };
 
 /// Format Tish source. On parse error, returns the parser message.
@@ -79,7 +79,10 @@ impl Printer {
                 }
             }
             Statement::VarDeclDestructure {
-                pattern, mutable, init, ..
+                pattern,
+                mutable,
+                init,
+                ..
             } => {
                 self.indent(level);
                 self.buf.push_str(if *mutable { "let " } else { "const " });
@@ -267,7 +270,9 @@ impl Printer {
                     self.stmt_inline_or_block(fb, level);
                 }
             }
-            Statement::Import { specifiers, from, .. } => {
+            Statement::Import {
+                specifiers, from, ..
+            } => {
                 self.indent(level);
                 self.buf.push_str("import ");
                 self.import_specs(specifiers);
@@ -279,8 +284,15 @@ impl Printer {
                 self.buf.push_str("export ");
                 match declaration.as_ref() {
                     ExportDeclaration::Named(inner) => {
-                        if let Statement::FunDecl { async_, name, params, rest_param, return_type, body, .. } =
-                            inner.as_ref()
+                        if let Statement::FunDecl {
+                            async_,
+                            name,
+                            params,
+                            rest_param,
+                            return_type,
+                            body,
+                            ..
+                        } = inner.as_ref()
                         {
                             if *async_ {
                                 self.buf.push_str("async ");
@@ -536,7 +548,9 @@ impl Printer {
                 Literal::Null => self.buf.push_str("null"),
             },
             Expr::Ident { name, .. } => self.buf.push_str(name.as_ref()),
-            Expr::Binary { left, op, right, .. } => {
+            Expr::Binary {
+                left, op, right, ..
+            } => {
                 self.expr(left);
                 self.buf.push(' ');
                 self.buf.push_str(binop(*op));
@@ -704,12 +718,16 @@ impl Printer {
                 self.buf.push_str("--");
                 self.buf.push_str(name.as_ref());
             }
-            Expr::CompoundAssign { name, op, value, .. } => {
+            Expr::CompoundAssign {
+                name, op, value, ..
+            } => {
                 self.buf.push_str(name.as_ref());
                 self.buf.push_str(compound(*op));
                 self.expr(value);
             }
-            Expr::LogicalAssign { name, op, value, .. } => {
+            Expr::LogicalAssign {
+                name, op, value, ..
+            } => {
                 self.buf.push_str(name.as_ref());
                 self.buf.push_str(logical_assign(*op));
                 self.expr(value);
@@ -830,9 +848,7 @@ impl Printer {
                 self.buf.push_str("</>");
             }
             Expr::NativeModuleLoad {
-                spec,
-                export_name,
-                ..
+                spec, export_name, ..
             } => {
                 self.buf.push_str("import { ");
                 self.buf.push_str(export_name.as_ref());