@tishlang/tish-format 3.6.0 → 3.7.1

package/crates/tish_test/src/coverage.rs

@@ -0,0 +1,237 @@
+//! Line coverage collection for `tish test --coverage` (lives entirely in this crate).
+//!
+//! Hits are recorded by AST-injected calls to `__tish_cov_hit__(fileId, line)`, which works
+//! for every execution backend that runs the instrumented program (vm, interp, and later
+//! native/js emit of the same AST).
+
+use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
+use std::fs;
+use std::io::{self, Write};
+use std::path::{Path, PathBuf};
+use std::sync::Mutex;
+
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::LazyLock;
+
+use tishlang_core::Value;
+
+/// Read on every instrumented line, so it stays out of the mutex.
+static ENABLED: AtomicBool = AtomicBool::new(false);
+
+static STATE: LazyLock<Mutex<CoverageState>> = LazyLock::new(|| Mutex::new(CoverageState::empty()));
+
+struct CoverageState {
+    files: Vec<String>,
+    file_index: HashMap<String, u32>,
+    /// Modules already rewritten. A module imported by several test files must only be
+    /// instrumented once, or its statements would be wrapped (and counted) twice.
+    instrumented: HashSet<String>,
+    /// file id → executable lines (from instrumentation sites)
+    executable: Vec<BTreeSet<u32>>,
+    /// file id → line → hits. Indexed by id so the hot path never hashes or clones a path.
+    hits: Vec<BTreeMap<u32, u64>>,
+}
+
+impl CoverageState {
+    fn empty() -> Self {
+        Self {
+            files: Vec::new(),
+            file_index: HashMap::new(),
+            instrumented: HashSet::new(),
+            executable: Vec::new(),
+            hits: Vec::new(),
+        }
+    }
+}
+
+/// Enable coverage collection and clear prior data.
+pub fn begin() {
+    let mut s = STATE.lock().unwrap();
+    *s = CoverageState::empty();
+    ENABLED.store(true, Ordering::Relaxed);
+}
+
+pub fn is_enabled() -> bool {
+    ENABLED.load(Ordering::Relaxed)
+}
+
+/// Intern a source path; returns the numeric id passed to `__tish_cov_hit__`.
+pub fn intern_file(path: &Path) -> u32 {
+    let key = normalize_path(path);
+    let mut s = STATE.lock().unwrap();
+    if let Some(&id) = s.file_index.get(&key) {
+        return id;
+    }
+    let id = s.files.len() as u32;
+    s.files.push(key.clone());
+    s.file_index.insert(key, id);
+    s.executable.push(BTreeSet::new());
+    s.hits.push(BTreeMap::new());
+    id
+}
+
+/// Claim `path` for instrumentation. Returns false if it was already rewritten.
+pub fn mark_instrumented(path: &Path) -> bool {
+    let key = normalize_path(path);
+    let mut s = STATE.lock().unwrap();
+    s.instrumented.insert(key)
+}
+
+pub fn mark_executable(file_id: u32, line: u32) {
+    if line == 0 {
+        return;
+    }
+    let mut s = STATE.lock().unwrap();
+    if let Some(lines) = s.executable.get_mut(file_id as usize) {
+        lines.insert(line);
+    }
+}
+
+fn record_hit(file_id: u32, line: u32) {
+    if line == 0 || !is_enabled() {
+        return;
+    }
+    let mut s = STATE.lock().unwrap();
+    if let Some(m) = s.hits.get_mut(file_id as usize) {
+        *m.entry(line).or_insert(0) += 1;
+    }
+}
+
+/// Core native installed as global `__tish_cov_hit__` for VM / via CoreFn for interp.
+pub fn hit_native(args: &[Value]) -> Value {
+    let file_id = args.first().and_then(|v| v.as_number()).unwrap_or(0.0) as u32;
+    let line = args.get(1).and_then(|v| v.as_number()).unwrap_or(0.0) as u32;
+    record_hit(file_id, line);
+    Value::Null
+}
+
+pub fn hit_value() -> Value {
+    Value::native(hit_native)
+}
+
+const HIT_GLOBAL: &str = "__tish_cov_hit__";
+
+pub fn hit_global_name() -> &'static str {
+    HIT_GLOBAL
+}
+
+/// Drop test/spec files from the report (coverage of code under test).
+pub fn retain_non_test_files() {
+    let mut s = STATE.lock().unwrap();
+    for id in 0..s.files.len() {
+        if crate::discovery::is_test_file_name(
+            Path::new(&s.files[id])
+                .file_name()
+                .and_then(|n| n.to_str())
+                .unwrap_or(""),
+        ) {
+            s.executable[id].clear();
+            s.hits[id].clear();
+        }
+    }
+}
+
+/// `(file, executable lines, hits)` for every file with instrumented lines, sorted by path.
+fn reportable(s: &CoverageState) -> Vec<(&String, &BTreeSet<u32>, &BTreeMap<u32, u64>)> {
+    let mut rows: Vec<_> = s
+        .files
+        .iter()
+        .enumerate()
+        .filter(|(id, _)| !s.executable[*id].is_empty())
+        .map(|(id, f)| (f, &s.executable[id], &s.hits[id]))
+        .collect();
+    rows.sort_by(|a, b| a.0.cmp(b.0));
+    rows
+}
+
+pub fn summary() -> (usize, usize) {
+    let s = STATE.lock().unwrap();
+    let mut total = 0usize;
+    let mut covered = 0usize;
+    for (_, lines, hits) in reportable(&s) {
+        for line in lines {
+            total += 1;
+            if hits.get(line).copied().unwrap_or(0) > 0 {
+                covered += 1;
+            }
+        }
+    }
+    (covered, total)
+}
+
+pub fn write_lcov(path: &Path) -> io::Result<()> {
+    if let Some(parent) = path.parent() {
+        fs::create_dir_all(parent)?;
+    }
+    let s = STATE.lock().unwrap();
+    let mut out = fs::File::create(path)?;
+    for (file, lines, file_hits) in reportable(&s) {
+        writeln!(out, "TN:")?;
+        writeln!(out, "SF:{file}")?;
+        let mut lf = 0u32;
+        let mut lh = 0u32;
+        for &line in lines {
+            let count = file_hits.get(&line).copied().unwrap_or(0);
+            writeln!(out, "DA:{line},{count}")?;
+            lf += 1;
+            if count > 0 {
+                lh += 1;
+            }
+        }
+        writeln!(out, "LF:{lf}")?;
+        writeln!(out, "LH:{lh}")?;
+        writeln!(out, "end_of_record")?;
+    }
+    Ok(())
+}
+
+pub fn print_summary<W: Write>(mut w: W) -> io::Result<()> {
+    let (covered, total) = summary();
+    if total == 0 {
+        // "100%" of nothing reads as a passing gate. Say what actually happened.
+        writeln!(
+            w,
+            "\nCoverage: no non-test source was executed — nothing to report."
+        )?;
+        return Ok(());
+    }
+    let pct = (covered as f64) * 100.0 / (total as f64);
+    writeln!(w, "\nCoverage: {covered}/{total} lines ({pct:.1}%)")?;
+    let s = STATE.lock().unwrap();
+    for (file, lines, hits) in reportable(&s) {
+        let t = lines.len();
+        let c = lines
+            .iter()
+            .filter(|l| hits.get(l).copied().unwrap_or(0) > 0)
+            .count();
+        let p = if t == 0 {
+            0.0
+        } else {
+            (c as f64) * 100.0 / (t as f64)
+        };
+        writeln!(w, "  {p:5.1}%  {c}/{t}  {}", short_path(file))?;
+    }
+    Ok(())
+}
+
+pub fn default_dir() -> PathBuf {
+    PathBuf::from("coverage")
+}
+
+fn normalize_path(p: &Path) -> String {
+    p.canonicalize()
+        .unwrap_or_else(|_| p.to_path_buf())
+        .to_string_lossy()
+        .into_owned()
+}
+
+fn short_path(p: &str) -> &str {
+    if let Ok(cwd) = std::env::current_dir() {
+        if let Ok(rel) = Path::new(p).strip_prefix(&cwd) {
+            if let Some(s) = rel.to_str() {
+                return s;
+            }
+        }
+    }
+    p
+}

