dirsql 0.4.86__tar.gz → 0.4.88__tar.gz

{dirsql-0.4.86 → dirsql-0.4.88}/Cargo.lock

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

{dirsql-0.4.86 → dirsql-0.4.88}/PKG-INFO

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

{dirsql-0.4.86/packages/rust → dirsql-0.4.88}/docs/reference/path-tables.md

@@ -59,7 +59,9 @@ alternation: `'./docs/{a,b}.md'` is `docs/a.md` and `docs/b.md`, and groups
 nest. A group holding a `..` range counts: `'./log/{1..3}.txt'`,
 `'./{a..c}.md'`, `'./{01..10}.md'` (zero-padded) and `'./{1..10..2}.md'`
 (every second value). Any other brace is literal text, so `'./br/{q}.md'`
-names the file `br/{q}.md`, and `\{` is always a literal brace.
+names the file `br/{q}.md`, and `\{` is always a literal brace. A `{`, `}`
+or `[` with no partner is literal too, in a path-table and in a config
+`[[table]] glob`.
 
 The scan starts at the last directory named outright before the first glob
 component, and descends only as deep as the pattern can match --

{dirsql-0.4.86 → dirsql-0.4.88}/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.86"
+version = "0.4.88"
 # 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.88/packages/python/changelog.d/2026-10-05-unbalanced-brackets-literal.md

@@ -0,0 +1 @@
+**Fixed** An unmatched `{`, `}` or `[` in a path-table or a config `[[table]] glob` is a literal character, as in bash, instead of a glob compile error.

dirsql-0.4.88/packages/python/changelog.d/2026-10-06-config-gitignore.md

@@ -0,0 +1,3 @@
+**Changed** Declared `[[table]]` tables respect `.gitignore` by default, as
+path-tables do: inside a git repo, a file a `.gitignore` ignores is no longer a
+row, at startup or while watching. `--no-ignore` turns this off for them too.

{dirsql-0.4.86 → dirsql-0.4.88/packages/python}/docs/reference/path-tables.md

@@ -59,7 +59,9 @@ alternation: `'./docs/{a,b}.md'` is `docs/a.md` and `docs/b.md`, and groups
 nest. A group holding a `..` range counts: `'./log/{1..3}.txt'`,
 `'./{a..c}.md'`, `'./{01..10}.md'` (zero-padded) and `'./{1..10..2}.md'`
 (every second value). Any other brace is literal text, so `'./br/{q}.md'`
-names the file `br/{q}.md`, and `\{` is always a literal brace.
+names the file `br/{q}.md`, and `\{` is always a literal brace. A `{`, `}`
+or `[` with no partner is literal too, in a path-table and in a config
+`[[table]] glob`.
 
 The scan starts at the last directory named outright before the first glob
 component, and descends only as deep as the pattern can match --

dirsql-0.4.88/packages/python/e2e-attestations/claude-1258-config-gitignore.json

@@ -0,0 +1,7 @@
+{
+  "command": "uv run python -m pytest tests/e2e/glob_speed_gitignore_test.py 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": 1791329772,
+  "exit_code": 0,
+  "commit": "f828a8181c981ab9c5c775117cb60edf3ccd9dcc",
+  "branch": "claude/1258-config-gitignore"
+}

dirsql-0.4.88/packages/python/e2e-attestations/claude-1268-unbalanced-brackets.json

@@ -0,0 +1,7 @@
+{
+  "command": "uv run python -m pytest tests/e2e/glob_speed_depth_bound_test.py tests/e2e/glob_speed_recursive_test.py tests/e2e/glob_speed_one_level_test.py tests/e2e/glob_speed_matchers_test.py tests/e2e/glob_speed_dotfiles_test.py tests/e2e/query_contract_test.py tests/e2e/fanout_test.py tests/e2e/capture_collision_test.py -x -q",
+  "ran_at": 1791325871,
+  "exit_code": 0,
+  "commit": "45535f123cfc3ea9cf9460c228196e2630d377db",
+  "branch": "claude/1268-unbalanced-brackets"
+}

dirsql-0.4.88/packages/python/migrations.d/2026-10-05-unbalanced-brackets-literal.md

@@ -0,0 +1,29 @@
+### Core: unbalanced braces and brackets in a glob are literal
+
+#### Summary
+
+A `{`, `}` or `[` with no partner in a glob is now a literal character, as in
+bash, on path-tables and on config `[[table]] glob`. It used to fail with a
+glob compile error. Nothing that compiled before changes meaning.
+
+#### Required changes
+
+_None._
+
+#### Deprecations removed
+
+_None._
+
+#### Behavior changes without code changes
+
+- `'./{a.md'`, `'./a}.md'`, `'./[a.md'` and `'./a[b.md'` match files named
+  exactly that instead of failing to compile.
+
+#### Verification
+
+```bash
+cd "$(mktemp -d)"
+touch '[a.md'
+dirsql query "SELECT path FROM './[a.md'"
+# expected: [{"path":"[a.md"}]
+```

