@tishlang/tish 1.4.2 → 1.6.0

package/crates/tish_build_utils/src/lib.rs

@@ -15,6 +15,123 @@ fn is_tish_workspace_root(root: &Path) -> bool {
     root.join("crates").join("tish_runtime").is_dir()
 }
 
+/// True if `line` (trimmed) opens a Cargo.toml table whose body may contain path dependencies.
+fn cargo_section_may_contain_path_deps(header: &str) -> bool {
+    let h = header.trim();
+    if h == "dependencies"
+        || h == "dev-dependencies"
+        || h == "build-dependencies"
+        || h == "workspace.dependencies"
+    {
+        return true;
+    }
+    h.starts_with("dependencies.")
+        || h.starts_with("dev-dependencies.")
+        || h.starts_with("build-dependencies.")
+        || h.starts_with("workspace.dependencies.")
+        || h.starts_with("patch.")
+}
+
+/// Collect `path = "..."` / `path = '...'` strings from lines in dependency-related sections.
+fn path_values_from_cargo_toml(content: &str) -> Vec<String> {
+    let mut out = Vec::new();
+    let mut in_section = false;
+    for line in content.lines() {
+        let trimmed = line.trim();
+        if let Some(rest) = trimmed.strip_prefix('[').and_then(|s| s.strip_suffix(']')) {
+            in_section = cargo_section_may_contain_path_deps(rest);
+            continue;
+        }
+        if !in_section {
+            continue;
+        }
+        extract_path_assignments_from_line(trimmed, &mut out);
+    }
+    out
+}
+
+fn extract_path_assignments_from_line(line: &str, out: &mut Vec<String>) {
+    let mut rest = line;
+    while let Some(idx) = rest.find("path") {
+        let after = rest[idx + 4..].trim_start();
+        let after = match after.strip_prefix('=') {
+            Some(a) => a.trim_start(),
+            None => {
+                rest = &rest[idx + 4..];
+                continue;
+            }
+        };
+        let quote = match after.chars().next() {
+            Some('"') => '"',
+            Some('\'') => '\'',
+            _ => {
+                rest = &rest[idx + 4..];
+                continue;
+            }
+        };
+        let after = &after[quote.len_utf8()..];
+        let end = after.find(quote);
+        let Some(end) = end else {
+            rest = &rest[idx + 4..];
+            continue;
+        };
+        out.push(after[..end].to_string());
+        rest = &after[end + quote.len_utf8()..];
+    }
+}
+
+/// Starting from a filesystem path (crate dir or file), walk ancestors for `crates/tish_runtime`.
+fn tish_root_from_path_hint(start: &Path) -> Option<PathBuf> {
+    let mut dir = if start.is_file() {
+        start.parent()?.to_path_buf()
+    } else {
+        start.to_path_buf()
+    };
+    dir = fs::canonicalize(&dir).unwrap_or(dir);
+    let mut cur = dir.as_path();
+    for _ in 0..32 {
+        if is_tish_workspace_root(cur) {
+            return Some(cur.to_path_buf());
+        }
+        cur = cur.parent()?;
+    }
+    None
+}
+
+/// Scan `dir/Cargo.toml` for path dependencies; if any resolves inside a Tish workspace, return that root.
+fn tish_root_from_cargo_manifest_dir(dir: &Path) -> Option<PathBuf> {
+    let cargo_toml = dir.join("Cargo.toml");
+    if !cargo_toml.is_file() {
+        return None;
+    }
+    let content = fs::read_to_string(&cargo_toml).ok()?;
+    let base = dir;
+    for rel in path_values_from_cargo_toml(&content) {
+        let joined = base.join(&rel);
+        let resolved = match joined.canonicalize() {
+            Ok(p) => p,
+            Err(_) => continue,
+        };
+        if let Some(root) = tish_root_from_path_hint(&resolved) {
+            return Some(root);
+        }
+    }
+    None
+}
+
+/// Walk from `start` upward; at each directory try [`tish_root_from_cargo_manifest_dir`].
+fn tish_root_from_project_cargo_files(mut start: PathBuf) -> Option<PathBuf> {
+    for _ in 0..32 {
+        if let Some(root) = tish_root_from_cargo_manifest_dir(&start) {
+            return Some(root);
+        }
+        if !start.pop() {
+            break;
+        }
+    }
+    None
+}
+
 /// Find the Tish workspace root using multiple strategies.
 ///
 /// Returns the directory containing the workspace Cargo.toml (with [workspace]).
@@ -30,6 +147,10 @@ pub fn find_workspace_root() -> Result<PathBuf, String> {
                 return Ok(root_buf);
             }
         }
