@tishlang/tish 1.3.8 → 1.5.0

package/crates/tish_builtins/src/string.rs

@@ -37,6 +37,80 @@ pub fn len(s: &Value) -> Option<usize> {
     }
 }
 
+/// JS `ToIntegerOrInfinity` then clamp for `lastIndexOf` `position` (character index).
+fn last_index_of_position_to_start(position: &Value, len: usize) -> usize {
+    let pos = match position {
+        Value::Null => 0.0,
+        Value::Bool(false) => 0.0,
+        Value::Bool(true) => 1.0,
+        Value::Number(n) => {
+            if n.is_nan() || *n == 0.0 {
+                0.0
+            } else if n.is_infinite() {
+                *n
+            } else {
+                n.trunc()
+            }
+        }
+        _ => 0.0,
+    };
+    if pos.is_infinite() {
+        if pos > 0.0 {
+            len
+        } else {
+            0
+        }
+    } else if pos <= 0.0 {
+        0
+    } else {
+        (pos as usize).min(len)
+    }
+}
+
+/// Character index of last occurrence of `needle` in `haystack`, or `-1`.
+/// `position` is JS `lastIndexOf`'s second argument: use `Number(INFINITY)` when omitted;
+/// `Null` is JS `null` → 0. Indices are Unicode scalar positions (same as `.length` / `indexOf`).
+pub fn last_index_of_str(haystack: &str, needle: &str, position: &Value) -> Value {
+    let len = haystack.chars().count();
+    let start = last_index_of_position_to_start(position, len);
+    let hay: Vec<char> = haystack.chars().collect();
+    let needle_chars: Vec<char> = needle.chars().collect();
+    let search_len = needle_chars.len();
+    if search_len == 0 {
+        return Value::Number(start as f64);
+    }
+    if search_len > len {
+        return Value::Number(-1.0);
+    }
+    // Match must fit in the string and end at or before `start` (ECMA `lastIndexOf` position).
+    if start + 1 < search_len {
+        return Value::Number(-1.0);
+    }
+    let k_max_by_len = len - search_len;
+    let k_max_by_start = start + 1 - search_len;
+    let k_max = k_max_by_len.min(k_max_by_start);
+    let mut k = k_max;
+    loop {
+        if hay[k..k + search_len] == needle_chars[..] {
+            return Value::Number(k as f64);
+        }
+        if k == 0 {
+            break;
+        }
+        k -= 1;
+    }
+    Value::Number(-1.0)
+}
+
+/// Like [`last_index_of_str`] but takes string `Value`s; non-strings → `-1`.
+pub fn last_index_of(s: &Value, search: &Value, position: &Value) -> Value {
+    if let (Value::String(h), Value::String(n)) = (s, search) {
+        last_index_of_str(h.as_ref(), n.as_ref(), position)
+    } else {
+        Value::Number(-1.0)
+    }
+}
+
 /// Returns character index of first occurrence, or -1. Optional fromIndex (JS indexOf).
 pub fn index_of(s: &Value, search: &Value, from: Option<&Value>) -> Value {
     if let (Value::String(s), Value::String(search)) = (s, search) {
@@ -251,3 +325,177 @@ pub fn pad_start(s: &Value, target_len: &Value, pad: &Value) -> Value {
 pub fn pad_end(s: &Value, target_len: &Value, pad: &Value) -> Value {
     pad_impl(s, target_len, pad, false)
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn s(x: &str) -> Value {
+        Value::String(x.into())
+    }
+
+    fn n(x: f64) -> Value {
+        Value::Number(x)
+    }
+
+    fn same(a: &Value, b: &Value) -> bool {
+        match (a, b) {
+            (Value::String(x), Value::String(y)) => x == y,
+            (Value::Number(x), Value::Number(y)) => {
+                if x.is_nan() && y.is_nan() {
+                    true
+                } else {
+                    x == y
+                }
+            }
+            (Value::Bool(x), Value::Bool(y)) => x == y,
+            (Value::Null, Value::Null) => true,
+            (Value::Array(ax), Value::Array(ay)) => {
+                let bx = ax.borrow();
+                let by = ay.borrow();
+                bx.len() == by.len() && bx.iter().zip(by.iter()).all(|(u, v)| same(u, v))
+            }
+            _ => false,
+        }
+    }
+
+    macro_rules! assert_same {
+        ($left:expr, $right:expr) => {
+            assert!(same(&$left, &$right), "left={:?} right={:?}", $left, $right);
+        };
+    }
+
+    #[test]
+    fn index_of_basic() {
+        assert_same!(index_of(&s("abc"), &s("b"), None), n(1.0));
+        assert_same!(index_of(&s("abc"), &s("x"), None), n(-1.0));
+        assert_same!(index_of(&s("abca"), &s("a"), Some(&n(1.0))), n(3.0));
+    }
+
+    #[test]
+    fn index_of_non_string() {
+        assert_same!(index_of(&n(1.0), &s("a"), None), n(-1.0));
+        assert_same!(index_of(&s("a"), &n(1.0), None), n(-1.0));
+    }
+
+    #[test]
+    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));
+    }
+
+    #[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));
+        // 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));
+    }
+
+    #[test]
+    fn includes_non_string() {
+        assert_same!(includes(&n(1.0), &s("a"), None), Value::Bool(false));
+    }
+
+    #[test]
+    fn slice_substring() {
+        assert_same!(slice(&s("hello"), &n(1.0), &n(4.0)), s("ell"));
+        assert_same!(slice(&s("hello"), &n(-3.0), &Value::Null), s("llo"));
+        assert_same!(substring(&s("hello"), &n(4.0), &n(1.0)), s("ell"));
+        assert_same!(slice(&s("ab"), &n(1.0), &n(1.0)), s(""));
+    }
+
+    #[test]
+    fn slice_non_string() {
+        assert_same!(slice(&n(1.0), &n(0.0), &Value::Null), Value::Null);
+    }
+
+    #[test]
+    fn split_trim() {
+        let Value::Array(a) = split(&s("a,b"), &s(",")) else {
+            panic!();
+        };
+        assert_eq!(a.borrow().len(), 2);
+        assert_same!(
+            split(&s("x"), &n(1.0)),
+            Value::Array(Rc::new(RefCell::new(vec![s("x")])))
+        );
+        assert_same!(split(&n(1.0), &s(",")), Value::Null);
+        assert_same!(trim(&s("  x  ")), s("x"));
+        assert_same!(trim(&n(1.0)), Value::Null);
+    }
+
+    #[test]
+    fn case_and_prefix_suffix() {
+        assert_same!(to_upper_case(&s("aB")), s("AB"));
+        assert_same!(to_lower_case(&s("aB")), s("ab"));
+        assert_same!(starts_with(&s("/api"), &s("/api")), Value::Bool(true));
+        assert_same!(ends_with(&s("x.js"), &s(".js")), Value::Bool(true));
+        assert_same!(starts_with(&n(1.0), &s("")), Value::Bool(false));
+    }
+
+    #[test]
+    fn replace_family() {
+        assert_same!(replace(&s("aa"), &s("a"), &s("b")), s("ba"));
+        assert_same!(replace_all(&s("aa"), &s("a"), &s("b")), s("bb"));
+        assert_same!(replace(&n(1.0), &s("a"), &s("b")), Value::Null);
+    }
+
+    #[test]
+    fn char_at_code() {
+        assert_same!(char_at(&s("ab"), &n(0.0)), s("a"));
+        assert_same!(char_at(&s("ab"), &n(99.0)), s(""));
+        if let Value::Number(x) = char_code_at(&s("A"), &n(0.0)) {
+            assert_eq!(x, 65.0);
+        } else {
+            panic!();
+        }
+        assert!(matches!(char_code_at(&s("x"), &n(9.0)), Value::Number(x) if x.is_nan()));
+    }
+
+    #[test]
+    fn repeat_pad() {
+        assert_same!(repeat(&s("ab"), &n(2.0)), s("abab"));
+        assert_same!(repeat(&s("x"), &n(0.0)), s(""));
+        assert_same!(pad_start(&s("5"), &n(3.0), &s("0")), s("005"));
+        assert_same!(pad_end(&s("hi"), &n(5.0), &s("!")), s("hi!!!"));
+        assert_same!(pad_start(&s("hello"), &n(3.0), &Value::Null), s("hello"));
+    }
+
+    #[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(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));
+    }
+
+    #[test]
+    fn last_index_of_omit_and_null() {
+        assert_same!(last_index_of(&s("aba"), &s("a"), &n(f64::INFINITY)), n(2.0));
+        assert_same!(last_index_of(&s("aba"), &s("a"), &Value::Null), n(0.0));
+    }
+
+    #[test]
+    fn last_index_of_empty_needle() {
+        assert_same!(last_index_of(&s("abc"), &s(""), &n(2.0)), n(2.0));
+    }
+
+    #[test]
+    fn last_index_of_nan_position() {
+        assert_same!(last_index_of(&s("aba"), &s("a"), &n(f64::NAN)), n(0.0));
+    }
+
+    #[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));
+    }
+
+    #[test]
+    fn last_index_of_non_string() {
+        assert_same!(last_index_of(&n(1.0), &s("a"), &n(0.0)), n(-1.0));
+    }
+}

package/crates/tish_bytecode/Cargo.toml

@@ -14,3 +14,4 @@ tishlang_core = { path = "../tish_core", version = ">=0.1" }
 tishlang_compile = { path = "../tish_compile", version = ">=0.1" }
 tishlang_parser = { path = "../tish_parser", version = ">=0.1" }
 tishlang_opt = { path = "../tish_opt", version = ">=0.1" }
+tishlang_vm = { path = "../tish_vm", version = ">=0.1" }