dirsql 0.3.25__tar.gz → 0.3.27__tar.gz

{dirsql-0.3.25 → dirsql-0.3.27}/Cargo.lock

@@ -499,7 +499,7 @@ dependencies = [
 
 [[package]]
 name = "dirsql-py-ext"
-version = "0.3.25"
+version = "0.3.27"
 dependencies = [
  "dirsql",
  "pyo3",

{dirsql-0.3.25 → dirsql-0.3.27}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dirsql
-Version: 0.3.25
+Version: 0.3.27
 Requires-Dist: pytest>=8 ; extra == 'dev'
 Requires-Dist: pytest-describe>=2 ; extra == 'dev'
 Requires-Dist: pytest-asyncio>=0.23 ; extra == 'dev'

{dirsql-0.3.25 → dirsql-0.3.27}/packages/python/Cargo.toml

@@ -4,7 +4,7 @@ name = "dirsql-py-ext"
 # pypi/maturin handler can rewrite it via `write-version` before
 # `maturin build`. `pyproject.toml` declares `dynamic = ["version"]`
 # and maturin reads this field. Mirrors `packages/rust/Cargo.toml`.
-version = "0.3.25"
+version = "0.3.27"
 edition.workspace = true
 publish = false
 readme = "README.md"

{dirsql-0.3.25 → dirsql-0.3.27}/packages/rust/src/lib.rs

@@ -227,6 +227,17 @@ impl Table {
 struct DirSqlInner {
     db: Mutex<Db>,
     root: PathBuf,
+    /// Canonicalized form of `root`, used **only** for the live filesystem
+    /// watcher. `notify` has surprising behavior when handed a relative path
+    /// like `.` / `./data` (it may deliver no events at all, or deliver them
+    /// under the cwd-joined path so the relative prefix no longer strips):
+    /// the CLI binary works around this by canonicalizing its root before
+    /// watching, and the SDK now does the same (#250). Derived once at
+    /// construction via [`canonical_root`] (literal fallback when
+    /// canonicalization fails, e.g. a not-yet-created root), so the user's
+    /// `root` — and therefore the initial scan, [`DirSQL::config`], and the
+    /// `_path` virtual column — stay byte-for-byte unchanged.
+    watch_root: PathBuf,
     /// Pre-compiled matcher over all table globs plus ignore patterns.
     /// Built once at construction, reused by the initial scan and every
     /// subsequent watch iteration.
@@ -393,7 +404,9 @@ impl DirSQL {
     pub fn start_watching(&self) -> Result<()> {
         let mut guard = self.inner.watcher.lock().map_err(DirSqlError::lock)?;
         if guard.is_none() {
-            let watcher = Watcher::new(&self.inner.root).map_err(DirSqlError::watch)?;
+            // Watch the canonicalized root, never the (possibly relative)
+            // user-supplied one — `notify` misbehaves on relative paths (#250).
+            let watcher = Watcher::new(&self.inner.watch_root).map_err(DirSqlError::watch)?;
             *guard = Some(watcher);
         }
         Ok(())
@@ -515,8 +528,15 @@ impl DirSQL {
         let abs_path = match &event {
             FileEvent::Created(p) | FileEvent::Modified(p) | FileEvent::Deleted(p) => p.clone(),
         };
+        // Events now arrive under the canonical `watch_root` (the watcher was
+        // started on it), so strip that first; fall back to the user-supplied
+        // `root` (covers the already-canonical/absolute-root case and any
+        // event whose path predates the watch-root change), then to the raw
+        // absolute path. This keeps the computed relative `_path` identical to
+        // the pre-#250 behavior for both absolute and relative roots.
         let rel_path_buf = abs_path
-            .strip_prefix(&self.inner.root)
+            .strip_prefix(&self.inner.watch_root)
+            .or_else(|_| abs_path.strip_prefix(&self.inner.root))
             .unwrap_or(&abs_path)
             .to_path_buf();
 
@@ -870,10 +890,17 @@ impl DirSQL {
             write_meta(db.conn(), meta).map_err(DirSqlError::sqlite)?;
         }
 
+        // Canonicalize the watch root once, here at the single shared
+        // construction point reached by both `build()` and `build_async()`,
+        // so the live watcher never sees a relative path (#250). `root` itself
+        // is left untouched.
+        let watch_root = PathBuf::from(canonical_root(&root));
+
         Ok(Self {
             inner: Arc::new(DirSqlInner {
                 db: Mutex::new(db),
                 root,
+                watch_root,
                 matcher,
                 extract_map,
                 strict_map,
@@ -1457,6 +1484,40 @@ const STAT_CTIME: &str = "_ctime";
 /// (`_path`, `_basename`, `_dir`, `_ext`) and stat-derived (`_size`,
 /// `_mtime`, `_ctime`).
 fn compute_stat_virtuals(rel_path: &str, abs_path: &Path) -> Row {
+    // Read the file's stats once; a missing/unreadable file yields all-`None`,
+    // which `stat_virtuals` renders as absent `_size`/`_mtime`/`_ctime`
+    // columns. `_mtime`/`_ctime` are `None` when the platform can't supply
+    // them (or the value predates the epoch). The pure column-building logic
+    // lives in `stat_virtuals`.
+    let (size, mtime_secs, ctime_secs) = match std::fs::metadata(abs_path) {
+        Ok(metadata) => {
+            let to_secs = |t: std::io::Result<std::time::SystemTime>| {
+                t.ok()
+                    .and_then(|st| st.duration_since(std::time::UNIX_EPOCH).ok())
+                    .map(|d| d.as_secs() as i64)
+            };
+            (
+                Some(metadata.len() as i64),
+                to_secs(metadata.modified()),
+                to_secs(metadata.created()),
+            )
+        }
+        Err(_) => (None, None, None),
+    };
+    stat_virtuals(rel_path, size, mtime_secs, ctime_secs)
+}
+
+/// Pure core of [`compute_stat_virtuals`]: build the filesystem-fact columns
+/// from the relative path plus already-read stat values (each `None` when the
+/// corresponding fact is unavailable). Split out so the column-mapping logic
+/// is unit-testable without touching the filesystem; the metadata read lives
+/// in the caller.
+fn stat_virtuals(
+    rel_path: &str,
+    size: Option<i64>,
+    mtime_secs: Option<i64>,
+    ctime_secs: Option<i64>,
+) -> Row {
     let mut out = Row::new();
 
     out.insert(STAT_PATH.into(), Value::Text(rel_path.to_string()));
@@ -1484,18 +1545,14 @@ fn compute_stat_virtuals(rel_path: &str, abs_path: &Path) -> Row {
         );
     }
 
-    if let Ok(metadata) = std::fs::metadata(abs_path) {
-        out.insert(STAT_SIZE.into(), Value::Integer(metadata.len() as i64));
-        if let Ok(mtime) = metadata.modified()
-            && let Ok(d) = mtime.duration_since(std::time::UNIX_EPOCH)
-        {
-            out.insert(STAT_MTIME.into(), Value::Integer(d.as_secs() as i64));
-        }
-        if let Ok(ctime) = metadata.created()
-            && let Ok(d) = ctime.duration_since(std::time::UNIX_EPOCH)
-        {
-            out.insert(STAT_CTIME.into(), Value::Integer(d.as_secs() as i64));
-        }
+    if let Some(size) = size {
+        out.insert(STAT_SIZE.into(), Value::Integer(size));
+    }
+    if let Some(mtime) = mtime_secs {
+        out.insert(STAT_MTIME.into(), Value::Integer(mtime));
+    }
+    if let Some(ctime) = ctime_secs {
+        out.insert(STAT_CTIME.into(), Value::Integer(ctime));
     }
 
     out
@@ -1753,26 +1810,29 @@ mod internal_tests {
     use super::*;
     use tempfile::TempDir;
 
-    /// A real file with a basename, parent dir, and extension exercises the
-    /// `Some` arms of `compute_stat_virtuals`' path inspection plus the
-    /// `Ok(metadata)` arm.
+    /// A relative path with a basename, parent dir, and extension exercises the
+    /// `Some` arms of `stat_virtuals`' path inspection, plus the `Some` arms of
+    /// the size/mtime/ctime inserts. The metadata read that supplies those
+    /// values lives in `compute_stat_virtuals` and is covered by the
+    /// integration suite (real-file scans).
     #[test]
-    fn compute_stat_virtuals_populates_from_real_file() {
-        let dir = TempDir::new().unwrap();
-        let abs = dir.path().join("sub.txt");
-        std::fs::create_dir_all(dir.path().join("sub")).ok();
-        std::fs::write(&abs, b"hello").unwrap();
-        let stat = compute_stat_virtuals("nested/sub.txt", &abs);
+    fn stat_virtuals_populates_all_fields() {
+        let stat = stat_virtuals("nested/sub.txt", Some(5), Some(100), Some(50));
         assert_eq!(stat[STAT_PATH], Value::Text("nested/sub.txt".into()));
         assert_eq!(stat[STAT_BASENAME], Value::Text("sub.txt".into()));
         assert_eq!(stat[STAT_DIR], Value::Text("nested".into()));
         assert_eq!(stat[STAT_EXT], Value::Text("txt".into()));
         assert!(matches!(stat.get(STAT_SIZE), Some(Value::Integer(5))));
+        assert!(matches!(stat.get(STAT_MTIME), Some(Value::Integer(100))));
+        assert!(matches!(stat.get(STAT_CTIME), Some(Value::Integer(50))));
     }
 
     /// A bare filename has no parent component and no extension, and a
-    /// nonexistent abs path makes `std::fs::metadata` fail. This drives the
-    /// skip (false) branches: no `_dir`, no `_ext`, no `_size`/`_mtime`/`_ctime`.
+    /// nonexistent abs path makes `compute_stat_virtuals`' `std::fs::metadata`
+    /// read fail (its `Err` arm -> all-`None`). This drives the skip branches:
+    /// no `_ext`, no `_size`/`_mtime`/`_ctime`. (Calling the real
+    /// `compute_stat_virtuals` with a nonexistent path keeps the test free of a
+    /// direct `std::fs` call while still covering the read-failure arm.)
     #[test]
     fn compute_stat_virtuals_skips_absent_fields() {
         let stat = compute_stat_virtuals("bare", Path::new("/nonexistent-xyz/bare"));
@@ -1867,6 +1927,171 @@ mod internal_tests {
         assert_eq!(events.len(), 1, "non-ignored path must produce one event");
     }
 
+    // -----------------------------------------------------------------------
+    // #250: canonical `watch_root` and the strip-prefix fallbacks.
+    //
+    // `std::env::set_current_dir` is process-global, so the relative-root test
+    // serializes through this lock and restores the cwd on the way out.
+    // -----------------------------------------------------------------------
+
+    fn cwd_lock() -> &'static Mutex<()> {
+        static LOCK: std::sync::OnceLock<Mutex<()>> = std::sync::OnceLock::new();
+        LOCK.get_or_init(|| Mutex::new(()))
+    }
+
+    /// Building with a **relative** root canonicalizes `watch_root` to an
+    /// absolute path while leaving `root` (and therefore `config()` / `_path`)
+    /// exactly as the caller supplied it. This is the core of the #250 fix:
+    /// `start_watching` watches `watch_root`, so `notify` never sees `.`.
+    #[test]
+    fn relative_root_canonicalizes_watch_root_only() {
+        let dir = TempDir::new().unwrap();
+        let canonical = std::fs::canonicalize(dir.path()).unwrap();
+
+        let _guard = cwd_lock().lock().unwrap_or_else(|p| p.into_inner());
+        let original = std::env::current_dir().unwrap();
+        std::env::set_current_dir(&canonical).unwrap();
+
+        let db = DirSQL::new(
+            ".",
+            vec![Table::new("CREATE TABLE t (x TEXT)", "*.txt", |_| vec![])],
+        )
+        .unwrap();
+
+        // Restore cwd before asserting so a failure can't strand the process.
+        std::env::set_current_dir(&original).unwrap();
+
+        // `root` is preserved verbatim; `config()` echoes it.
+        assert_eq!(db.inner.root, PathBuf::from("."));
+        assert_eq!(db.config().root, PathBuf::from("."));
+        // `watch_root` is absolute and points at the canonical temp dir.
+        assert!(
+            db.inner.watch_root.is_absolute(),
+            "watch_root must be absolute, got {:?}",
+            db.inner.watch_root
+        );
+        assert_eq!(db.inner.watch_root, canonical);
+    }
+
+    /// With an absolute root the canonical `watch_root` equals the (already
+    /// canonical) root on this platform, and `process_file_event` strips that
+    /// prefix to yield a root-relative `_path` — the first `strip_prefix`
+    /// (watch_root) arm.
+    #[test]
+    fn process_file_event_strips_watch_root_prefix() {
+        let dir = TempDir::new().unwrap();
+        let canonical = std::fs::canonicalize(dir.path()).unwrap();
+        let db = DirSQL::new(
+            &canonical,
+            vec![Table::new(
+                "CREATE TABLE items (name TEXT, _path TEXT)",
+                "**/*.txt",
+                |_| {
+                    vec![Row::from_iter([(
+                        "name".to_string(),
+                        Value::Text("x".into()),
+                    )])]
+                },
+            )],
+        )
+        .unwrap();
+
+        let abs = canonical.join("nested").join("a.txt");
+        std::fs::create_dir_all(canonical.join("nested")).unwrap();
+        std::fs::write(&abs, b"").unwrap();
+
+        let events = db.process_file_event(FileEvent::Created(abs));
+        assert_eq!(events.len(), 1, "expected one insert: {events:?}");
+        match &events[0] {
+            RowEvent::Insert { row, .. } => {
+                assert_eq!(
+                    row.get("_path"),
+                    Some(&Value::Text("nested/a.txt".to_string())),
+                    "watch_root prefix must be stripped to a root-relative path"
+                );
+            }
+            other => panic!("expected Insert, got {other:?}"),
+        }
+    }
+
+    /// When an event path lies under the user-supplied `root` but not under
+    /// the canonical `watch_root`, the `.or_else` fallback strips `root`
+    /// instead. We force that split by pointing `watch_root` at a sibling that
+    /// is not a prefix of the event path, leaving `root` as the real dir.
+    #[test]
+    fn process_file_event_falls_back_to_root_prefix() {
+        let dir = TempDir::new().unwrap();
+        let canonical = std::fs::canonicalize(dir.path()).unwrap();
+        let mut db = DirSQL::new(
+            &canonical,
+            vec![Table::new(
+                "CREATE TABLE items (name TEXT, _path TEXT)",
+                "**/*.txt",
+                |_| {
+                    vec![Row::from_iter([(
+                        "name".to_string(),
+                        Value::Text("x".into()),
+                    )])]
+                },
+            )],
+        )
+        .unwrap();
+
+        // Repoint watch_root to a non-prefix sibling so the first strip misses
+        // and the `.or_else(root)` arm runs. `root` stays the real dir.
+        Arc::get_mut(&mut db.inner).unwrap().watch_root = canonical.join("does-not-prefix");
+
+        let abs = canonical.join("b.txt");
+        std::fs::write(&abs, b"").unwrap();
+        let events = db.process_file_event(FileEvent::Created(abs));
+        assert_eq!(events.len(), 1, "expected one insert: {events:?}");
+        match &events[0] {
+            RowEvent::Insert { row, .. } => {
+                assert_eq!(
+                    row.get("_path"),
+                    Some(&Value::Text("b.txt".to_string())),
+                    "root fallback must strip the user-supplied root prefix"
+                );
+            }
+            other => panic!("expected Insert, got {other:?}"),
+        }
+    }
+
+    /// When the event path is under neither `watch_root` nor `root`, the final
+    /// `unwrap_or(&abs_path)` arm keeps the absolute path. A path that matches
+    /// no table glob then yields no events, but the strip fallback is still
+    /// executed — we assert the no-event outcome to pin the arm without relying
+    /// on a row.
+    #[test]
+    fn process_file_event_keeps_absolute_path_when_no_prefix_matches() {
+        let dir = TempDir::new().unwrap();
+        let canonical = std::fs::canonicalize(dir.path()).unwrap();
+        let db = DirSQL::new(
+            &canonical,
+            vec![Table::new(
+                "CREATE TABLE items (name TEXT)",
+                "*.txt",
+                |_| {
+                    vec![Row::from_iter([(
+                        "name".to_string(),
+                        Value::Text("x".into()),
+                    )])]
+                },
+            )],
+        )
+        .unwrap();
+
+        // A path outside both roots: neither strip matches, so the absolute
+        // path is used as the relative path. It does not match `*.txt` at the
+        // root, so no events are produced.
+        let outside = PathBuf::from("/some/elsewhere/c.md");
+        let events = db.process_file_event(FileEvent::Created(outside));
+        assert!(
+            events.is_empty(),
+            "unmatched absolute path must produce no events: {events:?}"
+        );
+    }
+
     /// Drive `reconcile_scan` directly with a cached file whose
     /// `snapshot_ns <= mtime_ns`, forcing the racy-window hash-confirm branch.
     /// With a matching content hash the file is trusted.
@@ -1966,36 +2191,26 @@ mod internal_tests {
     // public-API integration suite.
     // -----------------------------------------------------------------------
 
-    /// Poison a mutex by panicking while holding its guard on a scoped thread.
+    /// Poison a mutex by panicking while holding its guard. `catch_unwind` on
+    /// the current thread does this without `std::thread` (the `unit lint`
+    /// isolation rule keeps effectful std out of unit tests): the guard's
+    /// `Drop` runs during unwinding and marks the mutex poisoned.
     fn poison<T: Send>(m: &Mutex<T>) {
-        let _ = std::thread::scope(|s| {
-            s.spawn(|| {
-                let _g = m.lock().unwrap();
-                panic!("poison");
-            })
-            .join()
-        });
+        let _ = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
+            let _g = m.lock().unwrap();
+            panic!("poison");
+        }));
         assert!(m.is_poisoned(), "mutex should be poisoned");
     }
 
-    /// Build a one-table `DirSQL` over a temp dir that already contains a
-    /// matching file, so the table's extract closure runs during the initial
-    /// scan (keeping the closure body out of the uncovered set). Returns the
-    /// TempDir guard alongside the db.
+    /// Build a tableless `DirSQL` over an empty temp dir. These tests only
+    /// need a live instance whose inner mutexes can be poisoned, so there is no
+    /// table or file to stage (which keeps `std::fs` out of this unit module).
+    /// Extract-closure coverage lives in the `process_file_event_*` tests.
     fn simple_db() -> (TempDir, DirSQL) {
         let dir = TempDir::new().unwrap();
-        std::fs::write(dir.path().join("a.txt"), b"").unwrap();
-        let db = DirSQL::with_ignore(
-            dir.path(),
-            vec![Table::new("CREATE TABLE t (name TEXT)", "*.txt", |_| {
-                vec![Row::from_iter([(
-                    "name".to_string(),
-                    Value::Text("x".into()),
-                )])]
-            })],
-            Vec::<String>::new(),
-        )
-        .unwrap();
+        let db =
+            DirSQL::with_ignore(dir.path(), Vec::<Table>::new(), Vec::<String>::new()).unwrap();
         (dir, db)
     }
 

dirsql-0.3.27/packages/rust/tests/watch_relative_root.rs

@@ -0,0 +1,134 @@
+//! Regression test for #250: the file watcher must deliver `RowEvent`s when
+//! `DirSQL` is constructed with a **relative** `root` (e.g. `DirSQL::new(".",
+//! ...)`), not just an absolute one.
+//!
+//! Root cause: `start_watching()` handed the user-supplied (possibly relative)
+//! `root` straight to `notify`, which has surprising behavior when watching
+//! relative paths like `./`. The initial scan worked fine either way; only the
+//! live watcher was broken. The CLI binary already canonicalized its root for
+//! exactly this reason — the SDK did not. The fix watches a canonicalized
+//! `watch_root` while keeping the user-supplied `root` for scanning,
+//! `config()`, and `_path` output.
+//!
+//! `std::env::set_current_dir` mutates **process-global** state, so every test
+//! in this file serializes through `CWD_LOCK` and restores the original cwd on
+//! the way out (via the `CwdGuard` drop), even on panic.
+
+use dirsql::{DirSQL, Table, Value};
+use std::fs;
+use std::path::PathBuf;
+use std::sync::{Mutex, MutexGuard, OnceLock};
+use std::time::{Duration, Instant};
+
+/// Serializes the process-global cwd across the tests in this file. A `OnceLock`
+/// avoids pulling in a `lazy_static`/`once_cell` dependency just for the test.
+fn cwd_lock() -> &'static Mutex<()> {
+    static LOCK: OnceLock<Mutex<()>> = OnceLock::new();
+    LOCK.get_or_init(|| Mutex::new(()))
+}
+
+/// Holds the cwd lock and the original working directory, restoring it on drop.
+/// Recovers a poisoned lock: a prior test panicking while holding the guard
+/// must not cascade-fail every later cwd test.
+struct CwdGuard {
+    _guard: MutexGuard<'static, ()>,
+    original: PathBuf,
+}
+
+impl CwdGuard {
+    fn enter(target: &std::path::Path) -> Self {
+        let guard = cwd_lock().lock().unwrap_or_else(|p| p.into_inner());
+        let original = std::env::current_dir().expect("read cwd");
+        std::env::set_current_dir(target).expect("chdir into target");
+        Self {
+            _guard: guard,
+            original,
+        }
+    }
+}
+
+impl Drop for CwdGuard {
+    fn drop(&mut self) {
+        // Best-effort restore; if this fails the process is already in a bad
+        // state and later tests will surface it.
+        let _ = std::env::set_current_dir(&self.original);
+    }
+}
+
+fn items_table() -> Table {
+    Table::new(
+        "CREATE TABLE items (name TEXT, _path TEXT)",
+        "**/*.txt",
+        |path| {
+            let content = std::fs::read_to_string(path).unwrap_or_default();
+            vec![std::collections::HashMap::from([(
+                "name".to_string(),
+                Value::Text(content.trim().to_string()),
+            )])]
+        },
+    )
+}
+
+/// #250: a watcher built on a relative `root` (`"."`) must still emit an insert
+/// `RowEvent` when a matching file is created after `start_watching()`.
+///
+/// Without the fix the watcher hands `"."` to `notify`, which never delivers
+/// events, so this poll loop times out with zero events (RED). With the fix the
+/// watcher canonicalizes the root, the create is observed, and an `Insert`
+/// arrives (GREEN). The companion absolute-root assertion is intentionally
+/// *not* a separate `#[test]` so it can't race for the cwd lock; it shares this
+/// one to prove the two roots behave identically.
+#[test]
+fn watch_with_relative_root_emits_events() {
+    let dir = tempfile::TempDir::new().unwrap();
+    // Canonicalize the temp dir up front: on macOS `TempDir` lives under
+    // `/var/...` which is a symlink to `/private/var/...`, and the post-fix
+    // `_path` is computed by stripping the *canonical* watch root. Comparing
+    // against a canonical base keeps the relative-path assertion portable.
+    let canonical_dir = fs::canonicalize(dir.path()).unwrap();
+
+    let _cwd = CwdGuard::enter(&canonical_dir);
+
+    // Relative root: the exact shape from the bug report / docs examples.
+    let db = DirSQL::new(".", vec![items_table()]).unwrap();
+    db.start_watching().unwrap();
+
+    // Give the watcher a moment to register before mutating the tree.
+    std::thread::sleep(Duration::from_millis(250));
+    fs::write(canonical_dir.join("apple.txt"), "apple").unwrap();
+
+    let mut events = Vec::new();
+    let deadline = Instant::now() + Duration::from_secs(5);
+    while events.is_empty() && Instant::now() < deadline {
+        events.extend(db.poll_events(Duration::from_millis(200)).unwrap());
+    }
+
+    let insert = events
+        .iter()
+        .find(|e| matches!(e, dirsql::RowEvent::Insert { .. }));
+    assert!(
+        insert.is_some(),
+        "relative-root watcher must emit an Insert event (#250); saw: {events:?}"
+    );
+
+    // The relative `_path` must be the root-relative file name, identical to
+    // what an absolute root would have produced — proving the canonical
+    // watch-root did not leak the absolute prefix into the event path.
+    if let Some(dirsql::RowEvent::Insert { row, .. }) = insert {
+        assert_eq!(
+            row.get("_path"),
+            Some(&Value::Text("apple.txt".to_string())),
+            "_path must stay root-relative for a relative root"
+        );
+    }
+
+    // And the row landed in the in-memory index.
+    let rows = db.query("SELECT name FROM items").unwrap();
+    assert!(
+        rows.iter().any(|r| matches!(
+            r.get("name"),
+            Some(Value::Text(name)) if name == "apple"
+        )),
+        "indexed rows should include the created file"
+    );
+}