+        // Consumer workspace: manifest is the app crate; path deps point at Tish checkout.
+        if let Some(root) = tish_root_from_project_cargo_files(path.clone()) {
+            return Ok(root);
+        }
     }
 
     // Strategy 2: Walk from current executable (e.g. target/debug/tish)
@@ -49,7 +170,14 @@ pub fn find_workspace_root() -> Result<PathBuf, String> {
         }
     }
 
-    // Strategy 3: Walk from current working directory
+    // Strategy 3: Walk from current working directory (path deps on a consumer crate)
+    if let Ok(cwd) = std::env::current_dir() {
+        if let Some(root) = tish_root_from_project_cargo_files(cwd.clone()) {
+            return Ok(root);
+        }
+    }
+
+    // Strategy 4: Walk from current working directory
     if let Ok(mut current) = std::env::current_dir() {
         for _ in 0..15 {
             let cargo_toml = current.join("Cargo.toml");
@@ -74,6 +202,21 @@ pub fn find_workspace_root() -> Result<PathBuf, String> {
     Err("Cannot find Tish workspace root. Run from workspace root or use cargo run.".to_string())
 }
 
+/// Path to `crates/tish_runtime` inside a locally installed `@tishlang/tish` npm package.
+pub fn npm_package_runtime_path(project_root: &Path) -> Option<PathBuf> {
+    let p = project_root
+        .join("node_modules")
+        .join("@tishlang")
+        .join("tish")
+        .join("crates")
+        .join("tish_runtime");
+    if p.is_dir() {
+        Some(p)
+    } else {
+        None
+    }
+}
+
 /// Find the path to the tishlang_runtime crate.
 ///
 /// Returns a canonical path string suitable for Cargo.toml path dependencies.
@@ -89,6 +232,24 @@ pub fn find_runtime_path() -> Result<String, String> {
         .map(|p| p.display().to_string().replace('\\', "/"))
 }
 
+/// Resolve `tishlang_runtime` for a Cargo build, preferring the npm install under `project_root`.
+///
+/// When a Tish app lives next to a checkout of the language repo (e.g. `…/tish/tish-cargo-example`),
+/// [`find_workspace_root`] can return the checkout while `rustDependencies` point at
+/// `node_modules/@tishlang/tish/crates/tish_core`. Using the npm tree for **both** runtime and shim
+/// avoids Cargo lockfile "package collision" for the same crate name/version at two paths.
+pub fn find_runtime_path_for_project(project_root: Option<&Path>) -> Result<String, String> {
+    if let Some(root) = project_root {
+        if let Some(rt) = npm_package_runtime_path(root) {
+            return rt
+                .canonicalize()
+                .map_err(|e| format!("Cannot canonicalize tishlang_runtime (npm): {}", e))
+                .map(|p| p.display().to_string().replace('\\', "/"));
+        }
+    }
+    find_runtime_path()
+}
+
 /// Crate package name -> directory name (directories kept as tish_* for historical reasons).
 const CRATE_NAME_TO_DIR: &[(&str, &str)] = &[
     ("tishlang_runtime", "tish_runtime"),
@@ -193,3 +354,45 @@ pub fn copy_binary_to_output(binary: &Path, output_path: &Path) -> Result<(), St
     fs::copy(binary, output_path).map_err(|e| format!("Cannot copy to {}: {}", output_path.display(), e))?;
     Ok(())
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn path_values_dependencies_section_only() {
+        let toml = r#"
+[package]
+name = "app"
+path = "ignored-outside-deps"
+
+[dependencies]
+tishlang_runtime = { path = "../tish/crates/tish_runtime" }
+
+[metadata]
+path = "also-ignored"
+"#;
+        let paths = path_values_from_cargo_toml(toml);
+        assert_eq!(paths, vec!["../tish/crates/tish_runtime"]);
+    }
+
+    #[test]
+    fn path_values_workspace_dependencies() {
+        let toml = r#"
+[workspace.dependencies]
+tishlang_runtime = { path = "../../tish/tish/crates/tish_runtime" }
+"#;
+        let paths = path_values_from_cargo_toml(toml);
+        assert_eq!(paths, vec!["../../tish/tish/crates/tish_runtime"]);
+    }
+
+    #[test]
+    fn path_values_patch_section() {
+        let toml = r#"
+[patch.crates-io]
+tishlang_runtime = { path = "../vendor/tish_runtime" }
+"#;
+        let paths = path_values_from_cargo_toml(toml);
+        assert_eq!(paths, vec!["../vendor/tish_runtime"]);
+    }
+}

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" }