dirsql-0.4.88/packages/python/migrations.d/2026-10-06-config-gitignore.md

@@ -0,0 +1,45 @@
+### Config tables respect .gitignore
+
+#### Summary
+
+A declared `[[table]]` used to read every file its glob matched, whatever
+`.gitignore` said. It now skips gitignored files, as a path-table does. This
+breaks a config that relied on indexing an ignored file; pass `--no-ignore`
+(or `no_ignore` in the SDKs) to restore the old behavior.
+
+#### Required changes
+
+| Before | After |
+| --- | --- |
+| a table indexed gitignored files | pass `--no-ignore`, or stop ignoring the file |
+
+#### Deprecations removed
+
+_None._
+
+#### Behavior changes without code changes
+
+- Inside a git repo (a directory holding `.git`), files a `.gitignore` ignores
+  are not rows of a `[[table]]`, at startup or while watching.
+- Outside a repo nothing changes.
+
+#### Verification
+
+```bash
+cd "$(mktemp -d)"
+git init -q
+printf 'skip.json\n' > .gitignore
+echo '[{"p":"keep"}]' > keep.json
+echo '[{"p":"skip"}]' > skip.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":"keep"}]
+dirsql query "SELECT p FROM t ORDER BY p" -c .dirsql.toml --no-ignore
+# expected: [{"p":"keep"},{"p":"skip"}]
+```

{dirsql-0.4.86 → dirsql-0.4.88}/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.86"
+version = "0.4.88"
 edition.workspace = true
 # Literal `license` (not `license.workspace = true`) because
 # putitoutthere's preflight check reads `[package].license` directly

{dirsql-0.4.86/packages/python → dirsql-0.4.88/packages/rust}/docs/reference/path-tables.md

@@ -59,7 +59,9 @@ alternation: `'./docs/{a,b}.md'` is `docs/a.md` and `docs/b.md`, and groups
 nest. A group holding a `..` range counts: `'./log/{1..3}.txt'`,
 `'./{a..c}.md'`, `'./{01..10}.md'` (zero-padded) and `'./{1..10..2}.md'`
 (every second value). Any other brace is literal text, so `'./br/{q}.md'`
-names the file `br/{q}.md`, and `\{` is always a literal brace.
+names the file `br/{q}.md`, and `\{` is always a literal brace. A `{`, `}`
+or `[` with no partner is literal too, in a path-table and in a config
+`[[table]] glob`.
 
 The scan starts at the last directory named outright before the first glob
 component, and descends only as deep as the pattern can match --

{dirsql-0.4.86 → dirsql-0.4.88}/packages/rust/src/brace.rs

