dirsql 0.4.69__tar.gz → 0.4.71__tar.gz

{dirsql-0.4.69 → dirsql-0.4.71}/Cargo.lock

@@ -552,7 +552,7 @@ checksum = "6184e33543162437515c2e2b48714794e37845ec9851711914eec9d308f6ebe8"
 
 [[package]]
 name = "dirsql"
-version = "0.4.69"
+version = "0.4.71"
 dependencies = [
  "assert_cmd",
  "axum",
@@ -601,7 +601,7 @@ dependencies = [
 
 [[package]]
 name = "dirsql-py-ext"
-version = "0.4.69"
+version = "0.4.71"
 dependencies = [
  "dirsql",
  "pyo3",

{dirsql-0.4.69 → dirsql-0.4.71}/PKG-INFO

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

{dirsql-0.4.69/packages/rust → dirsql-0.4.71}/docs/reference/path-tables.md

@@ -295,6 +295,15 @@ SELECT path FROM './dist';                 -- scans dist/ even when gitignored
 The `.gitignore` files in force there, including those above it, still
 filter what lies beneath it.
 
+A `node_modules` component after a glob names it too, at any depth:
+
+```sql
+SELECT path FROM './**/node_modules/*/package.json';  -- every node_modules
+SELECT path FROM './*/node_modules/**';               -- one level down
+```
+
+Only the literal name counts; `'./**/*.js'` still skips every `node_modules`.
+
 ### Hidden files
 
 A path component starting with `.` is skipped unless the path spells it, the

{dirsql-0.4.69 → dirsql-0.4.71}/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.69"
+version = "0.4.71"
 # 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.71/packages/python/changelog.d/2026-10-05-path-table-node-modules-named.md

@@ -0,0 +1,6 @@
+**Fixed** A path-table pattern that names `node_modules` after a glob
+component now scans it: `'./**/node_modules/**'` lists every `node_modules`
+in the tree and `'./*/node_modules/*/*'` the ones one level down. Only a
+`node_modules` in the literal prefix used to count, so these returned nothing.
+A pattern that does not name `node_modules`, such as `'./**'` or
+`'./**/*.js'`, still skips it.

{dirsql-0.4.69 → dirsql-0.4.71}/packages/python/docs/reference/path-tables.md

@@ -295,6 +295,15 @@ SELECT path FROM './dist';                 -- scans dist/ even when gitignored
 The `.gitignore` files in force there, including those above it, still
 filter what lies beneath it.
 
+A `node_modules` component after a glob names it too, at any depth:
+
+```sql
+SELECT path FROM './**/node_modules/*/package.json';  -- every node_modules
+SELECT path FROM './*/node_modules/**';               -- one level down
+```
+
+Only the literal name counts; `'./**/*.js'` still skips every `node_modules`.
+
 ### Hidden files
 
 A path component starting with `.` is skipped unless the path spells it, the

dirsql-0.4.71/packages/python/e2e-attestations/claude-1267-posix-classes.json

@@ -0,0 +1,7 @@
+{
+  "command": "just test-e2e",
+  "ran_at": 1791224868,
+  "exit_code": 0,
+  "commit": "ca8ccbb55b7f51f9373b8f774665b925ba10ac21",
+  "branch": "claude/1267-posix-classes"
+}

dirsql-0.4.71/packages/python/e2e-attestations/claude-1271-node-modules-named.json

@@ -0,0 +1,7 @@
+{
+  "command": "just test-e2e",
+  "ran_at": 1791224899,
+  "exit_code": 0,
+  "commit": "e48a79c9fc67e5c2d69ec6c77116e5d2730684bb",
+  "branch": "claude/1271-node-modules-named"
+}

dirsql-0.4.71/packages/python/migrations.d/2026-10-05-path-table-node-modules-named.md

@@ -0,0 +1,37 @@
+### Core: `node_modules` named after a glob is scanned
+
+#### Summary
+
+A path-table pattern with a literal `node_modules` component after a glob,
+such as `'./**/node_modules/**'`, now scans the `node_modules` directories it
+names; it used to return nothing. Every surface that resolves a path-table is
+affected: the CLI, the REPL, the HTTP server, the SDKs, and the `--on-file`
+form. Nothing breaks; such a query can return more rows. A pattern that does
+not name `node_modules` still skips it, and declared `[[table]]` globs are
+unchanged.
+
+#### Required changes
+
+_None._
+
+#### Deprecations removed
+
+_None._
+
+#### Behavior changes without code changes
+
+- `'./**/node_modules/**'` lists files under every `node_modules`.
+- `'./*/node_modules/*/*'` lists files two levels into each `node_modules`
+  one level down.
+
+#### Verification
+
+```bash
+cd "$(mktemp -d)"
+mkdir -p node_modules/pkg pkg/node_modules/dep
+touch node_modules/pkg/index.js pkg/node_modules/dep/i.js
+dirsql query "SELECT path FROM './**/node_modules/*/*' ORDER BY path"
+# expected: [{"path":"node_modules/pkg/index.js"},{"path":"pkg/node_modules/dep/i.js"}]
+dirsql query "SELECT path FROM './**/*.js'"
+# expected: []
+```

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

{dirsql-0.4.69 → dirsql-0.4.71/packages/rust}/docs/reference/path-tables.md

@@ -295,6 +295,15 @@ SELECT path FROM './dist';                 -- scans dist/ even when gitignored
 The `.gitignore` files in force there, including those above it, still
 filter what lies beneath it.
 
+A `node_modules` component after a glob names it too, at any depth:
+
+```sql
+SELECT path FROM './**/node_modules/*/package.json';  -- every node_modules
+SELECT path FROM './*/node_modules/**';               -- one level down
+```
+
+Only the literal name counts; `'./**/*.js'` still skips every `node_modules`.
+
 ### Hidden files
 
 A path component starting with `.` is skipped unless the path spells it, the

{dirsql-0.4.69 → dirsql-0.4.71}/packages/rust/src/db.rs

@@ -315,7 +315,8 @@ pub struct Db {
     /// exactly where `files` used to exist implicitly. A user who declared
     /// tables and forgot `files` gets the plain SQLite error.
     hint_legacy_files_table: bool,
-    /// Skip rules a path-table scan applies, seeded with the built-in defaults.
+    /// Configured skip rules a path-table scan applies on top of the table's
+    /// [`PathTable::default_ignores`].
     path_table_ignore: Vec<String>,
     /// Whether a path-table scan respects `.gitignore` files. On by default;
     /// the CLI's `--no-ignore` turns it off.
@@ -351,14 +352,6 @@ fn worker_error(message: String) -> DbError {
     DbError::Sqlite(rusqlite::Error::UserFunctionError(message.into()))
 }
 
-/// The skip rules a fresh `Db` starts with.
-fn default_path_table_ignore() -> Vec<String> {
-    path_table::DEFAULT_IGNORES
-        .iter()
-        .map(|s| (*s).to_string())
-        .collect()
-}
-
 impl Db {
     /// Open the default, ephemeral `Db`: an **anonymous disk-backed temp
     /// database** (`Connection::open("")`), not `:memory:`.
@@ -382,7 +375,7 @@ impl Db {
             scope,
             path_table_root: None,
             hint_legacy_files_table: false,
-            path_table_ignore: default_path_table_ignore(),
+            path_table_ignore: Vec::new(),
             path_table_gitignore: true,
             path_table_parser: None,
             calls: CallReporter::new(),
@@ -407,7 +400,7 @@ impl Db {
             scope,
             path_table_root: None,
             hint_legacy_files_table: false,
-            path_table_ignore: default_path_table_ignore(),
+            path_table_ignore: Vec::new(),
             path_table_gitignore: true,
             path_table_parser: None,
             calls: CallReporter::new(),
@@ -1170,10 +1163,15 @@ impl Db {
             .path_table_root
             .as_deref()
             .expect("a path-table resolves only under an index root");
+        let ignore: Vec<String> = table
+            .default_ignores()
+            .map(str::to_string)
+            .chain(self.path_table_ignore.iter().cloned())
+            .collect();
         self.conn.execute_batch(&path_table_ddl(
             name,
             table,
-            &self.path_table_ignore,
+            &ignore,
             self.path_table_gitignore,
             self.path_table_parser.as_deref(),
             index_root,
@@ -3083,14 +3081,6 @@ mod tests {
         );
     }
 
-    #[test]
-    fn default_path_table_ignore_carries_the_documented_defaults() {
-        assert_eq!(
-            default_path_table_ignore(),
-            vec!["**/node_modules/**".to_string(), "**/.git/**".to_string()]
-        );
-    }
-
     fn docs_path_table() -> PathTable {
         PathTable {
             root: PathBuf::from("/root"),
@@ -3304,17 +3294,12 @@ mod tests {
     }
 
     #[test]
-    fn add_path_table_ignore_extends_the_defaults() {
+    fn add_path_table_ignore_accumulates_configured_rules() {
         let mut db = Db::new().unwrap();
         db.add_path_table_ignore(vec!["*.tmp".to_string()]);
+        db.add_path_table_ignore(vec!["*.bak".to_string()]);
 
-        assert_eq!(db.path_table_ignore.last(), Some(&"*.tmp".to_string()));
-        assert!(
-            db.path_table_ignore
-                .contains(&"**/node_modules/**".to_string()),
-            "the built-in defaults must survive: {:?}",
-            db.path_table_ignore
-        );
+        assert_eq!(db.path_table_ignore, ["*.tmp", "*.bak"]);
     }
 
     #[test]

{dirsql-0.4.69 → dirsql-0.4.71}/packages/rust/src/lib.rs

@@ -33,6 +33,7 @@ pub mod parsed_vtab;
 pub mod path_table;
 #[doc(hidden)]
 pub mod persist;
+mod posix_class;
 #[doc(hidden)]
 pub mod progress;
 #[doc(hidden)]

{dirsql-0.4.69 → dirsql-0.4.71}/packages/rust/src/matcher.rs

@@ -1,3 +1,4 @@
+use crate::posix_class::expand_posix_classes;
 use globset::GlobBuilder;
 use regex::{Regex, RegexBuilder};
 use std::path::Path;
@@ -20,7 +21,9 @@ pub(crate) struct Pattern(Regex);
 impl Pattern {
     /// `*` and `?` stop at `/`; `**` crosses it.
     pub(crate) fn new(glob: &str) -> Result<Self, GlobError> {
-        let glob = GlobBuilder::new(glob).literal_separator(true).build()?;
+        let glob = GlobBuilder::new(&expand_posix_classes(glob))
+            .literal_separator(true)
+            .build()?;
         let regex = RegexBuilder::new(&unicode_regex(glob.regex()))
             .dot_matches_new_line(true)
             .build()?;
@@ -586,4 +589,11 @@ mod tests {
                 .is_empty()
         );
     }
+
+    #[test]
+    fn a_posix_class_in_a_table_glob_matches_its_characters() {
+        let matcher = TableMatcher::new(&[("notes/[[:digit:]].md", "n")], &[]).unwrap();
+        assert_eq!(names(&matcher, "notes/7.md"), vec!["n"]);
+        assert!(matcher.match_all(Path::new("notes/x.md")).is_empty());
+    }
 }

{dirsql-0.4.69 → dirsql-0.4.71}/packages/rust/src/path_table.rs

@@ -16,8 +16,11 @@ use typed_path::{
 
 /// Directories a path-table scan skips, at any depth. They are skipped only
 /// *beneath* the literal part of the path you write, so naming one explicitly
-/// still scans it.
-pub const DEFAULT_IGNORES: [&str; 2] = ["**/node_modules/**", "**/.git/**"];
+/// still scans it. See [`PathTable::default_ignores`] for `node_modules`
+/// named after a glob.
+pub const DEFAULT_IGNORES: [&str; 2] = [NODE_MODULES_IGNORE, "**/.git/**"];
+
+const NODE_MODULES_IGNORE: &str = "**/node_modules/**";
 
 /// The glob a directory expands to: one level, like `ls`. Any depth is
 /// spelled explicitly as `**`.
@@ -36,6 +39,18 @@ pub struct PathTable {
     pub path_prefix: String,
 }
 
+impl PathTable {
+    /// The [`DEFAULT_IGNORES`] this table applies. A glob with a
+    /// `node_modules` component names that directory wherever the component
+    /// sits, so its skip rule is dropped.
+    pub fn default_ignores(&self) -> impl Iterator<Item = &'static str> {
+        let names_node_modules = self.glob.split('/').any(|c| c == "node_modules");
+        DEFAULT_IGNORES
+            .into_iter()
+            .filter(move |rule| !(names_node_modules && *rule == NODE_MODULES_IGNORE))
+    }
+}
+
 /// What a name SQLite could not find turns out to be.
 #[derive(Debug, PartialEq)]
 pub enum Resolution {
@@ -315,6 +330,32 @@ mod tests {
         assert_eq!(DEFAULT_IGNORES, ["**/node_modules/**", "**/.git/**"]);
     }
 
+    fn table_globbing(glob: &str) -> PathTable {
+        PathTable {
+            root: PathBuf::from("/r"),
+            glob: glob.to_string(),
+            path_prefix: String::new(),
+        }
+    }
+
+    fn default_ignores_of(glob: &str) -> Vec<&'static str> {
+        table_globbing(glob).default_ignores().collect()
+    }
+
+    #[test]
+    fn a_glob_not_naming_node_modules_keeps_every_default_ignore() {
+        assert_eq!(default_ignores_of("**"), DEFAULT_IGNORES);
+        assert_eq!(default_ignores_of("**/*.js"), DEFAULT_IGNORES);
+        assert_eq!(default_ignores_of("node_modules*/*"), DEFAULT_IGNORES);
+    }
+
+    #[test]
+    fn a_glob_naming_node_modules_anywhere_drops_its_ignore() {
+        assert_eq!(default_ignores_of("**/node_modules/**"), ["**/.git/**"]);
+        assert_eq!(default_ignores_of("*/node_modules/*/*"), ["**/.git/**"]);
+        assert_eq!(default_ignores_of("node_modules"), ["**/.git/**"]);
+    }
+
     #[test]
     fn has_glob_metacharacter_spots_each_metacharacter() {
         assert!(has_glob_metacharacter("a*"));

dirsql-0.4.71/packages/rust/src/posix_class.rs

@@ -0,0 +1,313 @@
+//! POSIX character classes (`[[:digit:]]`) for globset, which has no
+//! `[:name:]` syntax: each bracket expression holding one is rewritten into an
+//! equivalent bracket of plain ranges before the glob is compiled.
+
+/// Rewrite every bracket expression in `pattern` that holds a `[:name:]`
+/// class into plain ranges. Brackets without one, unclosed brackets and
+/// backslash-escaped characters are left exactly as written.
+pub(crate) fn expand_posix_classes(pattern: &str) -> String {
+    let chars: Vec<char> = pattern.chars().collect();
+    let mut out = String::with_capacity(pattern.len());
+    let mut i = 0;
+    while i < chars.len() {
+        match chars[i] {
+            '\\' => {
+                let end = (i + 2).min(chars.len());
+                out.extend(&chars[i..end]);
+                i = end;
+            }
+            '[' => match bracket(&chars, i) {
+                Some((end, Some(rewritten))) => {
+                    out.push_str(&rewritten);
+                    i = end;
+                }
+                Some((end, None)) => {
+                    out.extend(&chars[i..end]);
+                    i = end;
+                }
+                None => {
+                    out.push('[');
+                    i += 1;
+                }
+            },
+            c => {
+                out.push(c);
+                i += 1;
+            }
+        }
+    }
+    out
+}
+
+/// Parse the bracket expression opening at `start`. `None` when it never
+/// closes; otherwise the index past its `]`, plus its rewrite when it holds a
+/// class.
+fn bracket(chars: &[char], start: usize) -> Option<(usize, Option<String>)> {
+    let mut j = start + 1;
+    let negated = matches!(chars.get(j), Some('!' | '^'));
+    if negated {
+        j += 1;
+    }
+    let body_start = j;
+    let mut ranges: Vec<(char, char)> = Vec::new();
+    let mut has_class = false;
+    // bash matches nothing at all when a range ends in a class, negated or not.
+    let mut range_into_class = false;
+    loop {
+        let c = *chars.get(j)?;
+        if c == ']' && j > body_start {
+            j += 1;
+            break;
+        }
+        if let Some((name, next)) = class_at(chars, j) {
+            ranges.extend_from_slice(class_ranges(&name));
+            has_class = true;
+            j = next;
+            continue;
+        }
+        match (chars.get(j + 1), chars.get(j + 2)) {
+            (Some('-'), Some(&end)) if end != ']' => {
+                if let Some((_, next)) = class_at(chars, j + 2) {
+                    has_class = true;
+                    range_into_class = true;
+                    j = next;
+                    continue;
+                }
+                if c <= end {
+                    ranges.push((c, end));
+                }
+                j += 3;
+            }
+            _ => {
+                ranges.push((c, c));
+                j += 1;
+            }
+        }
+    }
+    if !has_class {
+        return Some((j, None));
+    }
+    let rewritten = if range_into_class {
+        "[\0]".to_string()
+    } else {
+        render(negated, ranges)
+    };
+    Some((j, Some(rewritten)))
+}
+
+/// The class `[:name:]` starting at `j`, with the index past its `:]`. A `]`
+/// before the `:]` means the `[` is an ordinary character, as in bash.
+fn class_at(chars: &[char], j: usize) -> Option<(String, usize)> {
+    if chars.get(j) != Some(&'[') || chars.get(j + 1) != Some(&':') {
+        return None;
+    }
+    let mut k = j + 2;
+    loop {
+        match (chars.get(k)?, chars.get(k + 1)) {
+            (':', Some(']')) => return Some((chars[j + 2..k].iter().collect(), k + 2)),
+            (']', _) => return None,
+            _ => k += 1,
+        }
+    }
+}
+
+/// The ASCII members of a class; an unknown name has none, as in bash.
+fn class_ranges(name: &str) -> &'static [(char, char)] {
+    match name {
+        "alnum" => &[('0', '9'), ('A', 'Z'), ('a', 'z')],
+        "alpha" => &[('A', 'Z'), ('a', 'z')],
+        "ascii" => &[('\0', '\x7f')],
+        "blank" => &[(' ', ' '), ('\t', '\t')],
+        "cntrl" => &[('\0', '\x1f'), ('\x7f', '\x7f')],
+        "digit" => &[('0', '9')],
+        "graph" => &[('!', '~')],
+        "lower" => &[('a', 'z')],
+        "print" => &[(' ', '~')],
+        "punct" => &[('!', '/'), (':', '@'), ('[', '`'), ('{', '~')],
+        "space" => &[('\t', '\r'), (' ', ' ')],
+        "upper" => &[('A', 'Z')],
+        "word" => &[('0', '9'), ('A', 'Z'), ('a', 'z'), ('_', '_')],
+        "xdigit" => &[('0', '9'), ('A', 'F'), ('a', 'f')],
+        _ => &[],
+    }
+}
+
+/// Characters globset reads as syntax at some position inside a bracket, so
+/// they are pulled out of ranges and placed where they are literal.
+const POSITIONAL: [char; 4] = [']', '-', '!', '^'];
+
+/// A globset bracket matching exactly `ranges` (or everything else when
+/// `negated`). A bracket never matches the separator, so `/` is dropped from a
+/// positive set and added to a negated one. NUL, which no path holds, stands
+/// in when nothing else may open the bracket.
+fn render(negated: bool, ranges: Vec<(char, char)>) -> String {
+    let mut set: Vec<(u32, u32)> = ranges
+        .into_iter()
+        .map(|(a, b)| (a as u32, b as u32))
+        .collect();
+    set = without(set, '/');
+    if negated {
+        set.push(('/' as u32, '/' as u32));
+    }
+    let present = |c: char| set.iter().any(|&(a, b)| a <= c as u32 && c as u32 <= b);
+    let specials: Vec<char> = POSITIONAL.into_iter().filter(|&c| present(c)).collect();
+    let mut plain = POSITIONAL.into_iter().fold(set.clone(), without);
+    plain.sort_unstable();
+    if plain.is_empty() && !specials.contains(&']') {
+        plain.push((0, 0));
+    }
+
+    let mut out = String::from("[");
+    if negated {
+        out.push('!');
+    }
+    if specials.contains(&']') {
+        out.push(']');
+    }
+    for (a, b) in plain {
+        out.extend(char::from_u32(a));
+        if a != b {
+            out.push('-');
+            out.extend(char::from_u32(b));
+        }
+    }
+    for c in ['!', '^', '-'] {
+        if specials.contains(&c) {
+            out.push(c);
+        }
+    }
+    out.push(']');
+    out
+}
+
+/// `set` with `c` removed, splitting any range that spans it. `c` is never
+/// NUL, so `c - 1` cannot underflow.
+fn without(set: Vec<(u32, u32)>, c: char) -> Vec<(u32, u32)> {
+    let c = c as u32;
+    set.into_iter()
+        .flat_map(|(a, b)| [(a, b.min(c - 1)), (a.max(c + 1), b)])
+        .filter(|&(a, b)| a <= b)
+        .collect()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn a_class_becomes_its_ranges() {
+        assert_eq!(expand_posix_classes("[[:digit:]].md"), "[0-9].md");
+        assert_eq!(expand_posix_classes("[[:upper:]]*"), "[A-Z]*");
+    }
+
+    #[test]
+    fn every_named_class_expands() {
+        let cases = [
+            ("alnum", "[0-9A-Za-z]"),
+            ("alpha", "[A-Za-z]"),
+            ("ascii", "[]\0- \"-,.0-\\_-\x7f!^-]"),
+            ("blank", "[\t ]"),
+            ("cntrl", "[\0-\x1f\x7f]"),
+            ("digit", "[0-9]"),
+            ("graph", "[]\"-,.0-\\_-~!^-]"),
+            ("lower", "[a-z]"),
+            ("print", "[] \"-,.0-\\_-~!^-]"),
+            ("punct", "[]\"-,.:-@[-\\_-`{-~!^-]"),
+            ("space", "[\t-\r ]"),
+            ("upper", "[A-Z]"),
+            ("word", "[0-9A-Z_a-z]"),
+            ("xdigit", "[0-9A-Fa-f]"),
+        ];
+        for (name, want) in cases {
+            assert_eq!(
+                expand_posix_classes(&format!("[[:{name}:]]")),
+                want,
+                "{name}"
+            );
+        }
+    }
+
+    #[test]
+    fn a_negated_class_also_excludes_the_separator() {
+        assert_eq!(expand_posix_classes("[![:digit:]]"), "[!/0-9]");
+        assert_eq!(expand_posix_classes("[^[:digit:]]"), "[!/0-9]");
+    }
+
+    #[test]
+    fn classes_and_characters_combine() {
+        assert_eq!(expand_posix_classes("[a[:digit:]]"), "[0-9a]");
+        assert_eq!(expand_posix_classes("[[:digit:][:upper:]]"), "[0-9A-Z]");
+        assert_eq!(expand_posix_classes("[[:digit:]x-z]"), "[0-9x-z]");
+    }
+
+    #[test]
+    fn a_dash_after_a_class_is_literal() {
+        assert_eq!(expand_posix_classes("[[:digit:]-z]"), "[0-9z-]");
+        assert_eq!(expand_posix_classes("[[:digit:]-]"), "[0-9-]");
+        assert_eq!(expand_posix_classes("[[:digit:]x-]"), "[0-9x-]");
+    }
+
+    #[test]
+    fn a_leading_close_bracket_is_a_member() {
+        assert_eq!(expand_posix_classes("[][:digit:]]"), "[]0-9]");
+    }
+
+    #[test]
+    fn an_unknown_class_contributes_nothing() {
+        assert_eq!(expand_posix_classes("[[:foo:]a]"), "[a]");
+        assert_eq!(expand_posix_classes("[[:DIGIT:]]"), "[\0]");
+        assert_eq!(expand_posix_classes("[![:foo:]]"), "[!/]");
+    }
+
+    #[test]
+    fn a_lone_bang_is_kept_off_the_negation_position() {
+        assert_eq!(expand_posix_classes("[[:foo:]!]"), "[\0!]");
+        assert_eq!(expand_posix_classes("[[:foo:]^]"), "[\0^]");
+    }
+
+    #[test]
+    fn a_range_ending_in_a_class_matches_nothing() {
+        assert_eq!(expand_posix_classes("[x-[:digit:]]"), "[\0]");
+        assert_eq!(expand_posix_classes("[!x-[:digit:]]"), "[\0]");
+    }
+
+    #[test]
+    fn a_reversed_range_beside_a_class_is_empty() {
+        assert_eq!(expand_posix_classes("[z-a[:digit:]]"), "[0-9]");
+    }
+
+    #[test]
+    fn a_bracket_without_a_class_is_untouched() {
+        for pattern in [
+            "[a-c]*",
+            "[!x].md",
+            "[]]",
+            "[[:a]",
+            "{a,b}/[xy]",
+            "[a:digit:]]",
+            "[[:a][:digit:]]",
+        ] {
+            assert_eq!(expand_posix_classes(pattern), pattern);
+        }
+    }
+
+    #[test]
+    fn an_unclosed_bracket_is_untouched() {
+        assert_eq!(expand_posix_classes("[[:digit:]"), "[[:digit:]");
+        assert_eq!(expand_posix_classes("a["), "a[");
+    }
+
+    #[test]
+    fn an_escaped_bracket_is_untouched() {
+        assert_eq!(expand_posix_classes("\\[[:digit:]]"), "\\[[:digit:]]");
+        assert_eq!(expand_posix_classes("a\\"), "a\\");
+    }
+
+    #[test]
+    fn text_around_brackets_is_kept() {
+        assert_eq!(
+            expand_posix_classes("**/v[[:digit:]]/*.md"),
+            "**/v[0-9]/*.md"
+        );
+    }
+}