dirsql 0.4.91__tar.gz → 0.4.93__tar.gz

{dirsql-0.4.91 → dirsql-0.4.93}/Cargo.lock

@@ -552,7 +552,7 @@ checksum = "6184e33543162437515c2e2b48714794e37845ec9851711914eec9d308f6ebe8"
 
 [[package]]
 name = "dirsql"
-version = "0.4.91"
+version = "0.4.93"
 dependencies = [
  "assert_cmd",
  "axum",
@@ -603,7 +603,7 @@ dependencies = [
 
 [[package]]
 name = "dirsql-py-ext"
-version = "0.4.91"
+version = "0.4.93"
 dependencies = [
  "dirsql",
  "pyo3",

{dirsql-0.4.91 → dirsql-0.4.93}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dirsql
-Version: 0.4.91
+Version: 0.4.93
 Requires-Dist: bin-shim>=0.1
 Summary: Ephemeral SQL index over a local directory
 Keywords: sql,filesystem,directory,sqlite,index

{dirsql-0.4.91 → dirsql-0.4.93}/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.4.91"
+version = "0.4.93"
 # abi3 note: the `abi3-py310` pyo3 feature (below) builds ONE stable-ABI
 # `cp310-abi3` wheel per platform that loads on every CPython >= 3.10
 # (matching `pyproject.toml`'s `requires-python = ">=3.10"`), instead of

dirsql-0.4.93/packages/python/changelog.d/2026-10-06-config-dotnames.md

@@ -0,0 +1,3 @@
+**Changed** A declared `[[table]] glob` no longer matches a dot-named file or
+directory unless the glob spells it: `**/*.md` skips `.env.md` and
+`.hid/z.md`, while `.hid/*.md` lists `.hid/z.md`.

dirsql-0.4.93/packages/python/changelog.d/2026-10-06-config-links.md

@@ -0,0 +1,3 @@
+**Changed** A declared `[[table]] glob` skips `node_modules` unless the glob
+names it, and follows symlinks, as a path-table does. `**/*.js` no longer lists
+`node_modules/...`; `link.md -> top.md` and `linkdir/*` now list their rows.

dirsql-0.4.93/packages/python/e2e-attestations/claude-1258-config-dotnames.json

@@ -0,0 +1,7 @@
+{
+  "command": "uv run python -m pytest tests/e2e/glob_speed_dotfiles_test.py tests/e2e/glob_speed_recursive_test.py tests/e2e/glob_speed_matchers_test.py tests/e2e/query_contract_test.py -x -q",
+  "ran_at": 1791335904,
+  "exit_code": 0,
+  "commit": "dd146cf1e0f60982d186b8393e96ca484fb4b0b8",
+  "branch": "claude/1258-config-dotnames"
+}

dirsql-0.4.93/packages/python/e2e-attestations/claude-1258-config-links.json

@@ -0,0 +1,7 @@
+{
+  "command": "uv run python -m pytest tests/e2e/glob_speed_symlink_test.py tests/e2e/glob_speed_node_modules_test.py tests/e2e/glob_speed_dotfiles_test.py tests/e2e/glob_speed_matchers_test.py tests/e2e/query_contract_test.py -x -q",
+  "ran_at": 1791338642,
+  "exit_code": 0,
+  "commit": "81890d53f01c2d6e6e833e0748a6ff952e3382c5",
+  "branch": "claude/1258-config-links"
+}

dirsql-0.4.93/packages/python/migrations.d/2026-10-06-config-dotnames.md

@@ -0,0 +1,41 @@
+### A config glob hides dot-named entries unless it spells them
+
+#### Summary
+
+`glob = "**/*.md"` used to match `.env.md` and everything under `.hid/`. It
+now matches neither, as a path-table and bash (with `dotglob` off) do. A config
+that read dot-named files without naming them loses those rows.
+
+#### Required changes
+
+| Before | After |
+| --- | --- |
+| `glob = "**/*.md"` (included `.hid/z.md`) | `glob = ".hid/*.md"` or `glob = "{*,.hid}/*.md"` |
+
+#### Deprecations removed
+
+_None._
+
+#### Behavior changes without code changes
+
+- A dot-named component matches only where the glob spells a dot (`.hid`,
+  `.*`).
+- A glob that names the dot directory (`.hid/*.md`) is unchanged.
+
+#### Verification
+
+```bash
+cd "$(mktemp -d)"
+mkdir .hid
+echo '[{"p":"a"}]' > a.json
+echo '[{"p":"h"}]' > .hid/h.json
+cat > .dirsql.toml <<'TOML'
+[[table]]
+name = "t"
+glob = "**/*.json"
+ddl = "CREATE TABLE t (p TEXT)"
+on-file = "jq -sc add"
+TOML
+dirsql query "SELECT p FROM t" -c .dirsql.toml
+# expected: [{"p":"a"}]
+```

dirsql-0.4.93/packages/python/migrations.d/2026-10-06-config-links.md

@@ -0,0 +1,43 @@
+### Config globs skip node_modules unless named, and follow symlinks
+
+#### Summary
+
+`glob = "**/*.js"` used to list files under any `node_modules`; it now does
+not, unless a component of the glob is `node_modules`. Symlinked files and
+directories, which a config glob used to ignore, are now followed as in a
+path-table and in bash.
+
+#### Required changes
+
+| Before | After |
+| --- | --- |
+| `glob = "**/*.js"` (included `node_modules/`) | `glob = "node_modules/**/*.js"` to list it |
+
+#### Deprecations removed
+
+_None._
+
+#### Behavior changes without code changes
+
+- A glob with no `node_modules` component never matches under one.
+- A symlinked file or directory the glob reaches now yields rows.
+
+#### Verification
+
+```bash
+cd "$(mktemp -d)"
+mkdir real node_modules
+echo '[{"p":"r"}]' > real/r.json
+echo '[{"p":"n"}]' > node_modules/n.json
+ln -s real linkdir
+cat > .dirsql.toml <<'TOML'
+[[table]]
+name = "t"
+glob = "**/*.json"
+ddl = "CREATE TABLE t (p TEXT)"
+on-file = "jq -sc add"
+TOML
+dirsql query "SELECT p FROM t" -c .dirsql.toml
+# expected: no row from node_modules; rows for real/ (symlinked linkdir/ is
+# reached by `linkdir/*.json`, not by `**`)
+```

{dirsql-0.4.91 → dirsql-0.4.93}/packages/rust/Cargo.toml

@@ -6,7 +6,7 @@ description = "Ephemeral SQL index over a local directory"
 # version stays for the binding crates (publish = false). The literal
 # intentionally lags the published version: putitoutthere rewrites it to
 # the planned release version at build time and never commits it back.
-version = "0.4.91"
+version = "0.4.93"
 edition.workspace = true
 # Literal `license` (not `license.workspace = true`) because
 # putitoutthere's preflight check reads `[package].license` directly

{dirsql-0.4.91 → dirsql-0.4.93}/packages/rust/src/matcher.rs

@@ -1,7 +1,8 @@
 use crate::posix_class::expand_posix_classes;
-use crate::scanner::{PathGlob, compile_glob};
+use crate::scanner::{PathGlob, compile_glob, compile_globs};
 use globset::GlobBuilder;
 use regex::{Regex, RegexBuilder};
+use std::ffi::OsStr;
 use std::path::Path;
 
 #[derive(Debug, thiserror::Error)]
@@ -79,23 +80,30 @@ pub struct MatchResult {
     pub table_name: String,
 }
 
+const NODE_MODULES: &str = "node_modules";
+
 #[derive(Clone)]
 struct PatternEntry {
     pattern: PathGlob,
     table_name: String,
+    names_node_modules: bool,
 }
 
 /// Maps file paths to table names based on glob patterns.
 /// Every matching pattern fires: a file matching N patterns yields N
 /// `MatchResult`s (one per table), so a file can belong to multiple tables.
-/// An ignore list filters paths entirely. `{name}` placeholders in glob
-/// patterns are accepted and behave like `*`.
+/// An ignore list filters paths entirely.
 #[derive(Clone)]
 pub struct TableMatcher {
     entries: Vec<PatternEntry>,
     ignore_set: Vec<Pattern>,
     ignore_dir_set: Vec<Pattern>,
     gitignore: bool,
+    walk: PathGlob,
+}
+
+fn has_node_modules_component(path: &Path) -> bool {
+    path.components().any(|c| c.as_os_str() == NODE_MODULES)
 }
 
 impl TableMatcher {
@@ -106,8 +114,11 @@ impl TableMatcher {
             entries.push(PatternEntry {
                 pattern: compile_glob(pattern)?,
                 table_name: table_name.to_string(),
+                names_node_modules: pattern.split('/').any(|c| c == NODE_MODULES),
             });
         }
+        let globs: Vec<&str> = mappings.iter().map(|(pattern, _)| *pattern).collect();
+        let walk = compile_globs(&globs)?;
 
         let mut ignore_set = Vec::new();
         let mut ignore_dir_set = Vec::new();
@@ -123,6 +134,7 @@ impl TableMatcher {
             ignore_set,
             ignore_dir_set,
             gitignore: false,
+            walk,
         })
     }
 
@@ -142,13 +154,29 @@ impl TableMatcher {
     pub fn match_all(&self, path: &Path) -> Vec<MatchResult> {
         self.entries
             .iter()
-            .filter(|entry| entry.pattern.is_match(path))
+            .filter(|entry| {
+                entry.pattern.is_match_unhidden(path)
+                    && (entry.names_node_modules || !has_node_modules_component(path))
+            })
             .map(|entry| MatchResult {
                 table_name: entry.table_name.clone(),
             })
             .collect()
     }
 
+    /// The one glob a walk for every table at once follows.
+    pub(crate) fn walk_glob(&self) -> &PathGlob {
+        &self.walk
+    }
+
+    /// Whether the walk may skip a directory called `name` outright: it is
+    /// `node_modules` and no table's glob names it.
+    pub(crate) fn prunes_directory(&self, name: &OsStr) -> bool {
+        name == NODE_MODULES
+            && !self.entries.is_empty()
+            && !self.entries.iter().any(|e| e.names_node_modules)
+    }
+
     /// Returns true if the path matches any ignore pattern.
     pub fn is_ignored(&self, path: &Path) -> bool {
         self.ignore_set.iter().any(|p| p.is_match(path))
@@ -188,6 +216,30 @@ mod tests {
         assert!(matcher.with_gitignore(true).respects_gitignore());
     }
 
+    #[test]
+    fn node_modules_is_skipped_unless_a_table_names_it() {
+        let matcher =
+            TableMatcher::new(&[("**/*.js", "all"), ("node_modules/*.js", "nm")], &[]).unwrap();
+        assert_eq!(names(&matcher, "pkg/a.js"), vec!["all"]);
+        assert_eq!(
+            names(&matcher, "pkg/node_modules/a.js"),
+            Vec::<String>::new()
+        );
+        assert_eq!(names(&matcher, "node_modules/a.js"), vec!["nm"]);
+    }
+
+    #[test]
+    fn the_walk_prunes_node_modules_only_while_no_table_names_it() {
+        let name = OsStr::new("node_modules");
+        let plain = TableMatcher::new(&[("**/*.js", "t")], &[]).unwrap();
+        let naming = TableMatcher::new(&[("node_modules/*.js", "t")], &[]).unwrap();
+        let none = TableMatcher::new(&[], &[]).unwrap();
+        assert!(plain.prunes_directory(name));
+        assert!(!plain.prunes_directory(OsStr::new("src")));
+        assert!(!naming.prunes_directory(name));
+        assert!(!none.prunes_directory(name));
+    }
+
     #[test]
     fn match_all_returns_empty_for_no_match() {
         let matcher = TableMatcher::new(&[("*.csv", "data")], &[]).unwrap();

{dirsql-0.4.91 → dirsql-0.4.93}/packages/rust/src/scanner.rs

@@ -104,7 +104,7 @@ fn scan_below(
     // regardless of the absolute root directory.
     let walker = Walk {
         ignore: matcher,
-        glob: None,
+        glob: Some(matcher.walk_glob()),
         gitignore,
         in_repo: repo.is_some(),
         frames: repo.map_or_else(Vec::new, |top| {
@@ -236,7 +236,7 @@ enum Kind {
 }
 
 impl PathGlob {
-    fn spells_dot_name(&self, name: &OsStr) -> bool {
+    pub(crate) fn spells_dot_name(&self, name: &OsStr) -> bool {
         self.spelled_dot_names
             .iter()
             .any(|p| p.is_match(Path::new(name)))
@@ -246,6 +246,17 @@ impl PathGlob {
         self.files.iter().any(|p| p.is_match(rel_path))
     }
 
+    /// [`is_match`](Self::is_match), and every dot-named component of the path
+    /// is one the glob spells.
+    pub(crate) fn is_match_unhidden(&self, rel_path: &Path) -> bool {
+        self.is_match(rel_path)
+            && rel_path
+                .components()
+                .map(|c| c.as_os_str())
+                .filter(|name| is_dot_named(name))
+                .all(|name| self.spells_dot_name(name))
+    }
+
     fn has_components(&self) -> bool {
         !self.components.is_empty()
     }
@@ -307,7 +318,16 @@ impl PathGlob {
 /// it a lone `*` would cross `/` and the explicit non-recursive spelling would
 /// silently recurse. `**` still crosses separators.
 pub fn compile_glob(pattern: &str) -> Result<PathGlob, GlobError> {
-    let words = crate::brace::expand(pattern);
+    compile_globs(&[pattern])
+}
+
+/// One [`PathGlob`] over every word of every pattern: the walk a set of
+/// tables shares, entering what any of them could reach.
+pub fn compile_globs(patterns: &[&str]) -> Result<PathGlob, GlobError> {
+    let words: Vec<String> = patterns
+        .iter()
+        .flat_map(|pattern| crate::brace::expand(pattern))
+        .collect();
     let mut files = Vec::new();
     let mut spelled_dot_names = Vec::new();
     for word in &words {
@@ -392,7 +412,11 @@ fn walk(
     visit: &mut dyn FnMut(PathBuf, &Path),
 ) {
     let rel = start.strip_prefix(root).unwrap_or(start);
-    let states = walker.glob.map_or_else(Vec::new, PathGlob::start);
+    let states = walker.glob.map_or_else(Vec::new, |glob| {
+        rel.components().fold(glob.start(), |states, component| {
+            glob.step(&states, component.as_os_str(), Kind::Dir)
+        })
+    });
     let place = Place {
         walk: walker,
         dir: start.to_path_buf(),
@@ -579,6 +603,7 @@ impl Walk<'_> {
     /// `.gitignore` files in force.
     fn admits(&self, depth: usize, is_dir: bool, name: &OsStr, path: &Path, rel: &Path) -> bool {
         should_descend(depth, is_dir, name, rel, self.ignore)
+            && !(is_dir && self.ignore.prunes_directory(name))
             && self.admits_name(name)
             && (self.frames.is_empty() || !is_gitignored(&self.frames, path, is_dir))
     }
@@ -1018,7 +1043,7 @@ mod tests {
         fs::create_dir_all(root.path().join("a").join("node_modules").join("pkg")).unwrap();
         fs::create_dir_all(root.path().join("a").join(RESERVED_DIR)).unwrap();
         fs::write(root.path().join("a").join("f.md"), "").unwrap();
-        let ignore = TableMatcher::new(&[], &["**/node_modules/**"]).unwrap();
+        let ignore = TableMatcher::new(&[(".dirsql/*", "t")], &["**/node_modules/**"]).unwrap();
         let a = root.path().join("a");
         let mut dirs = scan_dirs(root.path(), &a, &ignore);
         dirs.sort();
@@ -1040,7 +1065,7 @@ mod tests {
     fn explore_enters_a_dirsql_directory_below_the_top_level() {
         let root = tempfile::tempdir().unwrap();
         fs::create_dir_all(root.path().join("a").join(RESERVED_DIR)).unwrap();
-        let ignore = TableMatcher::new(&[], &[]).unwrap();
+        let ignore = TableMatcher::new(&[("**/.dirsql/*", "t")], &[]).unwrap();
         let top = Place {
             walk: walk_with(&ignore, None, Vec::new()),
             dir: root.path().to_path_buf(),
@@ -1393,16 +1418,31 @@ mod tests {
     }
 
     #[test]
-    fn admits_every_dot_named_entry_when_no_glob_governs_the_walk() {
-        let ignore = TableMatcher::new(&[], &[]).unwrap();
-        let walk = walk_with(&ignore, None, Vec::new());
-        assert!(walk.admits(
-            1,
-            false,
-            OsStr::new(".env"),
-            Path::new("/r/.env"),
-            Path::new(".env")
-        ));
+    fn a_table_walk_skips_a_node_modules_directory_no_table_names() {
+        let ignore = TableMatcher::new(&[("**/*.js", "t")], &[]).unwrap();
+        let walk = walk_with(&ignore, Some(ignore.walk_glob()), Vec::new());
+        let admits = |is_dir, name: &str| {
+            walk.admits(
+                1,
+                is_dir,
+                OsStr::new(name),
+                Path::new(name),
+                Path::new(name),
+            )
+        };
+        assert!(!admits(true, "node_modules"));
+        assert!(admits(false, "node_modules"));
+        assert!(admits(true, "src"));
+    }
+
+    #[test]
+    fn a_match_with_an_unspelled_dot_component_is_hidden() {
+        let glob = compile_glob("**/*.md").unwrap();
+        assert!(glob.is_match_unhidden(Path::new("sub/b.md")));
+        assert!(!glob.is_match_unhidden(Path::new(".env.md")));
+        assert!(!glob.is_match_unhidden(Path::new(".hid/z.md")));
+        let spelled = compile_glob(".hid/*.md").unwrap();
+        assert!(spelled.is_match_unhidden(Path::new(".hid/z.md")));
     }
 
     #[test]