dirsql 0.4.96__tar.gz → 0.4.97__tar.gz

{dirsql-0.4.96 → dirsql-0.4.97}/Cargo.lock

@@ -573,7 +573,7 @@ dependencies = [
 
 [[package]]
 name = "dirsql"
-version = "0.4.96"
+version = "0.4.97"
 dependencies = [
  "assert_cmd",
  "axum",
@@ -625,7 +625,7 @@ dependencies = [
 
 [[package]]
 name = "dirsql-py-ext"
-version = "0.4.96"
+version = "0.4.97"
 dependencies = [
  "dirsql",
  "pyo3",

{dirsql-0.4.96 → dirsql-0.4.97}/PKG-INFO

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

{dirsql-0.4.96/packages/python → dirsql-0.4.97}/docs/reference/glob.md

@@ -76,6 +76,9 @@ A test runs every row against dirsql as a path-table and, with the leading
 | `./[!a].md` | `1.md`, `2.md`, `3.md`, `4.md`, `b.md`, `c.md` |  |
 | `./\[a\].md` | `[a].md` |  |
 | `./[z.md` | `[z.md` |  |
+| `./[d/x]ocs/api.md` | none |  |
+| `./docs[/]api.md` | none |  |
+| `./[!/]*/api.md` | none |  |
 | `./{a,b}.md` | `a.md`, `b.md` |  |
 | `./{q}.md` | `{q}.md` |  |
 | `./{a.md` | none |  |
@@ -91,6 +94,16 @@ A test runs every row against dirsql as a path-table and, with the leading
 | `./*/r.md` | `linkdir/r.md`, `real/r.md` |  |
 | `./**/r.md` | `linkdir/r.md`, `real/r.md` |  |
 | `./real/**` | `real/r.md` |  |
+| `./docs//api.md` | `docs//api.md` |  |
+| `./docs//*.md` | `docs//api.md`, `docs//guide.md` |  |
+| `./*//api.md` | `docs/api.md` |  |
+| `./docs/./api.md` | `docs/./api.md` |  |
+| `./*/./api.md` | `docs/./api.md` |  |
+| `./docs/../top.md` | `docs/../top.md` |  |
+| `./docs/nested/../../top.md` | `docs/nested/../../top.md` |  |
+| `./[dlr]*/../top.md` | `docs/../top.md`, `linkdir/../top.md`, `real/../top.md` |  |
+| `./**/nested/../api.md` | `docs/nested/../api.md` |  |
+| `./docs/*/../api.md` | `docs/nested/../api.md` |  |
 | `./docs` | `docs/api.md`, `docs/guide.md` | directory-name |
 | `./docs/` | `docs/api.md`, `docs/guide.md` | directory-name |
 | `./*/` | `docs/api.md`, `docs/guide.md`, `linkdir/r.md`, `real/r.md` | directory-name |

{dirsql-0.4.96 → dirsql-0.4.97}/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.96"
+version = "0.4.97"
 # 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.97/packages/python/changelog.d/2026-10-07-bracket-slash-literal.md

@@ -0,0 +1,3 @@
+**Changed**
+
+- A `/` inside `[...]` is literal and ends the component, as in bash: `./[b/c]/*` matches nothing instead of `b/c/*`.

dirsql-0.4.97/packages/python/changelog.d/2026-10-07-dotdot-and-double-slashes.md

@@ -0,0 +1,3 @@
+**Changed**
+
+- A relative path-table accepts `//`, `.` and `..` components and reports the path as written; `./docs//api.md` returns `docs//api.md`, and `./docs/../top.md` matches `top.md` through `docs/..`.

dirsql-0.4.97/packages/python/changelog.d/2026-10-07-fix-main-build.md

@@ -0,0 +1,3 @@
+**Changed**
+
+- No user-visible change.

{dirsql-0.4.96/packages/rust → dirsql-0.4.97/packages/python}/docs/reference/glob.md

@@ -76,6 +76,9 @@ A test runs every row against dirsql as a path-table and, with the leading
 | `./[!a].md` | `1.md`, `2.md`, `3.md`, `4.md`, `b.md`, `c.md` |  |
 | `./\[a\].md` | `[a].md` |  |
 | `./[z.md` | `[z.md` |  |
+| `./[d/x]ocs/api.md` | none |  |
+| `./docs[/]api.md` | none |  |
+| `./[!/]*/api.md` | none |  |
 | `./{a,b}.md` | `a.md`, `b.md` |  |
 | `./{q}.md` | `{q}.md` |  |
 | `./{a.md` | none |  |
@@ -91,6 +94,16 @@ A test runs every row against dirsql as a path-table and, with the leading
 | `./*/r.md` | `linkdir/r.md`, `real/r.md` |  |
 | `./**/r.md` | `linkdir/r.md`, `real/r.md` |  |
 | `./real/**` | `real/r.md` |  |
+| `./docs//api.md` | `docs//api.md` |  |
+| `./docs//*.md` | `docs//api.md`, `docs//guide.md` |  |
+| `./*//api.md` | `docs/api.md` |  |
+| `./docs/./api.md` | `docs/./api.md` |  |
+| `./*/./api.md` | `docs/./api.md` |  |
+| `./docs/../top.md` | `docs/../top.md` |  |
+| `./docs/nested/../../top.md` | `docs/nested/../../top.md` |  |
+| `./[dlr]*/../top.md` | `docs/../top.md`, `linkdir/../top.md`, `real/../top.md` |  |
+| `./**/nested/../api.md` | `docs/nested/../api.md` |  |
+| `./docs/*/../api.md` | `docs/nested/../api.md` |  |
 | `./docs` | `docs/api.md`, `docs/guide.md` | directory-name |
 | `./docs/` | `docs/api.md`, `docs/guide.md` | directory-name |
 | `./*/` | `docs/api.md`, `docs/guide.md`, `linkdir/r.md`, `real/r.md` | directory-name |

dirsql-0.4.97/packages/python/e2e-attestations/bot-1419-dotdot-slashes.json

@@ -0,0 +1,7 @@
+{
+  "command": "uv run python -m pytest tests/e2e/glob_speed_recursive_test.py tests/e2e/glob_speed_one_level_test.py tests/e2e/glob_speed_matchers_test.py -x -q",
+  "ran_at": 1791392720,
+  "exit_code": 0,
+  "commit": "7ffc3f247a2b09c1a4788f680e7ab1e88342df94",
+  "branch": "bot/1419-dotdot-slashes"
+}

dirsql-0.4.97/packages/python/e2e-attestations/bot-1420-bracket-slash.json

@@ -0,0 +1,7 @@
+{
+  "command": "uv run python -m pytest tests/e2e/glob_speed_matchers_test.py -x -q",
+  "ran_at": 1791393896,
+  "exit_code": 0,
+  "commit": "10ba3a468aaa558480098ec45a7b52b802b681bd",
+  "branch": "bot/1420-bracket-slash"
+}

dirsql-0.4.97/packages/python/e2e-attestations/bot-1440-fix-main-build.json

@@ -0,0 +1,7 @@
+{
+  "command": "uv run python -m pytest tests/e2e/glob_speed_one_level_test.py -x -q",
+  "ran_at": 1791395806,
+  "exit_code": 0,
+  "commit": "a61af62fec489a0a0d45979d96fa045df52a8f60",
+  "branch": "bot/1440-fix-main-build"
+}

dirsql-0.4.97/packages/python/migrations.d/2026-10-07-bracket-slash-literal.md

@@ -0,0 +1,23 @@
+### A slash inside brackets is literal
+
+#### Summary
+
+A slash inside brackets ends the component, so the brackets are literal, as in bash.
+
+#### Required changes
+
+_None._
+
+#### Deprecations removed
+
+_None._
+
+#### Behavior changes without code changes
+
+- A `/` inside `[...]` is literal and ends the component, as in bash: `./[b/c]/*` matches nothing instead of `b/c/*`.
+
+#### Verification
+
+```bash
+dirsql query "SELECT path FROM './[d/x]ocs/api.md'"
+```

dirsql-0.4.97/packages/python/migrations.d/2026-10-07-dotdot-and-double-slashes.md

@@ -0,0 +1,23 @@
+### Relative globs accept //, . and .. components
+
+#### Summary
+
+Relative path-table and config globs now accept `//`, `.` and `..` components as bash does.
+
+#### Required changes
+
+_None._
+
+#### Deprecations removed
+
+_None._
+
+#### Behavior changes without code changes
+
+- A relative path-table accepts `//`, `.` and `..` components and reports the path as written; `./docs//api.md` returns `docs//api.md`, and `./docs/../top.md` matches `top.md` through `docs/..`.
+
+#### Verification
+
+```bash
+dirsql query "SELECT path FROM './docs/../*.md'"
+```

dirsql-0.4.97/packages/python/migrations.d/2026-10-07-fix-main-build.md

@@ -0,0 +1,23 @@
+### Build fix
+
+#### Summary
+
+Fixes the build break from two merged changes.
+
+#### Required changes
+
+_None._
+
+#### Deprecations removed
+
+_None._
+
+#### Behavior changes without code changes
+
+- No user-visible change.
+
+#### Verification
+
+```bash
+dirsql query "SELECT path FROM './docs/../*.md'"
+```

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

{dirsql-0.4.96 → dirsql-0.4.97/packages/rust}/docs/reference/glob.md

@@ -76,6 +76,9 @@ A test runs every row against dirsql as a path-table and, with the leading
 | `./[!a].md` | `1.md`, `2.md`, `3.md`, `4.md`, `b.md`, `c.md` |  |
 | `./\[a\].md` | `[a].md` |  |
 | `./[z.md` | `[z.md` |  |
+| `./[d/x]ocs/api.md` | none |  |
+| `./docs[/]api.md` | none |  |
+| `./[!/]*/api.md` | none |  |
 | `./{a,b}.md` | `a.md`, `b.md` |  |
 | `./{q}.md` | `{q}.md` |  |
 | `./{a.md` | none |  |
@@ -91,6 +94,16 @@ A test runs every row against dirsql as a path-table and, with the leading
 | `./*/r.md` | `linkdir/r.md`, `real/r.md` |  |
 | `./**/r.md` | `linkdir/r.md`, `real/r.md` |  |
 | `./real/**` | `real/r.md` |  |
+| `./docs//api.md` | `docs//api.md` |  |
+| `./docs//*.md` | `docs//api.md`, `docs//guide.md` |  |
+| `./*//api.md` | `docs/api.md` |  |
+| `./docs/./api.md` | `docs/./api.md` |  |
+| `./*/./api.md` | `docs/./api.md` |  |
+| `./docs/../top.md` | `docs/../top.md` |  |
+| `./docs/nested/../../top.md` | `docs/nested/../../top.md` |  |
+| `./[dlr]*/../top.md` | `docs/../top.md`, `linkdir/../top.md`, `real/../top.md` |  |
+| `./**/nested/../api.md` | `docs/nested/../api.md` |  |
+| `./docs/*/../api.md` | `docs/nested/../api.md` |  |
 | `./docs` | `docs/api.md`, `docs/guide.md` | directory-name |
 | `./docs/` | `docs/api.md`, `docs/guide.md` | directory-name |
 | `./*/` | `docs/api.md`, `docs/guide.md`, `linkdir/r.md`, `real/r.md` | directory-name |

{dirsql-0.4.96 → dirsql-0.4.97}/packages/rust/src/brace.rs

@@ -198,7 +198,8 @@ 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 `[` is a literal character.
+/// written; an unclosed `[` is a literal character, and so is one whose
+/// class would span a `/`, which ends a component first.
 fn escape_braces(word: &str) -> String {
     let chars: Vec<char> = word.chars().collect();
     let mut out = String::with_capacity(word.len());
@@ -217,7 +218,7 @@ fn escape_braces(word: &str) -> String {
                 }
                 resume = i + 2;
             }
-            ('[', _) => match class_end(&chars, i) {
+            ('[', _) => match class_end(&chars, i).filter(|&end| !chars[i..end].contains(&'/')) {
                 Some(end) => {
                     out.extend(&chars[i..=end]);
                     resume = end + 1;
@@ -415,6 +416,14 @@ mod tests {
         assert_eq!(escape_braces("a].md"), "a].md");
     }
 
+    #[test]
+    fn a_class_spanning_a_slash_is_literal() {
+        assert_eq!(escape_braces("[b/c]/*"), "[[]b/c]/*");
+        assert_eq!(escape_braces("a[/]b"), "a[[]/]b");
+        assert_eq!(escape_braces("[!/]x"), "[[]!/]x");
+        assert_eq!(escape_braces("[a]/[b]"), "[a]/[b]");
+    }
+
     #[test]
     fn expand_leaves_an_unpartnered_brace_literal() {
         assert_eq!(expand("{a.md"), vec!["[{]a.md"]);

{dirsql-0.4.96 → dirsql-0.4.97}/packages/rust/src/path_table.rs

@@ -193,22 +193,43 @@ fn trailing_separator_as_star<S: Syntax>(name: &str) -> String {
 /// Split a `./`-relative target into the directory to walk beneath the index
 /// root and the glob to match there. The walk starts at the literal prefix
 /// and `path` is reported under it, so the rows read as if the index root
-/// had been walked whole.
+/// had been walked whole. The prefix is kept as written, `//` and `.` and
+/// `..` included, as the shell keeps it; past the first wildcard, repeated
+/// separators collapse.
 fn split_relative(index_root: &Path, rest: &str, is_dir: &dyn Fn(&Path) -> bool) -> PathTable {
-    let target = Utf8Path::<Utf8UnixEncoding>::new(rest);
-    let (literal, glob) = split_target(target, &|rel| is_dir(&index_root.join(rel)));
-    let root = if literal.as_str().is_empty() {
+    let parts: Vec<&str> = rest.split('/').collect();
+    let (literal, glob) = match parts.iter().position(|p| has_glob_metacharacter(p)) {
+        Some(at) => (parts[..at].join("/"), glob_of(&parts[at..])),
+        None if is_dir(&index_root.join(rest)) => (rest.to_string(), DIRECTORY_GLOB.to_string()),
+        None => {
+            let (name, parent) = parts.split_last().expect("split yields a part");
+            (parent.join("/"), (*name).to_string())
+        }
+    };
+    let root = if literal.is_empty() {
         index_root.to_path_buf()
     } else {
-        index_root.join(literal.as_str())
+        index_root.join(&literal)
+    };
+    // A prefix already ending in a separator is not given another when a path
+    // is reported under it, so a written `//` needs the second one here.
+    let path_prefix = if literal.ends_with('/') {
+        format!("{literal}/")
+    } else {
+        literal
     };
     PathTable {
         root,
         glob,
-        path_prefix: literal.into_string(),
+        path_prefix,
     }
 }
 
+fn glob_of(parts: &[&str]) -> String {
+    let kept: Vec<&str> = parts.iter().copied().filter(|p| !p.is_empty()).collect();
+    kept.join("/")
+}
+
 fn typed<S: Syntax>(path: &Path) -> Utf8PathBuf<S> {
     Utf8PathBuf::from(path.to_string_lossy().into_owned())
 }
@@ -400,6 +421,33 @@ mod tests {
         assert_eq!(DEFAULT_IGNORES, ["**/.git/**"]);
     }
 
+    #[test]
+    fn a_double_separator_in_the_literal_prefix_is_kept_as_written() {
+        let t = table("./docs//a.md", &nothing_is_a_dir);
+        assert_eq!(t.root, Path::new("/index/docs/"));
+        assert_eq!(t.glob, "a.md");
+        assert_eq!(t.path_prefix, "docs//");
+    }
+
+    #[test]
+    fn a_current_directory_component_in_the_literal_prefix_is_kept_as_written() {
+        let t = table("./docs/./*.md", &nothing_is_a_dir);
+        assert_eq!(t.glob, "*.md");
+        assert_eq!(t.path_prefix, "docs/.");
+    }
+
+    #[test]
+    fn a_current_directory_component_after_a_wildcard_stays_in_the_glob() {
+        let t = table("./*/./a.md", &nothing_is_a_dir);
+        assert_eq!(t.glob, "*/./a.md");
+    }
+
+    #[test]
+    fn a_double_separator_after_a_wildcard_collapses() {
+        let t = table("./*//a.md", &nothing_is_a_dir);
+        assert_eq!(t.glob, "*/a.md");
+    }
+
     #[test]
     fn has_glob_metacharacter_spots_each_metacharacter() {
         assert!(has_glob_metacharacter("a*"));

{dirsql-0.4.96 → dirsql-0.4.97}/packages/rust/src/scanner.rs

@@ -208,6 +208,9 @@ pub struct PathGlob {
     components: Vec<Component>,
     /// Where each word's components begin.
     starts: Vec<usize>,
+    /// Whether any word spells a `.` or `..` component, which the walk has to
+    /// enter itself: a directory listing never names them.
+    spells_relative: bool,
 }
 
 #[derive(Debug, Clone)]
@@ -253,6 +256,19 @@ impl PathGlob {
         !self.components.is_empty()
     }
 
+    /// The `.` and `..` entries a directory reached with `states` has as far
+    /// as the pattern is concerned, each with the states it leads to.
+    fn relative_entries(&self, states: &[usize]) -> Vec<(&'static str, Vec<usize>)> {
+        if !self.spells_relative {
+            return Vec::new();
+        }
+        [".", ".."]
+            .into_iter()
+            .map(|name| (name, self.step(states, OsStr::new(name), Kind::Dir)))
+            .filter(|(_, next)| self.reaches(next, Kind::Dir))
+            .collect()
+    }
+
     fn start(&self) -> Vec<usize> {
         self.closure(self.starts.clone())
     }
@@ -319,7 +335,11 @@ pub fn compile_globs(patterns: &[&str]) -> Result<PathGlob, GlobError> {
     let words: Vec<String> = patterns
         .iter()
         .flat_map(|pattern| crate::brace::expand(pattern))
+        .map(|word| collapse_separators(&word))
         .collect();
+    let spells_relative = words
+        .iter()
+        .any(|word| word.split('/').any(|c| c == "." || c == ".."));
     let mut files = Vec::new();
     let mut spelled_dot_names = Vec::new();
     for word in &words {
@@ -330,10 +350,8 @@ pub fn compile_globs(patterns: &[&str]) -> Result<PathGlob, GlobError> {
     }
     let mut components = Vec::new();
     let mut starts = Vec::new();
-    // All or nothing: the walk prunes a directory no component can enter, so
-    // a word left without components would lose its matches.
-    let compiled: Option<Vec<_>> = words.iter().map(|w| compile_components(w)).collect();
-    for word_components in compiled.unwrap_or_default() {
+    for word in &words {
+        let word_components = compile_components(word)?;
         starts.push(components.len());
         components.extend(word_components);
         components.push(Component::End);
@@ -343,16 +361,27 @@ pub fn compile_globs(patterns: &[&str]) -> Result<PathGlob, GlobError> {
         spelled_dot_names,
         components,
         starts,
+        spells_relative,
     })
 }
 
+/// `word` with each run of `/` made one, as the shell reads a pattern's
+/// components.
+fn collapse_separators(word: &str) -> String {
+    let mut out = String::with_capacity(word.len());
+    for c in word.chars() {
+        if c != '/' || !out.ends_with('/') {
+            out.push(c);
+        }
+    }
+    out
+}
+
 fn is_dot_named(name: &OsStr) -> bool {
     name.as_encoded_bytes().first() == Some(&b'.')
 }
 
-/// A word whose components do not compile on their own (a class spanning a
-/// `/`) gets none.
-fn compile_components(word: &str) -> Option<Vec<Component>> {
+fn compile_components(word: &str) -> Result<Vec<Component>, GlobError> {
     let mut components = word
         .split('/')
         .map(|c| match c {
@@ -360,10 +389,9 @@ fn compile_components(word: &str) -> Option<Vec<Component>> {
             _ if is_dot_named(OsStr::new(c)) => Pattern::new(c).map(Component::DotName),
             _ => Pattern::new(c).map(Component::Name),
         })
-        .collect::<Result<Vec<_>, _>>()
-        .ok()?;
+        .collect::<Result<Vec<_>, _>>()?;
     components.dedup_by(|a, b| matches!((a, b), (Component::AnyDepth, Component::AnyDepth)));
-    Some(components)
+    Ok(components)
 }
 
 /// Module-argument spelling for a scan that respects `.gitignore`.
@@ -486,6 +514,21 @@ impl<'a> Place<'a> {
         } else {
             Vec::new()
         };
+        let relative = walk.glob.map_or_else(Vec::new, |glob| {
+            glob.relative_entries(&states)
+                .into_iter()
+                .map(|(name, next)| {
+                    Step::Dir(Box::new(Place {
+                        walk: walk.clone(),
+                        dir: dir.join(name),
+                        rel: rel.join(name),
+                        states: next,
+                        linked,
+                    }))
+                })
+                .collect::<Vec<_>>()
+        });
+        steps.extend(relative);
         let entered =
             listing
                 .entries()
@@ -1037,6 +1080,44 @@ mod tests {
         assert_eq!(nested, vec![Path::new("a").join(".dirsql")]);
     }
 
+    #[test]
+    fn explore_enters_a_current_directory_component_the_glob_spells() {
+        let root = tempfile::tempdir().unwrap();
+        let ignore = TableMatcher::new(&[], &[]).unwrap();
+        let glob = compile_glob("./x").unwrap();
+        let top = Place {
+            walk: walk_with(&ignore, Some(&glob), Vec::new()),
+            dir: root.path().to_path_buf(),
+            rel: PathBuf::new(),
+            states: glob.start(),
+            linked: false,
+        };
+        let [dot] = <[Place<'_>; 1]>::try_from(explored_dirs(top)).ok().unwrap();
+        assert_eq!(dot.rel, Path::new("."));
+        assert_eq!(dot.dir, root.path().join("."));
+    }
+
+    #[test]
+    fn relative_entries_name_only_the_components_the_glob_spells() {
+        let glob = compile_glob("*/../x").unwrap();
+        let states = glob.step(&glob.start(), OsStr::new("docs"), Kind::Dir);
+        let entries = glob.relative_entries(&states);
+        assert_eq!(
+            entries.iter().map(|(name, _)| *name).collect::<Vec<_>>(),
+            vec![".."]
+        );
+        let plain = compile_glob("*/x").unwrap();
+        let states = plain.step(&plain.start(), OsStr::new("docs"), Kind::Dir);
+        assert!(plain.relative_entries(&states).is_empty());
+    }
+
+    #[test]
+    fn a_glob_spells_relative_components_only_when_a_word_has_one() {
+        assert!(compile_glob("a/./b").unwrap().spells_relative);
+        assert!(compile_glob("a/../b").unwrap().spells_relative);
+        assert!(!compile_glob("a/b").unwrap().spells_relative);
+    }
+
     #[test]
     fn reaches_dir_enters_the_root_and_unignored_directories() {
         let ignore = TableMatcher::new(&[], &["**/node_modules/**"]).unwrap();
@@ -1465,19 +1546,12 @@ mod tests {
     }
 
     #[test]
-    fn a_pattern_whose_components_do_not_compile_alone_follows_no_link() {
-        let glob = compile_glob("[a/b]").unwrap();
+    fn a_glob_without_words_follows_no_link() {
+        let glob = compile_globs(&[]).unwrap();
         assert!(glob.components.is_empty());
         assert!(!glob.reaches(&glob.start(), Kind::LinkedDir));
     }
 
-    #[test]
-    fn one_brace_word_without_components_leaves_the_glob_without_any() {
-        let glob = compile_glob("{x,[a/b]}").unwrap();
-        assert!(glob.components.is_empty());
-        assert!(!glob.has_components());
-    }
-
     #[test]
     fn each_brace_word_is_walked_from_its_own_start() {
         let glob = compile_glob("{a,b/c}").unwrap();
@@ -1575,7 +1649,7 @@ mod tests {
     #[test]
     fn enters_every_real_directory_when_the_glob_has_no_components() {
         let ignore = TableMatcher::new(&[], &[]).unwrap();
-        let glob = compile_glob("[a/b]").unwrap();
+        let glob = compile_globs(&[]).unwrap();
         let walk = Walk {
             ignore: &ignore,
             glob: Some(&glob),