dirsql 0.3.80__tar.gz → 0.3.81__tar.gz

{dirsql-0.3.80 → dirsql-0.3.81}/Cargo.lock

@@ -500,7 +500,7 @@ dependencies = [
 
 [[package]]
 name = "dirsql-py-ext"
-version = "0.3.80"
+version = "0.3.81"
 dependencies = [
  "dirsql",
  "pyo3",

{dirsql-0.3.80 → dirsql-0.3.81}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dirsql
-Version: 0.3.80
+Version: 0.3.81
 Summary: Ephemeral SQL index over a local directory
 Keywords: sql,filesystem,directory,sqlite,index
 Author: Kevin Scott

{dirsql-0.3.80 → dirsql-0.3.81}/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.80"
+version = "0.3.81"
 edition.workspace = true
 publish = false
 readme = "README.md"

{dirsql-0.3.80 → dirsql-0.3.81}/packages/python/e2e-attestation.json

@@ -1,6 +1,6 @@
 {
   "command": "uv run python -m pytest tests/e2e/ -x -q",
-  "ran_at": 1783542175,
+  "ran_at": 1783543117,
   "exit_code": 0,
-  "commit": "327255640a688bbd372efc17ab3f64cc59e8f651"
+  "commit": "c3f426b7aea69084f30366fba44e4ca1dd743184"
 }

{dirsql-0.3.80 → dirsql-0.3.81}/packages/rust/src/db.rs

@@ -526,19 +526,64 @@ impl rusqlite::types::ToSql for Value {
 /// dirsql constrains table names to safe unquoted identifiers via
 /// [`validate_identifier`], so the handful of forms above are the only ones
 /// that can actually resolve to a usable table.
-pub fn parse_table_name(ddl: &str) -> Option<String> {
-    let upper = ddl.to_uppercase();
-    let idx = upper.find("CREATE TABLE")?;
-    let mut rest = ddl[idx + "CREATE TABLE".len()..].trim_start();
+/// Strip leading whitespace and SQL comments (`-- ...` to end-of-line and
+/// `/* ... */` blocks, repeated) from `s`. An unterminated block comment
+/// consumes the rest of the input. Every returned slice starts on a char
+/// boundary, so callers can index it safely.
+fn skip_ws_comments(s: &str) -> &str {
+    let mut s = s;
+    loop {
+        let trimmed = s.trim_start();
+        if let Some(after) = trimmed.strip_prefix("--") {
+            match after.find('\n') {
+                Some(i) => s = &after[i + 1..],
+                None => return "",
+            }
+        } else if let Some(after) = trimmed.strip_prefix("/*") {
+            match after.find("*/") {
+                Some(i) => s = &after[i + 2..],
+                None => return "",
+            }
+        } else {
+            return trimmed;
+        }
+    }
+}
+
+/// If `s` begins with the ASCII keyword `kw` (case-insensitive) followed by a
+/// non-identifier boundary, return the remainder after it; otherwise `None`.
+/// The boundary check keeps a longer identifier (`TABLES`, `iffy`) from
+/// matching a keyword prefix.
+fn strip_keyword_ci<'a>(s: &'a str, kw: &str) -> Option<&'a str> {
+    let bytes = s.as_bytes();
+    if bytes.len() < kw.len() || !bytes[..kw.len()].eq_ignore_ascii_case(kw.as_bytes()) {
+        return None;
+    }
+    let rest = &s[kw.len()..];
+    match rest.chars().next() {
+        Some(c) if c.is_alphanumeric() || c == '_' => None,
+        _ => Some(rest),
+    }
+}
 
-    // Skip optional "IF NOT EXISTS". `.get()` avoids slicing on a non-char
-    // boundary when the name itself begins with a multi-byte character.
-    const IF_NOT_EXISTS: &str = "IF NOT EXISTS";
-    if rest
-        .get(..IF_NOT_EXISTS.len())
-        .is_some_and(|p| p.eq_ignore_ascii_case(IF_NOT_EXISTS))
-    {
-        rest = rest[IF_NOT_EXISTS.len()..].trim_start();
+pub fn parse_table_name(ddl: &str) -> Option<String> {
+    // Match `CREATE TABLE` only as the *statement head*: skip leading
+    // whitespace and line/block comments and scan the original `ddl` by byte
+    // offset (never a `to_uppercase()` copy, whose length can differ from the
+    // source and mis-slice on Unicode). A `-- CREATE TABLE ...` comment must
+    // not hijack the name.
+    let rest = skip_ws_comments(ddl);
+    let rest = strip_keyword_ci(rest, "CREATE")?;
+    let rest = strip_keyword_ci(skip_ws_comments(rest), "TABLE")?;
+    let mut rest = skip_ws_comments(rest);
+
+    // Skip optional "IF NOT EXISTS". The keyword boundary check in
+    // `strip_keyword_ci` keeps a table literally named e.g. `iffy` from being
+    // mistaken for `IF`.
+    if let Some(after_if) = strip_keyword_ci(rest, "IF") {
+        let after_not = strip_keyword_ci(skip_ws_comments(after_if), "NOT")?;
+        let after_exists = strip_keyword_ci(skip_ws_comments(after_not), "EXISTS")?;
+        rest = skip_ws_comments(after_exists);
     }
 
     // `schema.table`: keep the last dot-separated segment. Each segment may
@@ -876,6 +921,59 @@ mod tests {
         assert_eq!(parse_table_name("CREATE TABLE (id TEXT)"), None);
     }
 
+    #[test]
+    fn parse_table_name_ignores_leading_line_comment() {
+        assert_eq!(
+            parse_table_name("-- create table old\nCREATE TABLE t (x TEXT)"),
+            Some("t".to_string())
+        );
+    }
+
+    #[test]
+    fn parse_table_name_ignores_leading_block_comment() {
+        assert_eq!(
+            parse_table_name("/* CREATE TABLE old */ CREATE TABLE t (x TEXT)"),
+            Some("t".to_string())
+        );
+    }
+
+    #[test]
+    fn parse_table_name_unterminated_comment_is_none() {
+        // Unterminated `--` and `/* */` comments consume the rest of the input,
+        // leaving no statement head.
+        assert_eq!(parse_table_name("-- no newline, no statement"), None);
+        assert_eq!(parse_table_name("/* unterminated CREATE TABLE t"), None);
+    }
+
+    #[test]
+    fn parse_table_name_rejects_keyword_prefix() {
+        // `CREATE TABLES` must not match the `TABLE` keyword prefix.
+        assert_eq!(parse_table_name("CREATE TABLES foo (id TEXT)"), None);
+    }
+
+    #[test]
+    fn parse_table_name_if_prefixed_name_is_not_if_not_exists() {
+        // A table whose name merely starts with `if` is not `IF NOT EXISTS`.
+        assert_eq!(
+            parse_table_name("CREATE TABLE ifx (id TEXT)"),
+            Some("ifx".to_string())
+        );
+    }
+
+    #[test]
+    fn parse_table_name_unicode_in_comment_does_not_panic() {
+        // A case-length-changing char (`fi`) in a comment must neither hijack
+        // the name nor panic on a byte-index slice.
+        assert_eq!(
+            parse_table_name("-- fi\nCREATE TABLE t (x TEXT)"),
+            Some("t".to_string())
+        );
+        assert_eq!(
+            parse_table_name("/* fififi */ CREATE TABLE t (x TEXT)"),
+            Some("t".to_string())
+        );
+    }
+
     #[test]
     fn get_table_columns_returns_user_columns_only() {
         let db = Db::new().unwrap();

{dirsql-0.3.80 → dirsql-0.3.81}/packages/rust/src/lib.rs

@@ -484,9 +484,13 @@ impl DirSQL {
     }
 
     fn handle_upsert(&self, table: &str, abs_path: &Path, rel_path: &str) -> Vec<RowEvent> {
-        // The file may have vanished between the watcher event and now.
-        match self.inner.fs.stat(abs_path) {
-            Ok(_) => {}
+        // The path may have vanished between the watcher event and now, or be a
+        // directory (a `mkdir` under the root matches a `**/*` glob). Only
+        // regular files become rows — mirror the initial scan, which skips
+        // non-files.
+        match self.inner.fs.is_file(abs_path) {
+            Ok(true) => {}
+            Ok(false) => return Vec::new(),
             Err(e) if e.kind() == std::io::ErrorKind::NotFound => return Vec::new(),
             Err(e) => return vec![error_event(Some(table), rel_path, e.to_string())],
         }
@@ -1215,6 +1219,8 @@ fn prepare_persist(
 /// tests can inject a deterministic double. Production always uses [`RealFs`].
 trait FileSystem: Send + Sync {
     fn stat(&self, path: &Path) -> std::io::Result<FileStat>;
+    /// Whether `path` is a regular file. `Err(NotFound)` when it doesn't exist.
+    fn is_file(&self, path: &Path) -> std::io::Result<bool>;
     /// BLAKE3-hash a file's contents.
     fn hash(&self, path: &Path) -> std::io::Result<[u8; 32]>;
     /// Canonicalize the watch root, falling back to the literal path.
@@ -1228,6 +1234,10 @@ impl FileSystem for RealFs {
         std::fs::metadata(path).map(|m| FileStat::from_metadata(&m))
     }
 
+    fn is_file(&self, path: &Path) -> std::io::Result<bool> {
+        std::fs::metadata(path).map(|m| m.is_file())
+    }
+
     fn hash(&self, path: &Path) -> std::io::Result<[u8; 32]> {
         hash_file(path)
     }
@@ -1822,15 +1832,19 @@ mod readonly_tests {
 mod internal_tests {
     use super::*;
     use std::collections::HashMap as StdHashMap;
+    use std::collections::HashSet as StdHashSet;
     use tempfile::TempDir;
 
     /// Deterministic [`FileSystem`] double: canned [`FileStat`]s and hashes;
-    /// any path not present stats/hashes as `NotFound`.
+    /// any path not present stats/hashes as `NotFound`. A path registered via
+    /// [`with_dir`](FakeFs::with_dir) reports as a non-file; any other stat'd
+    /// path reports as a regular file.
     #[derive(Default)]
     struct FakeFs {
         stats: StdHashMap<PathBuf, FileStat>,
         hashes: StdHashMap<PathBuf, [u8; 32]>,
         canonical_roots: StdHashMap<PathBuf, String>,
+        dirs: StdHashSet<PathBuf>,
     }
 
     impl FakeFs {
@@ -1840,6 +1854,12 @@ mod internal_tests {
             fs
         }
 
+        /// Register `path` as an existing non-file (a directory).
+        fn with_dir(mut self, path: impl Into<PathBuf>) -> Self {
+            self.dirs.insert(path.into());
+            self
+        }
+
         fn set_hash(&mut self, path: impl Into<PathBuf>, hash: [u8; 32]) {
             self.hashes.insert(path.into(), hash);
         }
@@ -1862,6 +1882,19 @@ mod internal_tests {
             })
         }
 
+        fn is_file(&self, path: &Path) -> std::io::Result<bool> {
+            if self.dirs.contains(path) {
+                return Ok(false);
+            }
+            if self.stats.contains_key(path) {
+                return Ok(true);
+            }
+            Err(std::io::Error::new(
+                std::io::ErrorKind::NotFound,
+                "fake: no such file",
+            ))
+        }
+
         fn hash(&self, path: &Path) -> std::io::Result<[u8; 32]> {
             self.hashes.get(path).copied().ok_or_else(|| {
                 std::io::Error::new(std::io::ErrorKind::NotFound, "fake: no such file")
@@ -2208,6 +2241,15 @@ mod internal_tests {
             fs.hash(&missing).is_err(),
             "hash of a missing path must error"
         );
+
+        assert!(
+            !fs.is_file(dir.path()).unwrap(),
+            "a directory must report is_file=false"
+        );
+        assert!(
+            fs.is_file(&missing).is_err(),
+            "is_file of a missing path must error"
+        );
         // A nonexistent path can't canonicalize, so the literal fallback runs.
         assert_eq!(
             fs.canonical_root(&missing),
@@ -2371,6 +2413,34 @@ mod internal_tests {
         assert!(dbg.contains("insert forbidden"), "got: {dbg}");
     }
 
+    #[test]
+    fn handle_upsert_skips_directory() {
+        // A `mkdir` under the root matches a `**/*` glob, but a directory must
+        // not become a row — mirror the initial scan's non-file skip.
+        let dir = TempDir::new().unwrap();
+        let subdir = dir.path().join("subdir");
+        let fake = FakeFs::default().with_dir(subdir.clone());
+        let db = DirSQL::with_ignore_and_fs(
+            dir.path(),
+            vec![Table::new("CREATE TABLE files (name TEXT)", "**/*", |_| {
+                vec![Row::from_iter([(
+                    "name".to_string(),
+                    Value::Text("x".into()),
+                )])]
+            })],
+            Vec::<String>::new(),
+            Arc::new(fake),
+        )
+        .unwrap();
+
+        let events = db.handle_upsert("files", &subdir, "subdir");
+        assert!(events.is_empty(), "a directory must not produce row events");
+        assert!(
+            db.query("SELECT * FROM files").unwrap().is_empty(),
+            "a directory must not insert a row"
+        );
+    }
+
     #[test]
     fn handle_upsert_returns_empty_when_file_vanished() {
         let (dir, db, _abs, _rel) = upsert_fixture();

{dirsql-0.3.80 → dirsql-0.3.81}/packages/rust/src/watcher.rs

@@ -1,3 +1,4 @@
+use notify::event::{ModifyKind, RenameMode};
 use notify::{
     Config, Event, EventKind, RecommendedWatcher, RecursiveMode, Watcher as NotifyWatcher,
 };
@@ -72,6 +73,12 @@ fn translate_event(event: &Event) -> Vec<FileEvent> {
     for path in &event.paths {
         let fe = match event.kind {
             EventKind::Create(_) => Some(FileEvent::Created(path.clone())),
+            // A rename OUT of the tree (inotify `IN_MOVED_FROM`) leaves no file
+            // behind, so it is a removal — otherwise the moved-away file's rows
+            // would persist.
+            EventKind::Modify(ModifyKind::Name(RenameMode::From)) => {
+                Some(FileEvent::Deleted(path.clone()))
+            }
             EventKind::Modify(_) => Some(FileEvent::Modified(path.clone())),
             EventKind::Remove(_) => Some(FileEvent::Deleted(path.clone())),
             _ => None,
@@ -117,6 +124,17 @@ fn remove_event(paths: Vec<PathBuf>) -> Event {
     }
 }
 
+#[cfg(test)]
+fn rename_from_event(paths: Vec<PathBuf>) -> Event {
+    Event {
+        kind: EventKind::Modify(notify::event::ModifyKind::Name(
+            notify::event::RenameMode::From,
+        )),
+        paths,
+        attrs: Default::default(),
+    }
+}
+
 #[cfg(test)]
 fn access_event(paths: Vec<PathBuf>) -> Event {
     Event {
@@ -167,6 +185,17 @@ mod tests {
         );
     }
 
+    #[test]
+    fn translate_event_maps_rename_from_to_delete() {
+        // inotify emits `Modify(Name(From))` when a file is renamed OUT of the
+        // watched tree; it must be treated as a removal so its rows are deleted.
+        let results = translate_event(&rename_from_event(vec![PathBuf::from("/tmp/moved.txt")]));
+        assert_eq!(
+            results,
+            vec![FileEvent::Deleted(PathBuf::from("/tmp/moved.txt"))]
+        );
+    }
+
     #[test]
     fn translate_event_multiple_paths() {
         let results = translate_event(&create_event(vec![