dirsql 0.4.66__tar.gz → 0.4.67__tar.gz

{dirsql-0.4.66 → dirsql-0.4.67}/Cargo.lock

@@ -552,7 +552,7 @@ checksum = "6184e33543162437515c2e2b48714794e37845ec9851711914eec9d308f6ebe8"
 
 [[package]]
 name = "dirsql"
-version = "0.4.66"
+version = "0.4.67"
 dependencies = [
  "assert_cmd",
  "axum",
@@ -600,7 +600,7 @@ dependencies = [
 
 [[package]]
 name = "dirsql-py-ext"
-version = "0.4.66"
+version = "0.4.67"
 dependencies = [
  "dirsql",
  "pyo3",

{dirsql-0.4.66 → dirsql-0.4.67}/PKG-INFO

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

{dirsql-0.4.66 → dirsql-0.4.67}/docs/howto/skip-files.md

@@ -47,8 +47,10 @@ dirsql query "SELECT basename FROM notes ORDER BY basename" -c ./.dirsql.toml
 ## Notes
 
 - `ignore` lives in a config file, so it needs one:
-  [configless mode](../reference/cli.md#configless-mode) indexes
-  everything with no ignores.
+  [configless mode](../reference/cli.md#configless-mode) has no `ignore`
+  list, though its path-tables still apply the built-in
+  [skip rules](../reference/path-tables.md#skip-rules) and respect
+  `.gitignore`.
 - The top-level `.dirsql/` directory is always excluded, ignore list or
   not — it is reserved for `dirsql`'s own metadata
   ([config reference](../reference/config.md#dirsql-keys)).

{dirsql-0.4.66 → dirsql-0.4.67}/docs/reference/cli.md

@@ -269,8 +269,10 @@ defines **no named tables**. Filesystem queries go through
 scanned live. A `./.dirsql.toml` sitting in the current directory is **not**
 auto-loaded (pass it with `-c ./.dirsql.toml` to use it).
 
-`'./'` is the whole root — every file at any depth, one row per file, with
-all seven [stat columns](./columns.md): `path`, `basename`, `dir`, `ext`,
+`'./'` lists the files directly inside the root, one level, like `ls`;
+`'./**'` reaches every depth. Both scans apply the path-table
+[skip rules](./path-tables.md#skip-rules), and each returns one row per file
+with all seven [stat columns](./columns.md): `path`, `basename`, `dir`, `ext`,
 `size`, `mtime`, `ctime`.
 
 ```bash

{dirsql-0.4.66/packages/python → dirsql-0.4.67}/docs/reference/path-tables.md

@@ -287,10 +287,25 @@ beneath it; one above it is never read.
 
 ### Hidden files
 
-Dotfiles are ordinary files: `'./'` and `'./*'` include them, with or without
-`--no-ignore`. This is a deliberate divergence from fd/ripgrep — querying
-dotfile directories (`.claude/`, …) is a first-class `dirsql` use case. Add an
-`ignore` pattern if you would rather not see them.
+A path component starting with `.` is skipped unless the path spells it, the
+rule `ls` and `fd` use. `'./'` and `'./**'` skip `.gitignore`, `.env` and
+everything under `.claude/`; naming the component lists it:
+
+| You write | dirsql scans |
+| --- | --- |
+| `'./**'` | every file, skipping dot-named files and directories at any depth |
+| `'./.claude'`, `'./.claude/**'` | the files under `.claude/` |
+| `'./.env'` | that one file |
+| `'./**/.env'` | every `.env` whose parent directories are not themselves dot-named |
+| `'~/.claude/projects/*/*.jsonl'` | the walk starts inside `.claude/`, so nothing there is hidden |
+
+A spelled component may be a glob of its own: `'./.env*'` lists `.env.local`,
+and `'./.*'` lists every dot-named entry one level down. A dot component the
+path does not spell stays hidden however deep the scan goes, so
+`'./.claude/**'` lists `.claude/sub/notes.md` but not `.claude/sub/.cache/x`.
+
+This is independent of `.gitignore`: [`--no-ignore`](./cli.md#flags) restores
+gitignored files and leaves dot-named entries hidden.
 
 ## Joining against declared tables
 

{dirsql-0.4.66 → dirsql-0.4.67}/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.66"
+version = "0.4.67"
 # 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.67/packages/python/changelog.d/2026-10-04-path-table-dotfiles-hidden.md

@@ -0,0 +1,6 @@
+**Changed** A path-table hides dot-named files and directories unless the
+path spells them, the rule `ls` and `fd` use. `'./'` and `'./**'` skip
+`.gitignore`, `.env` and everything under `.claude/`; `'./.claude/**'`,
+`'./.env'` and `'./**/.env'` list them. A spelled component may be a glob
+(`'./.env*'`, `'./.*'`). The rule is independent of `--no-ignore`, which
+still governs `.gitignore` only. Declared `[[table]]` globs are unchanged.

{dirsql-0.4.66/packages/rust → dirsql-0.4.67/packages/python}/docs/howto/skip-files.md

@@ -47,8 +47,10 @@ dirsql query "SELECT basename FROM notes ORDER BY basename" -c ./.dirsql.toml
 ## Notes
 
 - `ignore` lives in a config file, so it needs one:
-  [configless mode](../reference/cli.md#configless-mode) indexes
-  everything with no ignores.
+  [configless mode](../reference/cli.md#configless-mode) has no `ignore`
+  list, though its path-tables still apply the built-in
+  [skip rules](../reference/path-tables.md#skip-rules) and respect
+  `.gitignore`.
 - The top-level `.dirsql/` directory is always excluded, ignore list or
   not — it is reserved for `dirsql`'s own metadata
   ([config reference](../reference/config.md#dirsql-keys)).

{dirsql-0.4.66/packages/rust → dirsql-0.4.67/packages/python}/docs/reference/cli.md

@@ -269,8 +269,10 @@ defines **no named tables**. Filesystem queries go through
 scanned live. A `./.dirsql.toml` sitting in the current directory is **not**
 auto-loaded (pass it with `-c ./.dirsql.toml` to use it).
 
-`'./'` is the whole root — every file at any depth, one row per file, with
-all seven [stat columns](./columns.md): `path`, `basename`, `dir`, `ext`,
+`'./'` lists the files directly inside the root, one level, like `ls`;
+`'./**'` reaches every depth. Both scans apply the path-table
+[skip rules](./path-tables.md#skip-rules), and each returns one row per file
+with all seven [stat columns](./columns.md): `path`, `basename`, `dir`, `ext`,
 `size`, `mtime`, `ctime`.
 
 ```bash

{dirsql-0.4.66 → dirsql-0.4.67/packages/python}/docs/reference/path-tables.md

@@ -287,10 +287,25 @@ beneath it; one above it is never read.
 
 ### Hidden files
 
-Dotfiles are ordinary files: `'./'` and `'./*'` include them, with or without
-`--no-ignore`. This is a deliberate divergence from fd/ripgrep — querying
-dotfile directories (`.claude/`, …) is a first-class `dirsql` use case. Add an
-`ignore` pattern if you would rather not see them.
+A path component starting with `.` is skipped unless the path spells it, the
+rule `ls` and `fd` use. `'./'` and `'./**'` skip `.gitignore`, `.env` and
+everything under `.claude/`; naming the component lists it:
+
+| You write | dirsql scans |
+| --- | --- |
+| `'./**'` | every file, skipping dot-named files and directories at any depth |
+| `'./.claude'`, `'./.claude/**'` | the files under `.claude/` |
+| `'./.env'` | that one file |
+| `'./**/.env'` | every `.env` whose parent directories are not themselves dot-named |
+| `'~/.claude/projects/*/*.jsonl'` | the walk starts inside `.claude/`, so nothing there is hidden |
+
+A spelled component may be a glob of its own: `'./.env*'` lists `.env.local`,
+and `'./.*'` lists every dot-named entry one level down. A dot component the
+path does not spell stays hidden however deep the scan goes, so
+`'./.claude/**'` lists `.claude/sub/notes.md` but not `.claude/sub/.cache/x`.
+
+This is independent of `.gitignore`: [`--no-ignore`](./cli.md#flags) restores
+gitignored files and leaves dot-named entries hidden.
 
 ## Joining against declared tables
 

dirsql-0.4.67/packages/python/e2e-attestations/claude-1249-dotfiles.json

@@ -0,0 +1,7 @@
+{
+  "command": "just test-e2e",
+  "ran_at": 1791166584,
+  "exit_code": 0,
+  "commit": "009125bdab94f7f845df78b251328aa590fe75d9",
+  "branch": "claude/1249-dotfiles"
+}

dirsql-0.4.67/packages/python/migrations.d/2026-10-04-path-table-dotfiles-hidden.md

@@ -0,0 +1,45 @@
+### Core: path-tables hide dot-named entries unless the path spells them
+
+#### Summary
+
+A path-table scan now skips any file or directory whose name starts with `.`
+unless that component is spelled in the table's path -- the rule `ls` and
+`fd` use. It used to list dotfiles like any other file. Every surface that
+resolves a path-table is affected: the CLI, the REPL, the HTTP server, the
+SDKs, and the `--on-file` form. A query that relied on `'./'` or `'./**'`
+reaching `.gitignore`, `.env` or a `.claude/` tree must name the dot
+component. Declared `[[table]]` globs in `.dirsql.toml` are unchanged.
+
+#### Required changes
+
+| Surface | Before | After |
+| ------- | ------ | ----- |
+| A dot directory's files | `SELECT * FROM './**'` (rows under `.claude/` included) | `SELECT * FROM './.claude/**'` |
+| One dotfile | `SELECT * FROM './*'` (`.env` included) | `SELECT * FROM './.env'` |
+| Dotfiles at any depth | `SELECT * FROM './**'` | `SELECT * FROM './**/.env'` |
+| Every dot-named entry, one level | `SELECT * FROM './*'` | `SELECT * FROM './.*'` |
+| Spelled dot prefix (unchanged) | `SELECT * FROM '~/.claude/projects/*/*.jsonl'` | `SELECT * FROM '~/.claude/projects/*/*.jsonl'` |
+
+#### Deprecations removed
+
+_None._
+
+#### Behavior changes without code changes
+
+- `'./'`, `'./*'`, `'./**'` and every other path-table whose path spells no
+  dot component return no dot-named files and do not walk dot-named
+  directories, at any depth.
+- `--no-ignore` (`no_ignore` / `noIgnore` in the SDKs) restores gitignored
+  files only; dot-named entries stay hidden under it.
+
+#### Verification
+
+```python
+# root holds top.md, .env and .claude/notes.md
+rows = await DirSQL(root).query("SELECT path FROM './**' ORDER BY path")
+# expected: [{"path": "top.md"}]
+rows = await DirSQL(root).query("SELECT path FROM './.claude/**'")
+# expected: [{"path": ".claude/notes.md"}]
+rows = await DirSQL(root).query("SELECT path FROM './.env'")
+# expected: [{"path": ".env"}]
+```

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

{dirsql-0.4.66/packages/python → dirsql-0.4.67/packages/rust}/docs/howto/skip-files.md

@@ -47,8 +47,10 @@ dirsql query "SELECT basename FROM notes ORDER BY basename" -c ./.dirsql.toml
 ## Notes
 
 - `ignore` lives in a config file, so it needs one:
-  [configless mode](../reference/cli.md#configless-mode) indexes
-  everything with no ignores.
+  [configless mode](../reference/cli.md#configless-mode) has no `ignore`
+  list, though its path-tables still apply the built-in
+  [skip rules](../reference/path-tables.md#skip-rules) and respect
+  `.gitignore`.
 - The top-level `.dirsql/` directory is always excluded, ignore list or
   not — it is reserved for `dirsql`'s own metadata
   ([config reference](../reference/config.md#dirsql-keys)).

{dirsql-0.4.66/packages/python → dirsql-0.4.67/packages/rust}/docs/reference/cli.md

@@ -269,8 +269,10 @@ defines **no named tables**. Filesystem queries go through
 scanned live. A `./.dirsql.toml` sitting in the current directory is **not**
 auto-loaded (pass it with `-c ./.dirsql.toml` to use it).
 
-`'./'` is the whole root — every file at any depth, one row per file, with
-all seven [stat columns](./columns.md): `path`, `basename`, `dir`, `ext`,
+`'./'` lists the files directly inside the root, one level, like `ls`;
+`'./**'` reaches every depth. Both scans apply the path-table
+[skip rules](./path-tables.md#skip-rules), and each returns one row per file
+with all seven [stat columns](./columns.md): `path`, `basename`, `dir`, `ext`,
 `size`, `mtime`, `ctime`.
 
 ```bash

{dirsql-0.4.66 → dirsql-0.4.67}/packages/rust/docs/reference/path-tables.md

@@ -287,10 +287,25 @@ beneath it; one above it is never read.
 
 ### Hidden files
 
-Dotfiles are ordinary files: `'./'` and `'./*'` include them, with or without
-`--no-ignore`. This is a deliberate divergence from fd/ripgrep — querying
-dotfile directories (`.claude/`, …) is a first-class `dirsql` use case. Add an
-`ignore` pattern if you would rather not see them.
+A path component starting with `.` is skipped unless the path spells it, the
+rule `ls` and `fd` use. `'./'` and `'./**'` skip `.gitignore`, `.env` and
+everything under `.claude/`; naming the component lists it:
+
+| You write | dirsql scans |
+| --- | --- |
+| `'./**'` | every file, skipping dot-named files and directories at any depth |
+| `'./.claude'`, `'./.claude/**'` | the files under `.claude/` |
+| `'./.env'` | that one file |
+| `'./**/.env'` | every `.env` whose parent directories are not themselves dot-named |
+| `'~/.claude/projects/*/*.jsonl'` | the walk starts inside `.claude/`, so nothing there is hidden |
+
+A spelled component may be a glob of its own: `'./.env*'` lists `.env.local`,
+and `'./.*'` lists every dot-named entry one level down. A dot component the
+path does not spell stays hidden however deep the scan goes, so
+`'./.claude/**'` lists `.claude/sub/notes.md` but not `.claude/sub/.cache/x`.
+
+This is independent of `.gitignore`: [`--no-ignore`](./cli.md#flags) restores
+gitignored files and leaves dot-named entries hidden.
 
 ## Joining against declared tables
 

{dirsql-0.4.66 → dirsql-0.4.67}/packages/rust/src/scanner.rs

@@ -103,13 +103,15 @@ fn scan_below(
 /// Skip rules are judged on paths relative to `root`, so a table rooted at a
 /// directory the rules would otherwise skip still scans it.
 ///
-/// Symlinks are followed as `bash -O globstar` follows them (see
-/// [`PathGlob`]).
+/// A dot-named entry is skipped unless `glob` spells it, and symlinks are
+/// followed as `bash -O globstar` follows them (see [`PathGlob`]); the walk
+/// starts at the path's literal prefix, so a dot directory named there is
+/// already inside.
 ///
 /// With `gitignore` set, `.gitignore` files apply hierarchically (each one
-/// below its own directory) and prune traversal, like fd/ripgrep — except
-/// that hidden files are still scanned, and no `.git` directory is required.
-/// Only files at or below `root` are read; one above it has no say.
+/// below its own directory) and prune traversal, like fd/ripgrep, and no
+/// `.git` directory is required. Only files at or below `root` are read; one
+/// above it has no say.
 pub fn scan_glob(
     root: &Path,
     glob: &PathGlob,
@@ -139,17 +141,24 @@ fn is_wanted(glob: &PathGlob, ignore: &TableMatcher, rel_path: &Path) -> bool {
 }
 
 /// A path-table's glob as [`scan_glob`] reads it: the files it matches, and
-/// the same pattern split into `/`-separated components, which decide where
-/// the walk may follow a symlink.
+/// the dot-named entries it spells out and so lets the walk into, and the
+/// same pattern split into `/`-separated components, which decide where the
+/// walk may follow a symlink.
 ///
-/// The rule is bash's (`globstar`, 4.3 and later). A symlinked file is a file.
-/// A symlinked directory is entered by any component except `**`, which never
-/// traverses one, though it may stop on one for the next component to enter.
-/// Each link crossed spends a component, so a cycle cannot recurse without
-/// bound.
+/// A component beginning with `.` is spelled; `.claude` and `.env` admit
+/// exactly those names, `.*` any dot-named entry, as in the shell. Every
+/// other dot-named file or directory is skipped, the rule `ls` and `fd` use.
+/// A dot-named symlink is a dot-named entry like any other.
+///
+/// The symlink rule is bash's (`globstar`, 4.3 and later). A symlinked file
+/// is a file. A symlinked directory is entered by any component except `**`,
+/// which never traverses one, though it may stop on one for the next
+/// component to enter. Each link crossed spends a component, so a cycle
+/// cannot recurse without bound.
 #[derive(Debug)]
 pub struct PathGlob {
     files: GlobSet,
+    spelled_dot_names: GlobSet,
     components: Vec<Component>,
 }
 
@@ -225,8 +234,13 @@ impl PathGlob {
 pub fn compile_glob(pattern: &str) -> Result<PathGlob, globset::Error> {
     let mut files = GlobSetBuilder::new();
     files.add(compile_component(pattern)?);
+    let mut spelled = GlobSetBuilder::new();
+    for component in pattern.split('/').filter(|c| is_dot_named(OsStr::new(c))) {
+        spelled.add(compile_component(component)?);
+    }
     Ok(PathGlob {
         files: files.build()?,
+        spelled_dot_names: spelled.build()?,
         components: compile_components(pattern),
     })
 }
@@ -235,6 +249,10 @@ fn compile_component(pattern: &str) -> Result<globset::Glob, globset::Error> {
     GlobBuilder::new(pattern).literal_separator(true).build()
 }
 
+fn is_dot_named(name: &OsStr) -> bool {
+    name.as_encoded_bytes().first() == Some(&b'.')
+}
+
 /// A pattern whose components do not compile on their own (an alternation
 /// spanning a `/`) gets none, so the walk follows no symlinked directory.
 fn compile_components(pattern: &str) -> Vec<Component> {
@@ -271,10 +289,11 @@ pub(crate) fn parse_gitignore_arg(arg: &str) -> Result<bool, String> {
 /// `root`-relative path, siblings in name order, so the whole walk comes out
 /// in path order without a sort at the end. Prunes the reserved top-level
 /// `.dirsql/` subtree and any directory the skip rules ignore wholesale, so an
-/// ignored tree is never read at all. With `gitignore` set, entries a
-/// `.gitignore` in force ignores are pruned/skipped too. Symlinks are followed
-/// only as `glob` allows, and not at all without one; a broken link or an
-/// unreadable directory contributes nothing.
+/// ignored tree is never read at all. With `glob` given, a dot-named entry it
+/// does not spell is skipped; `None` admits them all. With `gitignore` set,
+/// entries a `.gitignore` in force ignores are pruned/skipped too. Symlinks
+/// are followed only as `glob` allows, and not at all without one; a broken
+/// link or an unreadable directory contributes nothing.
 fn walk(
     root: &Path,
     start: &Path,
@@ -349,12 +368,21 @@ impl Walk<'_> {
     }
 
     /// Whether the walk takes an entry at `depth`: the skip rules and the
-    /// reserved-directory rule first, then the `.gitignore` files in force.
+    /// reserved-directory rule first, then the dot-name rule, then the
+    /// `.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)
+            && self.admits_name(name)
             && (self.frames.is_empty() || !is_gitignored(&self.frames, path, is_dir))
     }
 
+    fn admits_name(&self, name: &OsStr) -> bool {
+        match self.glob {
+            Some(glob) => !is_dot_named(name) || glob.spelled_dot_names.is_match(name),
+            None => true,
+        }
+    }
+
     fn next_states(&self, states: &[usize], name: &OsStr, kind: Kind) -> Vec<usize> {
         self.glob
             .map_or_else(Vec::new, |glob| glob.step(states, name, kind))
@@ -625,10 +653,14 @@ mod tests {
         assert!(!is_wanted(&glob, &ignore, Path::new("drafts/a.md")));
     }
 
-    fn walk_with<'a>(ignore: &'a TableMatcher, frames: Vec<Gitignore>) -> Walk<'a> {
+    fn walk_with<'a>(
+        ignore: &'a TableMatcher,
+        glob: Option<&'a PathGlob>,
+        frames: Vec<Gitignore>,
+    ) -> Walk<'a> {
         Walk {
             ignore,
-            glob: None,
+            glob,
             gitignore: !frames.is_empty(),
             frames,
         }
@@ -637,7 +669,8 @@ mod tests {
     #[test]
     fn admits_an_ordinary_file_under_no_gitignore() {
         let ignore = TableMatcher::new(&[], &[]).unwrap();
-        let walk = walk_with(&ignore, Vec::new());
+        let glob = compile_glob("**").unwrap();
+        let walk = walk_with(&ignore, Some(&glob), Vec::new());
         assert!(walk.admits(
             1,
             false,
@@ -650,7 +683,8 @@ mod tests {
     #[test]
     fn admits_nothing_the_skip_rules_prune() {
         let ignore = TableMatcher::new(&[], &["**/node_modules/**"]).unwrap();
-        let walk = walk_with(&ignore, vec![frame("", &["*.log"])]);
+        let glob = compile_glob("**").unwrap();
+        let walk = walk_with(&ignore, Some(&glob), vec![frame("", &["*.log"])]);
         assert!(!walk.admits(
             2,
             true,
@@ -660,10 +694,95 @@ mod tests {
         ));
     }
 
+    #[test]
+    fn admits_no_dot_named_entry_the_glob_does_not_spell() {
+        let ignore = TableMatcher::new(&[], &[]).unwrap();
+        let glob = compile_glob("**").unwrap();
+        let walk = walk_with(&ignore, Some(&glob), Vec::new());
+        assert!(!walk.admits(
+            1,
+            false,
+            OsStr::new(".env"),
+            Path::new("/r/.env"),
+            Path::new(".env")
+        ));
+        assert!(!walk.admits(
+            1,
+            true,
+            OsStr::new(".hidden"),
+            Path::new("/r/.hidden"),
+            Path::new(".hidden")
+        ));
+    }
+
+    #[test]
+    fn admits_a_dot_named_entry_the_glob_spells() {
+        let ignore = TableMatcher::new(&[], &[]).unwrap();
+        let glob = compile_glob("**/.env").unwrap();
+        let walk = walk_with(&ignore, Some(&glob), Vec::new());
+        assert!(walk.admits(
+            2,
+            false,
+            OsStr::new(".env"),
+            Path::new("/r/sub/.env"),
+            Path::new("sub/.env")
+        ));
+        assert!(!walk.admits(
+            1,
+            true,
+            OsStr::new(".hidden"),
+            Path::new("/r/.hidden"),
+            Path::new(".hidden")
+        ));
+    }
+
+    #[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")
+        ));
+    }
+
+    #[test]
+    fn a_spelled_dot_component_may_itself_be_a_glob() {
+        let glob = compile_glob(".env*").unwrap();
+        assert!(glob.spelled_dot_names.is_match(".env.local"));
+        assert!(!glob.spelled_dot_names.is_match(".git"));
+    }
+
+    #[test]
+    fn a_dot_component_is_spelled_wherever_it_sits_in_the_glob() {
+        let glob = compile_glob("*/.cache/*").unwrap();
+        assert!(glob.spelled_dot_names.is_match(".cache"));
+        assert!(!glob.spelled_dot_names.is_match(".config"));
+    }
+
+    #[test]
+    fn a_glob_without_a_dot_component_spells_no_dot_name() {
+        let glob = compile_glob("docs/**/*.md").unwrap();
+        assert!(!glob.spelled_dot_names.is_match(".md"));
+        assert!(!glob.spelled_dot_names.is_match(".docs"));
+    }
+
+    #[test]
+    fn is_dot_named_looks_at_the_first_byte_only() {
+        assert!(is_dot_named(OsStr::new(".env")));
+        assert!(is_dot_named(OsStr::new(".")));
+        assert!(!is_dot_named(OsStr::new("a.md")));
+        assert!(!is_dot_named(OsStr::new("")));
+    }
+
     #[test]
     fn admits_nothing_a_gitignore_in_force_ignores() {
         let ignore = TableMatcher::new(&[], &[]).unwrap();
-        let walk = walk_with(&ignore, vec![frame("", &["*.log"])]);
+        let glob = compile_glob("**").unwrap();
+        let walk = walk_with(&ignore, Some(&glob), vec![frame("", &["*.log"])]);
         assert!(!walk.admits(
             1,
             false,
@@ -768,7 +887,7 @@ mod tests {
     #[test]
     fn follows_everything_off_a_link() {
         let ignore = TableMatcher::new(&[], &[]).unwrap();
-        let walk = walk_with(&ignore, Vec::new());
+        let walk = walk_with(&ignore, None, Vec::new());
         assert!(walk.follows(false, &[], Kind::File));
         assert!(!walk.follows(true, &[0], Kind::Dir));
     }
@@ -791,7 +910,7 @@ mod tests {
     #[test]
     fn next_states_are_empty_without_a_glob() {
         let ignore = TableMatcher::new(&[], &[]).unwrap();
-        let walk = walk_with(&ignore, Vec::new());
+        let walk = walk_with(&ignore, None, Vec::new());
         assert!(
             walk.next_states(&[0], OsStr::new("a"), Kind::Dir)
                 .is_empty()