@tishlang/tish 1.6.0 → 1.7.0

package/crates/tish_builtins/src/array.rs

@@ -1,9 +1,9 @@
 //! Array builtin methods.
 
+use crate::helpers::normalize_index;
 use std::cell::RefCell;
 use std::rc::Rc;
 use tishlang_core::Value;
-use crate::helpers::normalize_index;
 
 /// Create a new array Value from a Vec of Values.
 pub fn from_vec(v: Vec<Value>) -> Value {
@@ -153,7 +153,11 @@ pub fn slice(arr: &Value, start: &Value, end: &Value) -> Value {
         let len = arr_borrow.len() as i64;
         let start_idx = normalize_index(start, len, 0);
         let end_idx = normalize_index(end, len, len as usize);
-        let sliced = if start_idx < end_idx { arr_borrow[start_idx..end_idx].to_vec() } else { vec![] };
+        let sliced = if start_idx < end_idx {
+            arr_borrow[start_idx..end_idx].to_vec()
+        } else {
+            vec![]
+        };
         Value::Array(Rc::new(RefCell::new(sliced)))
     } else {
         Value::Null
@@ -188,7 +192,7 @@ pub fn flat(arr: &Value, depth: &Value) -> Value {
             result.push(v.clone());
         }
     }
-    
+
     if let Value::Array(arr) = arr {
         let d = match depth {
             Value::Number(n) => *n as i32,
@@ -208,9 +212,11 @@ pub fn flat(arr: &Value, depth: &Value) -> Value {
 pub fn map(arr: &Value, callback: &Value) -> Value {
     if let (Value::Array(arr), Value::Function(cb)) = (arr, callback) {
         let arr_borrow = arr.borrow();
-        let result: Vec<Value> = arr_borrow.iter().enumerate().map(|(i, v)| {
-            cb(&[v.clone(), Value::Number(i as f64)])
-        }).collect();
+        let result: Vec<Value> = arr_borrow
+            .iter()
+            .enumerate()
+            .map(|(i, v)| cb(&[v.clone(), Value::Number(i as f64)]))
+            .collect();
         Value::Array(Rc::new(RefCell::new(result)))
     } else {
         Value::Null
@@ -220,10 +226,18 @@ pub fn map(arr: &Value, callback: &Value) -> Value {
 pub fn filter(arr: &Value, callback: &Value) -> Value {
     if let (Value::Array(arr), Value::Function(cb)) = (arr, callback) {
         let arr_borrow = arr.borrow();
-        let result: Vec<Value> = arr_borrow.iter().enumerate().filter_map(|(i, v)| {
-            let keep = cb(&[v.clone(), Value::Number(i as f64)]);
-            if keep.is_truthy() { Some(v.clone()) } else { None }
-        }).collect();
+        let result: Vec<Value> = arr_borrow
+            .iter()
+            .enumerate()
+            .filter_map(|(i, v)| {
+                let keep = cb(&[v.clone(), Value::Number(i as f64)]);
+                if keep.is_truthy() {
+                    Some(v.clone())
+                } else {
+                    None
+                }
+            })
+            .collect();
         Value::Array(Rc::new(RefCell::new(result)))
     } else {
         Value::Null
@@ -234,9 +248,7 @@ pub fn reduce(arr: &Value, callback: &Value, initial: &Value) -> Value {
     if let (Value::Array(arr), Value::Function(cb)) = (arr, callback) {
         let arr_borrow = arr.borrow();
         let len = arr_borrow.len();
-        let (start_idx, mut acc) = if matches!(initial, Value::Null)
-            && !arr_borrow.is_empty()
-        {
+        let (start_idx, mut acc) = if matches!(initial, Value::Null) && !arr_borrow.is_empty() {
             // No initial value: use first element as acc, start from index 1
             (1, arr_borrow[0].clone())
         } else {
@@ -335,7 +347,9 @@ pub fn flat_map(arr: &Value, callback: &Value) -> Value {
 }
 
 fn sort_by_impl<F>(arr: &Value, cmp: F) -> Value
-where F: FnMut(&Value, &Value) -> std::cmp::Ordering {
+where
+    F: FnMut(&Value, &Value) -> std::cmp::Ordering,
+{
     if let Value::Array(arr) = arr {
         arr.borrow_mut().sort_by(cmp);
         Value::Array(Rc::clone(arr))
@@ -345,7 +359,9 @@ where F: FnMut(&Value, &Value) -> std::cmp::Ordering {
 }
 
 pub fn sort_default(arr: &Value) -> Value {
-    sort_by_impl(arr, |a, b| a.to_display_string().cmp(&b.to_display_string()))
+    sort_by_impl(arr, |a, b| {
+        a.to_display_string().cmp(&b.to_display_string())
+    })
 }
 
 pub fn sort_with_comparator(arr: &Value, comparator: &Value) -> Value {
@@ -355,7 +371,7 @@ pub fn sort_with_comparator(arr: &Value, comparator: &Value) -> Value {
         let mut indices: Vec<usize> = (0..len).collect();
         let mut elements: Vec<Value> = std::mem::take(&mut *arr_mut);
         let mut args_buf: [Value; 2] = [Value::Null, Value::Null];
-        
+
         indices.sort_by(|&a, &b| {
             args_buf[0] = elements[a].clone();
             args_buf[1] = elements[b].clone();
@@ -365,8 +381,11 @@ pub fn sort_with_comparator(arr: &Value, comparator: &Value) -> Value {
                 _ => std::cmp::Ordering::Equal,
             }
         });
-        
-        *arr_mut = indices.into_iter().map(|i| std::mem::replace(&mut elements[i], Value::Null)).collect();
+
+        *arr_mut = indices
+            .into_iter()
+            .map(|i| std::mem::replace(&mut elements[i], Value::Null))
+            .collect();
         drop(arr_mut);
         Value::Array(Rc::clone(arr))
     } else {
@@ -380,7 +399,11 @@ fn num_cmp(a: &Value, b: &Value, asc: bool) -> std::cmp::Ordering {
         _ => (f64::NAN, f64::NAN),
     };
     let cmp = na.partial_cmp(&nb).unwrap_or(std::cmp::Ordering::Equal);
-    if asc { cmp } else { cmp.reverse() }
+    if asc {
+        cmp
+    } else {
+        cmp.reverse()
+    }
 }
 
 pub fn sort_numeric_asc(arr: &Value) -> Value {
@@ -398,13 +421,21 @@ pub fn sort_by_property_numeric(arr: &Value, prop: &str, asc: bool) -> Value {
         let na = get_prop_number(a, &prop_arc);
         let nb = get_prop_number(b, &prop_arc);
         let cmp = na.partial_cmp(&nb).unwrap_or(std::cmp::Ordering::Equal);
-        if asc { cmp } else { cmp.reverse() }
+        if asc {
+            cmp
+        } else {
+            cmp.reverse()
+        }
     })
 }
 
 fn get_prop_number(v: &Value, prop: &std::sync::Arc<str>) -> f64 {
     match v {
-        Value::Object(o) => o.borrow().get(prop.as_ref()).map(|v| v.as_number().unwrap_or(f64::NAN)).unwrap_or(f64::NAN),
+        Value::Object(o) => o
+            .borrow()
+            .get(prop.as_ref())
+            .map(|v| v.as_number().unwrap_or(f64::NAN))
+            .unwrap_or(f64::NAN),
         _ => f64::NAN,
     }
 }

package/crates/tish_builtins/src/construct.rs

@@ -82,10 +82,7 @@ fn buffer_source_stub() -> Value {
         Arc::from("start"),
         Value::Function(Rc::new(|_| Value::Null)),
     );
-    m.insert(
-        Arc::from("stop"),
-        Value::Function(Rc::new(|_| Value::Null)),
-    );
+    m.insert(Arc::from("stop"), Value::Function(Rc::new(|_| Value::Null)));
     Value::Object(Rc::new(RefCell::new(m)))
 }
 
@@ -98,10 +95,7 @@ fn oscillator_stub() -> Value {
         Arc::from("start"),
         Value::Function(Rc::new(|_| Value::Null)),
     );
-    m.insert(
-        Arc::from("stop"),
-        Value::Function(Rc::new(|_| Value::Null)),
-    );
+    m.insert(Arc::from("stop"), Value::Function(Rc::new(|_| Value::Null)));
     Value::Object(Rc::new(RefCell::new(m)))
 }
 

package/crates/tish_builtins/src/globals.rs

@@ -16,29 +16,35 @@ pub fn boolean(args: &[Value]) -> Value {
 
 /// decodeURI(str)
 pub fn decode_uri(args: &[Value]) -> Value {
-    let s = args.first().map(Value::to_display_string).unwrap_or_default();
+    let s = args
+        .first()
+        .map(Value::to_display_string)
+        .unwrap_or_default();
     Value::String(percent_decode(&s).unwrap_or(s).into())
 }
 
 /// encodeURI(str)
 pub fn encode_uri(args: &[Value]) -> Value {
-    let s = args.first().map(Value::to_display_string).unwrap_or_default();
+    let s = args
+        .first()
+        .map(Value::to_display_string)
+        .unwrap_or_default();
     Value::String(percent_encode(&s).into())
 }
 
 /// isFinite(value)
 pub fn is_finite(args: &[Value]) -> Value {
-    Value::Bool(args.first().is_some_and(|v| matches!(v, Value::Number(n) if n.is_finite())))
+    Value::Bool(
+        args.first()
+            .is_some_and(|v| matches!(v, Value::Number(n) if n.is_finite())),
+    )
 }
 
 /// isNaN(value)
 pub fn is_nan(args: &[Value]) -> Value {
-    Value::Bool(
-        args.first().is_none_or(|v| {
-            matches!(v, Value::Number(n) if n.is_nan())
-                || !matches!(v, Value::Number(_))
-        }),
-    )
+    Value::Bool(args.first().is_none_or(|v| {
+        matches!(v, Value::Number(n) if n.is_nan()) || !matches!(v, Value::Number(_))
+    }))
 }
 
 /// Array.isArray(value)
@@ -144,12 +150,18 @@ pub fn object_assign(args: &[Value]) -> Value {
 
 /// parseInt(string, radix?)
 pub fn parse_int(args: &[Value]) -> Value {
-    let s = args.first().map(Value::to_display_string).unwrap_or_default();
+    let s = args
+        .first()
+        .map(Value::to_display_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);
 
     if (2..=36).contains(&radix) {
         let prefix: String = s
@@ -165,7 +177,10 @@ pub fn parse_int(args: &[Value]) -> Value {
 
 /// parseFloat(string)
 pub fn parse_float(args: &[Value]) -> Value {
-    let s = args.first().map(Value::to_display_string).unwrap_or_default();
+    let s = args
+        .first()
+        .map(Value::to_display_string)
+        .unwrap_or_default();
     Value::Number(s.trim().parse().unwrap_or(f64::NAN))
 }
 

package/crates/tish_builtins/src/lib.rs

@@ -5,11 +5,11 @@
 //! and native signatures.
 
 pub mod array;
-pub mod string;
-pub mod object;
-pub mod math;
-pub mod helpers;
-pub mod globals;
 pub mod construct;
+pub mod globals;
+pub mod helpers;
+pub mod math;
+pub mod object;
+pub mod string;
 
 pub use tishlang_core::Value;

package/crates/tish_builtins/src/math.rs

@@ -1,7 +1,7 @@
 //! Math builtin functions.
 
-use tishlang_core::Value;
 use crate::helpers::extract_num;
+use tishlang_core::Value;
 
 macro_rules! math_unary {
     ($name:ident, $op:ident) => {
@@ -31,14 +31,16 @@ math_unary!(trunc, trunc);
 math_unary!(cbrt, cbrt);
 
 pub fn min(args: &[Value]) -> Value {
-    let n = args.iter()
+    let n = args
+        .iter()
         .filter_map(|v| extract_num(Some(v)))
         .fold(f64::INFINITY, f64::min);
     Value::Number(if n == f64::INFINITY { f64::NAN } else { n })
 }
 
 pub fn max(args: &[Value]) -> Value {
-    let n = args.iter()
+    let n = args
+        .iter()
         .filter_map(|v| extract_num(Some(v)))
         .fold(f64::NEG_INFINITY, f64::max);
     Value::Number(if n == f64::NEG_INFINITY { f64::NAN } else { n })

package/crates/tish_builtins/src/string.rs

@@ -3,11 +3,11 @@
 //! All indices use character (Unicode scalar) positions for consistency with
 //! JavaScript, matching .length and .charAt(). Byte offsets are never exposed.
 
+use crate::helpers::normalize_index;
 use std::cell::RefCell;
 use std::rc::Rc;
 use std::sync::Arc;
 use tishlang_core::Value;
-use crate::helpers::normalize_index;
 
 /// Byte offset -> character index.
 fn byte_to_char_index(s: &str, byte_offset: usize) -> usize {
@@ -152,7 +152,10 @@ pub fn slice(s: &Value, start: &Value, end: &Value) -> Value {
     if let Value::String(s) = s {
         let chars: Vec<char> = s.chars().collect();
         let len = chars.len() as i64;
-        let (si, ei) = (normalize_index(start, len, 0), normalize_index(end, len, len as usize));
+        let (si, ei) = (
+            normalize_index(start, len, 0),
+            normalize_index(end, len, len as usize),
+        );
         let result: String = if si < ei {
             chars[si..ei].iter().collect()
         } else {
@@ -193,7 +196,8 @@ pub fn split(s: &Value, sep: &Value) -> Value {
             Value::String(ss) => ss.as_ref(),
             _ => return Value::Array(Rc::new(RefCell::new(vec![Value::String(Arc::clone(s))]))),
         };
-        let parts: Vec<Value> = s.split(separator)
+        let parts: Vec<Value> = s
+            .split(separator)
             .map(|p| Value::String(p.into()))
             .collect();
         Value::Array(Rc::new(RefCell::new(parts)))
@@ -244,9 +248,19 @@ pub fn ends_with(s: &Value, search: &Value) -> Value {
 
 fn replace_impl(s: &Value, search: &Value, replacement: &Value, all: bool) -> Value {
     if let Value::String(s) = s {
-        let search_str = match search { Value::String(ss) => ss.as_ref(), _ => return Value::String(Arc::clone(s)) };
-        let repl_str = match replacement { Value::String(ss) => ss.as_ref(), _ => "" };
-        let result = if all { s.replace(search_str, repl_str) } else { s.replacen(search_str, repl_str, 1) };
+        let search_str = match search {
+            Value::String(ss) => ss.as_ref(),
+            _ => return Value::String(Arc::clone(s)),
+        };
+        let repl_str = match replacement {
+            Value::String(ss) => ss.as_ref(),
+            _ => "",
+        };
+        let result = if all {
+            s.replace(search_str, repl_str)
+        } else {
+            s.replacen(search_str, repl_str, 1)
+        };
         Value::String(result.into())
     } else {
         Value::Null
@@ -267,8 +281,13 @@ fn char_at_idx(s: &str, idx: usize) -> Option<char> {
 
 pub fn char_at(s: &Value, idx: &Value) -> Value {
     if let Value::String(s) = s {
-        let idx = match idx { Value::Number(n) => *n as usize, _ => 0 };
-        char_at_idx(s, idx).map(|c| Value::String(c.to_string().into())).unwrap_or(Value::String("".into()))
+        let idx = match idx {
+            Value::Number(n) => *n as usize,
+            _ => 0,
+        };
+        char_at_idx(s, idx)
+            .map(|c| Value::String(c.to_string().into()))
+            .unwrap_or(Value::String("".into()))
     } else {
         Value::Null
     }
@@ -276,8 +295,13 @@ pub fn char_at(s: &Value, idx: &Value) -> Value {
 
 pub fn char_code_at(s: &Value, idx: &Value) -> Value {
     if let Value::String(s) = s {
-        let idx = match idx { Value::Number(n) => *n as usize, _ => 0 };
-        char_at_idx(s, idx).map(|c| Value::Number(c as u32 as f64)).unwrap_or(Value::Number(f64::NAN))
+        let idx = match idx {
+            Value::Number(n) => *n as usize,
+            _ => 0,
+        };
+        char_at_idx(s, idx)
+            .map(|c| Value::Number(c as u32 as f64))
+            .unwrap_or(Value::Number(f64::NAN))
     } else {
         Value::Null
     }
@@ -311,7 +335,11 @@ fn pad_impl(s: &Value, target_len: &Value, pad: &Value, at_start: bool) -> Value
         }
         let needed = target_len - char_count;
         let padding: String = pad_str.chars().cycle().take(needed).collect();
-        let result = if at_start { format!("{}{}", padding, s) } else { format!("{}{}", s, padding) };
+        let result = if at_start {
+            format!("{}{}", padding, s)
+        } else {
+            format!("{}{}", s, padding)
+        };
         Value::String(result.into())
     } else {
         Value::Null
@@ -382,16 +410,31 @@ mod tests {
     fn includes_basic() {
         assert_same!(includes(&s("hello"), &s("ll"), None), Value::Bool(true));
         assert_same!(includes(&s("hello"), &s("x"), None), Value::Bool(false));
-        assert_same!(includes(&s("hello"), &s("l"), Some(&n(3.0))), Value::Bool(true));
-        assert_same!(includes(&s("hello"), &s("l"), Some(&n(4.0))), Value::Bool(false));
+        assert_same!(
+            includes(&s("hello"), &s("l"), Some(&n(3.0))),
+            Value::Bool(true)
+        );
+        assert_same!(
+            includes(&s("hello"), &s("l"), Some(&n(4.0))),
+            Value::Bool(false)
+        );
     }
 
     #[test]
     fn includes_negative_from() {
-        assert_same!(includes(&s("hello"), &s("o"), Some(&n(-1.0))), Value::Bool(true));
-        assert_same!(includes(&s("hello"), &s("h"), Some(&n(-5.0))), Value::Bool(true));
+        assert_same!(
+            includes(&s("hello"), &s("o"), Some(&n(-1.0))),
+            Value::Bool(true)
+        );
+        assert_same!(
+            includes(&s("hello"), &s("h"), Some(&n(-5.0))),
+            Value::Bool(true)
+        );
         // fromIndex -1 → start at len-1 = 1 ("i" only), "h" not found
-        assert_same!(includes(&s("hi"), &s("h"), Some(&n(-1.0))), Value::Bool(false));
+        assert_same!(
+            includes(&s("hi"), &s("h"), Some(&n(-1.0))),
+            Value::Bool(false)
+        );
     }
 
     #[test]
@@ -466,7 +509,10 @@ mod tests {
 
     #[test]
     fn last_index_of_basic() {
-        assert_same!(last_index_of(&s("abcabc"), &s("a"), &n(f64::INFINITY)), n(3.0));
+        assert_same!(
+            last_index_of(&s("abcabc"), &s("a"), &n(f64::INFINITY)),
+            n(3.0)
+        );
         assert_same!(last_index_of(&s("abcabc"), &s("a"), &n(2.0)), n(0.0));
         assert_same!(last_index_of(&s("hello"), &s("l"), &n(3.0)), n(3.0));
         assert_same!(last_index_of(&s("hello"), &s("l"), &n(1.0)), n(-1.0));
@@ -490,8 +536,14 @@ mod tests {
 
     #[test]
     fn last_index_of_unicode() {
-        assert_same!(last_index_of(&s("😀a😀"), &s("a"), &n(f64::INFINITY)), n(1.0));
-        assert_same!(last_index_of(&s("😀a😀"), &s("😀"), &n(f64::INFINITY)), n(2.0));
+        assert_same!(
+            last_index_of(&s("😀a😀"), &s("a"), &n(f64::INFINITY)),
+            n(1.0)
+        );
+        assert_same!(
+            last_index_of(&s("😀a😀"), &s("😀"), &n(f64::INFINITY)),
+            n(2.0)
+        );
     }
 
     #[test]

package/crates/tish_bytecode/src/chunk.rs

@@ -30,7 +30,6 @@ impl Constant {
     }
 }
 
-
 /// A bytecode chunk: instructions and associated data.
 #[derive(Debug, Clone)]
 pub struct Chunk {