package/crates/tish_test/src/deep_equal.rs

@@ -0,0 +1,261 @@
+//! Shared deep strict equality for `expect.toEqual` and `assert.deepStrictEqual`.
+
+use std::collections::HashSet;
+
+use tishlang_core::{ObjectData, Value, VmRef};
+
+fn same_value_zero_num(a: f64, b: f64) -> bool {
+    if a.is_nan() && b.is_nan() {
+        return true;
+    }
+    if a == 0.0 && b == 0.0 {
+        return true;
+    }
+    a == b
+}
+
+fn ptr_key_obj(o: &VmRef<ObjectData>) -> usize {
+    o.as_ptr() as usize
+}
+
+fn ptr_key_arr(a: &VmRef<Vec<Value>>) -> usize {
+    a.as_ptr() as usize
+}
+
+fn type_name_of(v: &Value) -> &'static str {
+    match v {
+        Value::Null => "null",
+        Value::Bool(_) => "Boolean",
+        Value::Number(_) => "Number",
+        Value::String(_) => "String",
+        Value::Symbol(_) => "Symbol",
+        Value::Array(_) | Value::NumberArray(_) => "Array",
+        Value::Object(_) => "Object",
+        Value::Function(_) => "Function",
+        #[cfg(feature = "regex")]
+        Value::RegExp(_) => "RegExp",
+        Value::Promise(_) => "Promise",
+        Value::Opaque(_) => "Object",
+    }
+}
+
+/// Jest-style asymmetric matchers (`expect.any`, `objectContaining`, …) on the expected side.
+fn asymmetric_match(
+    actual: &Value,
+    expected: &Value,
+    seen: &mut HashSet<(usize, usize)>,
+) -> Option<bool> {
+    let Value::Object(e) = expected else {
+        return None;
+    };
+    let eb = e.borrow();
+    let Some(Value::String(kind)) = eb.strings.get(crate::expect::ASYMMETRIC_KEY) else {
+        return None;
+    };
+    Some(match kind.as_str() {
+        "anything" => !matches!(actual, Value::Null),
+        "any" => {
+            let want = eb
+                .strings
+                .get("typeName")
+                .map(|v| v.to_display_string())
+                .unwrap_or_else(|| "Object".into());
+            let got = type_name_of(actual);
+            want.eq_ignore_ascii_case(got)
+                || (want.eq_ignore_ascii_case("Object") && matches!(actual, Value::Object(_)))
+        }
+        "objectContaining" => {
+            let sample = eb.strings.get("sample").cloned().unwrap_or(Value::Null);
+            partial_deep_strict_equal(actual, &sample)
+        }
+        "arrayContaining" => {
+            // The sample needs the same packed-array materialization as `actual`; a numeric
+            // literal like `[1, 2]` can arrive as a `NumberArray`.
+            let sample = eb
+                .strings
+                .get("sample")
+                .cloned()
+                .unwrap_or(Value::Null)
+                .coerce_number_array();
+            let Value::Array(want) = sample else {
+                return Some(false);
+            };
+            let actual_coerced = actual.clone().coerce_number_array();
+            let Value::Array(haystack) = actual_coerced else {
+                return Some(false);
+            };
+            let needles: Vec<Value> = want.borrow().clone();
+            let hay: Vec<Value> = haystack.borrow().clone();
+            needles.iter().all(|needle| {
+                hay.iter()
+                    .any(|item| deep_strict_equal_inner(item, needle, seen))
+            })
+        }
+        "stringMatching" => {
+            let sample = eb.strings.get("sample").cloned().unwrap_or(Value::Null);
+            let Value::String(s) = actual else {
+                return Some(false);
+            };
+            match sample {
+                Value::String(pat) => s.contains(pat.as_str()),
+                #[cfg(feature = "regex")]
+                Value::RegExp(re) => re.borrow_mut().test(s),
+                _ => false,
+            }
+        }
+        _ => false,
+    })
+}
+
+/// Deep strict equality with cycle detection.
+pub fn deep_strict_equal(a: &Value, b: &Value) -> bool {
+    let mut seen = HashSet::new();
+    deep_strict_equal_inner(a, b, &mut seen)
+}
+
+fn deep_strict_equal_inner(a: &Value, b: &Value, seen: &mut HashSet<(usize, usize)>) -> bool {
+    // Materialize packed number arrays to generic arrays for structural compare.
+    let a = a.clone().coerce_number_array();
+    let b = b.clone().coerce_number_array();
+
+    if let Some(ok) = asymmetric_match(&a, &b, seen) {
+        return ok;
+    }
+    if let Some(ok) = asymmetric_match(&b, &a, seen) {
+        return ok;
+    }
+
+    match (&a, &b) {
+        (Value::Null, Value::Null) => true,
+        (Value::Bool(x), Value::Bool(y)) => x == y,
+        (Value::Number(x), Value::Number(y)) => same_value_zero_num(*x, *y),
+        (Value::String(x), Value::String(y)) => x.as_str() == y.as_str(),
+        (Value::Symbol(x), Value::Symbol(y)) => std::sync::Arc::ptr_eq(x, y),
+        (Value::Array(x), Value::Array(y)) => {
+            if VmRef::ptr_eq(x, y) {
+                return true;
+            }
+            let kx = ptr_key_arr(x);
+            let ky = ptr_key_arr(y);
+            let pair = (kx.min(ky), kx.max(ky));
+            if !seen.insert(pair) {
+                return true;
+            }
+            let xb = x.borrow();
+            let yb = y.borrow();
+            if xb.len() != yb.len() {
+                return false;
+            }
+            xb.iter()
+                .zip(yb.iter())
+                .all(|(u, v)| deep_strict_equal_inner(u, v, seen))
+        }
+        (Value::Object(x), Value::Object(y)) => {
+            if VmRef::ptr_eq(x, y) {
+                return true;
+            }
+            let kx = ptr_key_obj(x);
+            let ky = ptr_key_obj(y);
+            let pair = (kx.min(ky), kx.max(ky));
+            if !seen.insert(pair) {
+                return true;
+            }
+            let xb = x.borrow();
+            let yb = y.borrow();
+            if xb.strings.len() != yb.strings.len() {
+                return false;
+            }
+            for (k, v) in xb.strings.iter() {
+                match yb.strings.get(k) {
+                    Some(ov) => {
+                        if !deep_strict_equal_inner(v, ov, seen) {
+                            return false;
+                        }
+                    }
+                    None => return false,
+                }
+            }
+            true
+        }
+        #[cfg(feature = "regex")]
+        (Value::RegExp(x), Value::RegExp(y)) => {
+            let xb = x.borrow();
+            let yb = y.borrow();
+            xb.source == yb.source && format!("{}", xb.flags) == format!("{}", yb.flags)
+        }
+        // Jest compares functions by identity: `expect(fn).toEqual(fn)` passes, two distinct
+        // functions never do. Returning false unconditionally failed the identity case.
+        (Value::Function(x), Value::Function(y)) => std::sync::Arc::ptr_eq(x, y),
+        (Value::Opaque(x), Value::Opaque(y)) => std::sync::Arc::ptr_eq(x, y),
+        _ => false,
+    }
+}
+
+/// Partial deep strict: every key in `expected` exists in `actual` with matching values.
+pub fn partial_deep_strict_equal(actual: &Value, expected: &Value) -> bool {
+    match (actual, expected) {
+        (Value::Object(a), Value::Object(e)) => {
+            let ab = a.borrow();
+            let eb = e.borrow();
+            for (k, ev) in eb.strings.iter() {
+                match ab.strings.get(k) {
+                    Some(av) => {
+                        if matches!(ev, Value::Object(_) | Value::Array(_)) {
+                            if !partial_deep_strict_equal(av, ev) {
+                                return false;
+                            }
+                        } else if !deep_strict_equal(av, ev) {
+                            return false;
+                        }
+                    }
+                    None => return false,
+                }
+            }
+            true
+        }
+        (Value::Array(a), Value::Array(e)) => {
+            let ab = a.borrow();
+            let eb = e.borrow();
+            if eb.len() > ab.len() {
+                return false;
+            }
+            for (ev, av) in eb.iter().zip(ab.iter()) {
+                if matches!(ev, Value::Object(_) | Value::Array(_)) {
+                    if !partial_deep_strict_equal(av, ev) {
+                        return false;
+                    }
+                } else if !deep_strict_equal(av, ev) {
+                    return false;
+                }
+            }
+            true
+        }
+        _ => deep_strict_equal(actual, expected),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use tishlang_core::{Arc, ObjectMap};
+
+    #[test]
+    fn primitives() {
+        assert!(deep_strict_equal(&Value::Null, &Value::Null));
+        assert!(deep_strict_equal(&Value::Number(1.0), &Value::Number(1.0)));
+        assert!(deep_strict_equal(
+            &Value::Number(f64::NAN),
+            &Value::Number(f64::NAN)
+        ));
+        assert!(!deep_strict_equal(&Value::Number(1.0), &Value::Number(2.0)));
+    }
+
+    #[test]
+    fn objects() {
+        let mut m1 = ObjectMap::default();
+        m1.insert(Arc::from("a"), Value::Number(1.0));
+        let mut m2 = ObjectMap::default();
+        m2.insert(Arc::from("a"), Value::Number(1.0));
+        assert!(deep_strict_equal(&Value::object(m1), &Value::object(m2)));
+    }
+}

package/crates/tish_test/src/discovery.rs

@@ -0,0 +1,70 @@
+//! Discover `*.test.tish` / `*_test.tish` / `*.spec.tish` / `*_spec.tish` files.
+
+use std::path::{Path, PathBuf};
+
+use walkdir::WalkDir;
+
+/// Return true if `name` matches a recognized test file pattern.
+pub fn is_test_file_name(name: &str) -> bool {
+    let lower = name.to_ascii_lowercase();
+    if !lower.ends_with(".tish") {
+        return false;
+    }
+    lower.ends_with(".test.tish")
+        || lower.ends_with("_test.tish")
+        || lower.ends_with(".spec.tish")
+        || lower.ends_with("_spec.tish")
+}
+
+/// Walk `roots` for test files. Optional `filters` keep paths whose display string
+/// contains every substring (case-sensitive, Jest-style path filter).
+pub fn discover_tests(roots: &[PathBuf], filters: &[String]) -> Vec<PathBuf> {
+    let mut out = Vec::new();
+    for root in roots {
+        if root.is_file() {
+            // An explicit file argument runs even without a test-file suffix, so
+            // `tish test path/to/one.tish` works.
+            if let Some(name) = root.file_name().and_then(|n| n.to_str()) {
+                let is_candidate =
+                    is_test_file_name(name) || root.extension().map(|e| e == "tish") == Some(true);
+                if is_candidate && path_matches(root, filters) {
+                    out.push(root.clone());
+                }
+            }
+            continue;
+        }
+        if !root.exists() {
+            continue;
+        }
+        for entry in WalkDir::new(root)
+            .follow_links(false)
+            .into_iter()
+            .filter_map(|e| e.ok())
+        {
+            if !entry.file_type().is_file() {
+                continue;
+            }
+            let path = entry.path();
+            let Some(name) = path.file_name().and_then(|n| n.to_str()) else {
+                continue;
+            };
+            if !is_test_file_name(name) {
+                continue;
+            }
+            if path_matches(path, filters) {
+                out.push(path.to_path_buf());
+            }
+        }
+    }
+    out.sort();
+    out.dedup();
+    out
+}
+
+fn path_matches(path: &Path, filters: &[String]) -> bool {
+    if filters.is_empty() {
+        return true;
+    }
+    let s = path.to_string_lossy();
+    filters.iter().all(|f| s.contains(f.as_str()))
+}