@@ -198,7 +198,7 @@ fn steps(lo: i64, hi: i64, step: i64) -> Option<impl Iterator<Item = i128>> {
 
 /// Escape the braces bash left as literal text, so globset matches them
 /// rather than reading an alternation. A complete `[...]` class is copied as
-/// written; an unclosed one ends escaping so globset reports the error.
+/// written; an unclosed `[` is a literal character.
 fn escape_braces(word: &str) -> String {
     let chars: Vec<char> = word.chars().collect();
     let mut out = String::with_capacity(word.len());
@@ -222,10 +222,7 @@ fn escape_braces(word: &str) -> String {
                     out.extend(&chars[i..=end]);
                     resume = end + 1;
                 }
-                None => {
-                    out.extend(&chars[i..]);
-                    return out;
-                }
+                None => out.push_str("[[]"),
             },
             ('{', _) => out.push_str("[{]"),
             ('}', _) => out.push_str("[}]"),
@@ -411,9 +408,18 @@ mod tests {
     }
 
     #[test]
-    fn an_unclosed_class_ends_escaping() {
-        assert_eq!(escape_braces("x[{q}"), "x[{q}");
-        assert_eq!(escape_braces("x[]{"), "x[]{");
+    fn an_unclosed_bracket_is_literal() {
+        assert_eq!(escape_braces("x[{q}"), "x[[][{]q[}]");
+        assert_eq!(escape_braces("x[]{"), "x[[]][{]");
+        assert_eq!(escape_braces("[!a"), "[[]!a");
+        assert_eq!(escape_braces("a].md"), "a].md");
+    }
+
+    #[test]
+    fn expand_leaves_an_unpartnered_brace_literal() {
+        assert_eq!(expand("{a.md"), vec!["[{]a.md"]);
+        assert_eq!(expand("a}.md"), vec!["a[}].md"]);
+        assert_eq!(expand("{a,b}}.md"), vec!["a[}].md", "b[}].md"]);
     }
 
     #[test]

{dirsql-0.4.86 → dirsql-0.4.88}/packages/rust/src/lib.rs

@@ -732,6 +732,14 @@ impl DirSQL {
             if group.matcher.is_ignored(&rel_path_buf) {
                 continue;
             }
+            if group.matcher.respects_gitignore()
+                && scanner::is_gitignored_path(
+                    &abs_path,
+                    self.inner.fs.is_dir(&abs_path).unwrap_or(false),
+                )
+            {
+                continue;
+            }
 
             // A directory that appears whole (`mkdir`, or a populated directory
             // renamed into the tree) arrives as one event naming the directory and
@@ -1110,6 +1118,13 @@ impl DirSQL {
         } = resolved;
 
         let (groups, anchors, table_names) = compile_groups(&tables, &ignore, &root)?;
+        let groups = groups
+            .into_iter()
+            .map(|group| AnchorGroup {
+                matcher: group.matcher.with_gitignore(!no_ignore),
+                ..group
+            })
+            .collect::<Vec<_>>();
 
         // Resolve the persistent context before scanning, so the scan can
         // consult the cached file index.
@@ -2935,6 +2950,23 @@ mod internal_tests {
         assert_eq!(found, vec!["a.txt"]);
     }
 
+    /// The startup walk honors `.gitignore` unless the build asked not to.
+    #[test]
+    fn prepare_hands_the_walk_a_matcher_that_honors_gitignore_unless_no_ignore() {
+        let dir = TempDir::new().unwrap();
+        for no_ignore in [false, true] {
+            let honored = Cell::new(None);
+            let mut resolved = resolved_over(dir.path(), vec![txt_table()], false);
+            resolved.no_ignore = no_ignore;
+            DirSQL::prepare_resolved_with(resolved, &|_, matcher, _| {
+                honored.set(Some(matcher.respects_gitignore()));
+                Vec::new()
+            })
+            .unwrap();
+            assert_eq!(honored.get(), Some(!no_ignore));
+        }
+    }
+
     /// Skipping the walk skips only the walk: with persist on, the cache is
     /// still opened and reconciled against the (empty) scan.
     #[test]

{dirsql-0.4.86 → dirsql-0.4.88}/packages/rust/src/matcher.rs

@@ -97,6 +97,7 @@ pub struct TableMatcher {
     entries: Vec<PatternEntry>,
     ignore_set: Vec<Pattern>,
     ignore_dir_set: Vec<Pattern>,
+    gitignore: bool,
 }
 
 /// Byte spans of the `{name}` placeholders in `pattern`, in order: `(start,
@@ -182,9 +183,20 @@ impl TableMatcher {
             entries,
             ignore_set,
             ignore_dir_set,
+            gitignore: false,
         })
     }
 
+    /// Whether a scan under this matcher honors `.gitignore` files.
+    pub fn with_gitignore(mut self, gitignore: bool) -> Self {
+        self.gitignore = gitignore;
+        self
+    }
+
+    pub(crate) fn respects_gitignore(&self) -> bool {
+        self.gitignore
+    }
+
     /// Returns one [`MatchResult`] per matching pattern, in declaration order.
     /// A file matching N patterns yields N results (fan-out). Empty when
     /// nothing matches.
@@ -230,6 +242,13 @@ mod tests {
         assert_eq!(names(&matcher, "report.csv"), vec!["data"]);
     }
 
+    #[test]
+    fn a_matcher_honors_gitignore_only_once_asked_to() {
+        let matcher = TableMatcher::new(&[], &[]).unwrap();
+        assert!(!matcher.respects_gitignore());
+        assert!(matcher.with_gitignore(true).respects_gitignore());
+    }
+
     #[test]
     fn match_all_returns_empty_for_no_match() {
         let matcher = TableMatcher::new(&[("*.csv", "data")], &[]).unwrap();
@@ -323,7 +342,7 @@ mod tests {
 
     #[test]
     fn invalid_glob_returns_error() {
-        let result = TableMatcher::new(&[("[invalid", "t")], &[]);
+        let result = TableMatcher::new(&[("[z-a]", "t")], &[]);
         assert!(result.is_err());
     }
 

{dirsql-0.4.86 → dirsql-0.4.88}/packages/rust/src/parsed_vtab.rs

@@ -291,7 +291,7 @@ mod tests {
 
     #[test]
     fn parse_module_args_rejects_an_invalid_glob() {
-        let args = args_with(&[b"'/tmp'", b"'['", b"'cat'", b"'gitignore'", b"'/tmp'"]);
+        let args = args_with(&[b"'/tmp'", b"'[z-a]'", b"'cat'", b"'gitignore'", b"'/tmp'"]);
         assert!(parse_module_args(&args).is_err());
     }
 

{dirsql-0.4.86 → dirsql-0.4.88}/packages/rust/src/scanner.rs

@@ -93,15 +93,23 @@ fn scan_below(
 ) -> Vec<(PathBuf, String)> {
     let mut results = Vec::new();
     let mut seen: u64 = 0;
+    let gitignore = matcher.respects_gitignore();
+    let repo = if gitignore {
+        enclosing_repo(start, &holds_git)
+    } else {
+        None
+    };
 
     // Match against relative path so globs like "comments/**/*.jsonl" work
     // regardless of the absolute root directory.
     let walker = Walk {
         ignore: matcher,
         glob: None,
-        gitignore: false,
-        in_repo: false,
-        frames: Vec::new(),
+        gitignore,
+        in_repo: repo.is_some(),
+        frames: repo.map_or_else(Vec::new, |top| {
+            gitignores_above(start, top, &load_gitignore)
+        }),
         dirs: false,
     };
     walk(
@@ -741,6 +749,26 @@ fn load_gitignore(dir: &Path) -> Option<Gitignore> {
     builder.build().ok()
 }
 
+/// Whether the `.gitignore` files of the repo enclosing `path` ignore it, or
+/// a directory above it, as the walk would have: for a path a watcher reports
+/// without having walked to it.
+pub(crate) fn is_gitignored_path(path: &Path, is_dir: bool) -> bool {
+    let Some(top) = path
+        .parent()
+        .and_then(|dir| enclosing_repo(dir, &holds_git))
+    else {
+        return false;
+    };
+    for frame in gitignores_above(path, top, &load_gitignore).iter().rev() {
+        match frame.matched_path_or_any_parents(path, is_dir) {
+            Match::Ignore(_) => return true,
+            Match::Whitelist(_) => return false,
+            Match::None => {}
+        }
+    }
+    false
+}
+
 /// Whether the `.gitignore` files in force mark `path` ignored. Deeper files
 /// take precedence (git's rule), and a whitelisting `!pattern` un-ignores.
 fn is_gitignored(frames: &[Arc<Gitignore>], path: &Path, is_dir: bool) -> bool {
@@ -1110,7 +1138,7 @@ mod tests {
 
     #[test]
     fn compile_glob_rejects_an_invalid_pattern() {
-        assert!(compile_glob("[").is_err());
+        assert!(compile_glob("[z-a]").is_err());
     }
 
     #[test]
@@ -1664,4 +1692,14 @@ mod tests {
         let frames = [frame("", &["!keep.log"]), frame("sub", &["*.log"])];
         assert!(is_gitignored(&frames, Path::new("sub/keep.log"), false));
     }
+
+    #[test]
+    fn is_gitignored_path_ignores_a_path_the_repo_gitignore_matches() {
+        let repo = tempfile::tempdir().unwrap();
+        fs::create_dir(repo.path().join(".git")).unwrap();
+        fs::write(repo.path().join(".gitignore"), "*.log\n").unwrap();
+
+        assert!(is_gitignored_path(&repo.path().join("debug.log"), false));
+        assert!(!is_gitignored_path(&repo.path().join("app.js"), false));
+    }
 }

{dirsql-0.4.86 → dirsql-0.4.88}/packages/rust/src/vtab.rs

@@ -620,7 +620,7 @@ mod tests {
 
     #[test]
     fn parse_module_args_rejects_an_invalid_glob() {
-        let args = args_with(&[b"'/tmp'", b"'['", b"''", b"'gitignore'"]);
+        let args = args_with(&[b"'/tmp'", b"'[z-a]'", b"''", b"'gitignore'"]);
         assert!(parse_module_args(&args).is_err());
     }
 

{dirsql-0.4.86 → dirsql-0.4.88}/packages/rust/src/vtab_scaffold.rs

@@ -669,7 +669,7 @@ mod tests {
 
     #[test]
     fn compile_glob_rejects_an_invalid_pattern() {
-        let err = compile_glob("[").unwrap_err();
+        let err = compile_glob("[z-a]").unwrap_err();
         assert!(
             matches!(err, Error::ModuleError(_)),
             "invalid globs surface as module errors, got {err:?}"