dirsql 0.4.58__tar.gz → 0.4.60__tar.gz

{dirsql-0.4.58 → dirsql-0.4.60}/Cargo.lock

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

{dirsql-0.4.58 → dirsql-0.4.60}/PKG-INFO

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

{dirsql-0.4.58 → dirsql-0.4.60}/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.58"
+version = "0.4.60"
 # 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.60/packages/python/e2e-attestations/claude-1184-win-rel-paths.json

@@ -0,0 +1,7 @@
+{
+  "command": "just test-e2e",
+  "ran_at": 1790605446,
+  "exit_code": 0,
+  "commit": "ab668f9f958ed79fe0598f6cc494f1d0cc049316",
+  "branch": "claude/1184-win-rel-paths"
+}

dirsql-0.4.60/packages/python/e2e-attestations/claude-1186-win-test-harness.json

@@ -0,0 +1,7 @@
+{
+  "command": "just test-e2e",
+  "ran_at": 1790603833,
+  "exit_code": 0,
+  "commit": "6b84d84d60179482a842b0db205ee257f8e03c11",
+  "branch": "claude/1186-win-test-harness"
+}

dirsql-0.4.60/packages/python/e2e-attestations/claude-1207-win-argv-quote.json

@@ -0,0 +1,7 @@
+{
+  "command": "just test-e2e",
+  "ran_at": 1790939617,
+  "exit_code": 0,
+  "commit": "009c015ffa36453da6d92ddec17b5b655b51372f",
+  "branch": "claude/1207-win-argv-quote"
+}

dirsql-0.4.60/packages/python/e2e-attestations/claude-1208-win-nonverbatim-paths.json

@@ -0,0 +1,7 @@
+{
+  "command": "just test-e2e",
+  "ran_at": 1790939958,
+  "exit_code": 0,
+  "commit": "64a48bb1eff07865a52fc25e1ad50722aced9e45",
+  "branch": "claude/1208-win-nonverbatim-paths"
+}

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

{dirsql-0.4.58 → dirsql-0.4.60}/packages/rust/src/command.rs

@@ -49,6 +49,63 @@ impl Placeholder {
             value: value.into(),
         }
     }
+
+    /// A placeholder whose value is a filesystem path, handed to the child in
+    /// its plain (non-verbatim) form; see [`non_verbatim`].
+    pub fn path(name: impl Into<String>, path: &str) -> Self {
+        Self::new(name, non_verbatim(path))
+    }
+}
+
+/// The plain form of a Windows verbatim path: `\\?\C:\x` becomes `C:\x` and
+/// `\\?\UNC\server\share\x` becomes `\\server\share\x`. Anything else, and any
+/// verbatim path whose plain spelling would name a different file, is returned
+/// unchanged.
+pub(crate) fn non_verbatim(path: &str) -> String {
+    plain_form(path).unwrap_or_else(|| path.to_string())
+}
+
+fn plain_form(path: &str) -> Option<String> {
+    let rest = path.strip_prefix(r"\\?\")?;
+    let (plain, tail) = if let Some(unc) = rest.strip_prefix(r"UNC\") {
+        if unc.split('\\').count() < 2 {
+            return None;
+        }
+        (format!(r"\\{unc}"), unc)
+    } else {
+        let drive = rest.as_bytes();
+        let is_drive = drive.len() >= 3
+            && drive[0].is_ascii_alphabetic()
+            && drive[1] == b':'
+            && drive[2] == b'\\';
+        if !is_drive {
+            return None;
+        }
+        (rest.to_string(), &rest[3..])
+    };
+    // Win32 rejects or rewrites these, so the plain spelling would not name
+    // the same file; MAX_PATH counts UTF-16 units including the terminator.
+    let same_file = (tail.is_empty() || tail.split('\\').all(is_plain_component))
+        && plain.encode_utf16().count() < 260;
+    same_file.then_some(plain)
+}
+
+fn is_plain_component(name: &str) -> bool {
+    let invalid_char = |c: char| c < ' ' || r#"/<>:"|?*"#.contains(c);
+    let stem = name
+        .split_once('.')
+        .map_or(name, |(stem, _)| stem)
+        .trim_end_matches(' ');
+    let reserved = matches!(
+        stem.to_ascii_uppercase().as_bytes(),
+        b"CON"
+            | b"PRN"
+            | b"AUX"
+            | b"NUL"
+            | [b'C', b'O', b'M', b'1'..=b'9']
+            | [b'L', b'P', b'T', b'1'..=b'9']
+    );
+    !name.is_empty() && !name.ends_with(['.', ' ']) && !name.contains(invalid_char) && !reserved
 }
 
 /// A successful command run.
@@ -119,8 +176,8 @@ pub fn run_command(
     let argv = build_argv(command, placeholders)?;
     // `build_argv` guarantees a non-empty argv.
     let mut cmd = Command::new(&argv[0]);
-    cmd.args(&argv[1..])
-        .current_dir(cwd)
+    push_args(&mut cmd, &argv[1..]);
+    cmd.current_dir(cwd)
         .stdout(Stdio::piped())
         .stderr(Stdio::piped())
         .stdin(if stdin_payload.is_some() {
@@ -193,6 +250,20 @@ pub fn run_command(
     }
 }
 
+// One fn with cfg blocks rather than two cfg'd fns: cargo-mutants mutates
+// the uncompiled twin too, and no test on a Linux gate can kill that mutant.
+fn push_args(cmd: &mut Command, args: &[String]) {
+    #[cfg(windows)]
+    {
+        use std::os::windows::process::CommandExt;
+        for arg in args {
+            cmd.raw_arg(quote_windows_arg(arg));
+        }
+    }
+    #[cfg(not(windows))]
+    cmd.args(args);
+}
+
 fn spawn_error(program: &str, source: std::io::Error, cwd: &Path) -> CommandError {
     // A missing cwd fails the child's chdir with `NotFound` too.
     if !searched_path(program, source.kind()) || !cwd.is_dir() {
@@ -244,6 +315,35 @@ pub(crate) fn build_argv(
     Ok(argv)
 }
 
+/// Quote `arg` for a Windows command line by the MS C-runtime rules, always
+/// wrapped in double quotes: an MSYS/Cygwin child globs, brace-expands and
+/// unescapes any unquoted word, while an MSVCRT child parses the quoted form
+/// back to `arg` exactly.
+#[cfg_attr(not(windows), allow(dead_code))]
+pub(crate) fn quote_windows_arg(arg: &str) -> String {
+    let mut out = String::with_capacity(arg.len() + 2);
+    out.push('"');
+    let mut backslashes = 0;
+    for ch in arg.chars() {
+        match ch {
+            '\\' => backslashes += 1,
+            '"' => {
+                out.extend(std::iter::repeat_n('\\', backslashes * 2 + 1));
+                out.push('"');
+                backslashes = 0;
+            }
+            _ => {
+                out.extend(std::iter::repeat_n('\\', backslashes));
+                out.push(ch);
+                backslashes = 0;
+            }
+        }
+    }
+    out.extend(std::iter::repeat_n('\\', backslashes * 2));
+    out.push('"');
+    out
+}
+
 /// Replace every `{name}` in `token` with its placeholder value in a single
 /// left-to-right pass. Injected values are never re-scanned, so an untrusted
 /// value containing `{…}` is inert. Unknown `{…}` sequences are left literal.
@@ -315,6 +415,117 @@ mod tests {
         build_argv(command, placeholders).expect("valid command")
     }
 
+    fn unchanged(path: &str) {
+        assert_eq!(non_verbatim(path), path);
+    }
+
+    #[test]
+    fn non_verbatim_strips_a_verbatim_drive_path() {
+        assert_eq!(
+            non_verbatim(r"\\?\C:\Users\runner\in_cwd.txt"),
+            r"C:\Users\runner\in_cwd.txt"
+        );
+        assert_eq!(non_verbatim(r"\\?\d:\x"), r"d:\x");
+        assert_eq!(non_verbatim(r"\\?\C:\my file.txt"), r"C:\my file.txt");
+    }
+
+    #[test]
+    fn non_verbatim_strips_a_verbatim_drive_root() {
+        assert_eq!(non_verbatim(r"\\?\C:\"), r"C:\");
+    }
+
+    #[test]
+    fn non_verbatim_rewrites_a_verbatim_unc_path() {
+        assert_eq!(
+            non_verbatim(r"\\?\UNC\server\share\dir\f.txt"),
+            r"\\server\share\dir\f.txt"
+        );
+        assert_eq!(non_verbatim(r"\\?\UNC\server\share"), r"\\server\share");
+    }
+
+    #[test]
+    fn non_verbatim_leaves_plain_paths_unchanged() {
+        unchanged(r"C:\Users\runner\f.txt");
+        unchanged(r"\\server\share\f.txt");
+        unchanged("/tmp/root/f.txt");
+        unchanged("relative/f.txt");
+        unchanged("");
+    }
+
+    #[test]
+    fn non_verbatim_leaves_verbatim_forms_without_a_drive_or_unc_unchanged() {
+        unchanged(r"\\?\GLOBALROOT\Device\HarddiskVolume1\f.txt");
+        unchanged(r"\\?\Volume{0b1c2d3e-0000-0000-0000-100000000000}\f.txt");
+        unchanged(r"\\?\C:");
+        unchanged(r"\\?\C:x");
+        unchanged(r"\\?\1:\x");
+        unchanged(r"\\?\");
+    }
+
+    #[test]
+    fn non_verbatim_leaves_an_incomplete_unc_unchanged() {
+        unchanged(r"\\?\UNC\");
+        unchanged(r"\\?\UNC\server");
+        unchanged(r"\\?\UNC\server\");
+    }
+
+    #[test]
+    fn non_verbatim_leaves_components_win32_would_reinterpret_unchanged() {
+        unchanged(r"\\?\C:\a\..\b");
+        unchanged(r"\\?\C:\a\.\b");
+        unchanged(r"\\?\C:\a\\b");
+        unchanged(r"\\?\C:\a\");
+        unchanged(r"\\?\C:\trailing.");
+        unchanged(r"\\?\C:\trailing ");
+        unchanged(r"\\?\C:\a/b");
+        unchanged(r"\\?\C:\a?b");
+        unchanged(r"\\?\C:\a*b");
+        unchanged(r"\\?\C:\a:b");
+        unchanged(r#"\\?\C:\a"b"#);
+        unchanged(r"\\?\C:\a<b");
+        unchanged(r"\\?\C:\a>b");
+        unchanged(r"\\?\C:\a|b");
+        unchanged("\\\\?\\C:\\a\u{1}b");
+        unchanged(r"\\?\UNC\server\share\..\x");
+    }
+
+    #[test]
+    fn non_verbatim_leaves_reserved_device_names_unchanged() {
+        for name in [
+            "CON", "con", "PRN", "AUX", "NUL", "nul.txt", "NUL .txt", "COM1", "COM9", "LPT1",
+            "lpt9.log",
+        ] {
+            unchanged(&format!(r"\\?\C:\dir\{name}"));
+        }
+    }
+
+    #[test]
+    fn non_verbatim_strips_names_that_only_resemble_device_names() {
+        for name in [
+            "CONSOLE", "NULL.txt", "COM0", "COM10", "LPT", "xCON", "AUXa",
+        ] {
+            assert_eq!(
+                non_verbatim(&format!(r"\\?\C:\dir\{name}")),
+                format!(r"C:\dir\{name}")
+            );
+        }
+    }
+
+    #[test]
+    fn non_verbatim_strips_up_to_max_path_and_no_further() {
+        let fits = format!(r"C:\{}", "a".repeat(256));
+        assert_eq!(fits.encode_utf16().count(), 259);
+        assert_eq!(non_verbatim(&format!(r"\\?\{fits}")), fits);
+        unchanged(&format!(r"\\?\C:\{}", "a".repeat(257)));
+    }
+
+    #[test]
+    fn path_placeholder_carries_the_non_verbatim_value() {
+        let placeholder = Placeholder::path("path", r"\\?\C:\a\f.txt");
+        assert_eq!(placeholder.name, "path");
+        assert_eq!(placeholder.value, r"C:\a\f.txt");
+    }
+
     #[test]
     fn splits_on_whitespace_without_placeholders() {
         assert_eq!(argv("echo hello world", &[]), ["echo", "hello", "world"]);
@@ -402,6 +613,47 @@ mod tests {
         assert_eq!(argv("run", &[Placeholder::new("path", "/tmp/x")]), ["run"]);
     }
 
+    #[test]
+    fn windows_quoting_wraps_a_plain_arg_in_quotes() {
+        assert_eq!(quote_windows_arg("hello"), r#""hello""#);
+    }
+
+    #[test]
+    fn windows_quoting_keeps_an_empty_arg_as_an_empty_quoted_word() {
+        assert_eq!(quote_windows_arg(""), r#""""#);
+    }
+
+    #[test]
+    fn windows_quoting_quotes_glob_and_brace_characters() {
+        assert_eq!(quote_windows_arg("[{}]"), r#""[{}]""#);
+        assert_eq!(quote_windows_arg("a?b*c"), r#""a?b*c""#);
+    }
+
+    #[test]
+    fn windows_quoting_leaves_backslashes_not_before_a_quote_alone() {
+        assert_eq!(
+            quote_windows_arg(r"\\?\C:\Users\x.txt"),
+            r#""\\?\C:\Users\x.txt""#
+        );
+    }
+
+    #[test]
+    fn windows_quoting_doubles_trailing_backslashes_before_the_closing_quote() {
+        assert_eq!(quote_windows_arg(r"C:\dir\"), r#""C:\dir\\""#);
+        assert_eq!(quote_windows_arg(r"a\\"), r#""a\\\\""#);
+    }
+
+    #[test]
+    fn windows_quoting_escapes_embedded_quotes() {
+        assert_eq!(quote_windows_arg(r#"[{"n":1}]"#), r#""[{\"n\":1}]""#);
+    }
+
+    #[test]
+    fn windows_quoting_doubles_backslashes_before_an_embedded_quote() {
+        assert_eq!(quote_windows_arg(r#"a\"b"#), r#""a\\\"b""#);
+        assert_eq!(quote_windows_arg(r#"a\\"b"#), r#""a\\\\\"b""#);
+    }
+
     #[test]
     fn extract_payload_takes_the_last_non_empty_line() {
         assert_eq!(

{dirsql-0.4.58 → dirsql-0.4.60}/packages/rust/src/db.rs

@@ -655,7 +655,7 @@ impl Db {
     /// Every distinct `(table_name, file_path)` whose file sits beneath the
     /// directory `dir`, ordered by table then path.
     pub fn files_under(&self, dir: &str) -> Result<Vec<(String, String)>> {
-        let prefix = format!("{dir}{}", std::path::MAIN_SEPARATOR);
+        let prefix = format!("{dir}/");
         let mut stmt = self.conn.prepare(
             "SELECT DISTINCT table_name, file_path FROM _dirsql_internal_rows \
              WHERE substr(file_path, 1, length(?1)) = ?1 \

{dirsql-0.4.58 → dirsql-0.4.60}/packages/rust/src/extension_resolution.rs

@@ -512,7 +512,11 @@ mod tests {
         );
         assert_eq!(
             err.to_string(),
-            "multiple loadable extension files found in package 'vec': /pkg/a.so, /pkg/z.so; disambiguate with a literal path"
+            format!(
+                "multiple loadable extension files found in package 'vec': {}, {}; disambiguate with a literal path",
+                dir.join("a.so").display(),
+                dir.join("z.so").display()
+            )
         );
     }
 }

{dirsql-0.4.58 → dirsql-0.4.60}/packages/rust/src/lib.rs

@@ -571,7 +571,7 @@ impl DirSQL {
         // unspecified. An `on_file` failure produces an error event for that
         // table only; the other matching tables still process the event.
         let matches = self.inner.matcher.match_all(&rel_path_buf);
-        let rel_path = rel_path_buf.to_string_lossy().to_string();
+        let rel_path = scanner::to_slash(&rel_path_buf);
 
         let mut events = Vec::new();
         for m in matches {
@@ -625,11 +625,7 @@ impl DirSQL {
         };
         let mut events = Vec::new();
         for (path, table) in self.inner.fs.scan_subtree(base, dir, &self.inner.matcher) {
-            let rel_path = path
-                .strip_prefix(base)
-                .unwrap_or(&path)
-                .to_string_lossy()
-                .to_string();
+            let rel_path = scanner::to_slash(path.strip_prefix(base).unwrap_or(&path));
             events.extend(self.handle_upsert(&table, &path, &rel_path));
         }
         events
@@ -1836,10 +1832,7 @@ fn run_channel_loop(db: DirSQL, tx: UnboundedSender<RowEvent>) {
 }
 
 fn relative_path(root: &Path, path: &Path) -> String {
-    path.strip_prefix(root)
-        .unwrap_or(path)
-        .to_string_lossy()
-        .to_string()
+    scanner::to_slash(path.strip_prefix(root).unwrap_or(path))
 }
 
 /// Build [`Table`] objects from a parsed config.
@@ -1945,8 +1938,8 @@ fn run_on_file(
     root: &Path,
 ) -> std::result::Result<Vec<Row>, BoxError> {
     let placeholders = [
-        Placeholder::new("path", abs_path),
-        Placeholder::new("root", root.to_string_lossy().into_owned()),
+        Placeholder::path("path", abs_path),
+        Placeholder::path("root", &root.to_string_lossy()),
     ];
 
     // Errors travel to the caller rather than being logged and flattened to an
@@ -2943,7 +2936,12 @@ mod internal_tests {
     /// so `notify` never sees `.`.
     #[test]
     fn relative_root_canonicalizes_watch_root_only() {
-        let fake = FakeFs::default().with_canonical_root(".", "/ws/canonical");
+        let canonical = if cfg!(windows) {
+            r"C:\ws\canonical"
+        } else {
+            "/ws/canonical"
+        };
+        let fake = FakeFs::default().with_canonical_root(".", canonical);
         let db = DirSQL::with_ignore_and_fs(
             ".",
             vec![Table::new(
@@ -2963,7 +2961,7 @@ mod internal_tests {
             "watch_root must be absolute, got {:?}",
             db.inner.watch_root
         );
-        assert_eq!(db.inner.watch_root, PathBuf::from("/ws/canonical"));
+        assert_eq!(db.inner.watch_root, PathBuf::from(canonical));
     }
 
     /// With an absolute root, `process_file_event` strips the `watch_root`
@@ -4346,15 +4344,13 @@ mod internal_tests {
     }
 
     /// `{abspath}` is not in the substitution table: it is left literal like any
-    /// unknown `{…}`, so `printf` receives the string `{abspath}` verbatim. The
-    /// template references `{path}` so that arg is the real path (and no path is
-    /// appended), isolating the `{abspath}` behavior in the `q` column.
+    /// unknown `{…}`, so `printf` receives the string `{abspath}` verbatim.
     #[test]
     fn run_on_file_does_not_substitute_abspath() {
         let dir = TempDir::new().unwrap();
         let abs = dir.path().join("f.txt");
         let rows = run_on_file(
-            r#"printf '[{"p":"%s","q":"%s"}]' {path} {abspath}"#,
+            r#"printf '[{"q":"%s"}]' {abspath}"#,
             &abs.to_string_lossy(),
             dir.path(),
             dir.path(),
@@ -4365,25 +4361,39 @@ mod internal_tests {
     }
 
     /// `{path}` interpolates the matched file's **absolute** path (not a
-    /// root-relative one). The command echoes its `{path}` argument back as a
-    /// row value, and we assert it is byte-for-byte the absolute path even when
-    /// the file sits directly under `root` (the case the old `strip_prefix`
-    /// would have shortened to a bare relative path).
+    /// root-relative one), byte-for-byte, even when the file sits directly
+    /// under `root`. The command writes its argument to a side file rather than
+    /// into the JSON payload, where a Windows path's `\` would need escaping.
     #[test]
     fn run_on_file_passes_absolute_path_for_path_placeholder() {
         let dir = TempDir::new().unwrap();
         let abs = dir.path().join("f.txt");
-        let rows = run_on_file(
-            r#"sh -c "printf '[{\"p\":\"%s\"}]' \"$1\"" sh {path}"#,
+        run_on_file(
+            r#"sh -c 'printf %s "$1" > seen; echo "[]"' sh {path}"#,
             &abs.to_string_lossy(),
             dir.path(),
             dir.path(),
         )
         .expect("a well-formed payload parses");
-        assert_eq!(rows.len(), 1);
         assert_eq!(
-            rows[0]["p"],
-            Value::Text(abs.to_string_lossy().into_owned())
+            std::fs::read_to_string(dir.path().join("seen")).unwrap(),
+            abs.to_string_lossy()
+        );
+    }
+
+    #[test]
+    fn run_on_file_hands_the_hook_non_verbatim_path_and_root() {
+        let dir = TempDir::new().unwrap();
+        run_on_file(
+            r#"sh -c 'printf "%s|%s" "$1" "$2" > seen; echo "[]"' sh {path} {root}"#,
+            r"\\?\C:\r\f.txt",
+            dir.path(),
+            Path::new(r"\\?\D:\r"),
+        )
+        .expect("a well-formed payload parses");
+        assert_eq!(
+            std::fs::read_to_string(dir.path().join("seen")).unwrap(),
+            r"C:\r\f.txt|D:\r"
         );
     }
 

{dirsql-0.4.58 → dirsql-0.4.60}/packages/rust/src/parsed_vtab.rs

@@ -36,7 +36,7 @@ use crate::matcher::TableMatcher;
 use crate::parsed_cache::{self, CachedParse, Entry, RowCache, SqliteRowCache};
 use crate::path_table;
 use crate::persist::{FileStat, hash_file, now_ns};
-use crate::scanner::scan_glob;
+use crate::scanner::{scan_glob, to_slash};
 use crate::vtab_scaffold::{self, TableSource};
 
 /// SQL module name a parsed path-table is created with.
@@ -161,7 +161,7 @@ fn collect_rows_cached(
 
     let mut seen: Vec<(String, Parsed)> = Vec::with_capacity(rel_paths.len());
     for rel_path in rel_paths {
-        let key = rel_path.to_string_lossy().into_owned();
+        let key = to_slash(rel_path);
         let Some(live) = fs.stat(rel_path) else {
             // The file vanished between the scan and the stat. Nothing to
             // parse and nothing to cache; the next run decides afresh.
@@ -268,7 +268,7 @@ impl ParsedFs for RootedFs<'_> {
 fn command_skip_message(rel_path: &Path, error: &str) -> String {
     format!(
         "dirsql: skipping `{}`: on-file command failed: {error}",
-        rel_path.display()
+        to_slash(rel_path)
     )
 }
 
@@ -276,7 +276,7 @@ fn command_skip_message(rel_path: &Path, error: &str) -> String {
 fn parse_skip_message(rel_path: &Path, message: &str) -> String {
     format!(
         "dirsql: skipping `{}`: on-file output was not a JSON array of rows: {message}",
-        rel_path.display()
+        to_slash(rel_path)
     )
 }
 
@@ -292,8 +292,8 @@ fn no_rows_message(pattern: &str) -> String {
 fn run_parser(command: &str, root: &Path, rel_path: &Path) -> std::result::Result<String, String> {
     let abs_path = root.join(rel_path);
     let placeholders = [
-        Placeholder::new("path", abs_path.to_string_lossy().into_owned()),
-        Placeholder::new("root", root.to_string_lossy().into_owned()),
+        Placeholder::path("path", &abs_path.to_string_lossy()),
+        Placeholder::path("root", &root.to_string_lossy()),
     ];
 
     run_command(command, &placeholders, root, None)
@@ -660,9 +660,12 @@ mod tests {
 
     #[test]
     fn run_parser_substitutes_the_absolute_path_and_the_root() {
-        let payload =
-            run_parser("echo {path} {root}", Path::new("/tmp"), Path::new("a.json")).unwrap();
-        assert_eq!(payload, "/tmp/a.json /tmp");
+        let root = std::env::temp_dir();
+        let payload = run_parser("echo {path} {root}", &root, Path::new("a.json")).unwrap();
+        assert_eq!(
+            payload,
+            format!("{} {}", root.join("a.json").display(), root.display())
+        );
     }
 
     #[test]

{dirsql-0.4.58 → dirsql-0.4.60}/packages/rust/src/scanner.rs

@@ -10,6 +10,19 @@ use walkdir::WalkDir;
 /// whether persistence is enabled.
 pub const RESERVED_DIR: &str = ".dirsql";
 
+/// A root-relative path as dirsql stores and reports it: `/`-separated on
+/// every platform, so globs, `file_path` keys and `path` columns agree.
+pub(crate) fn to_slash(path: &Path) -> String {
+    with_slashes(&path.to_string_lossy(), std::path::MAIN_SEPARATOR)
+}
+
+fn with_slashes(path: &str, native: char) -> String {
+    if native == '/' {
+        return path.to_owned();
+    }
+    path.replace(native, "/")
+}
+
 /// Walk a directory tree and return all file paths paired with their matching table name.
 /// Ignored paths and directories are skipped. Only files (not directories) are returned.
 ///
@@ -354,6 +367,29 @@ mod tests {
         assert!(!is_glob_match(&set, Path::new("a.md")));
     }
 
+    #[test]
+    fn with_slashes_rewrites_a_backslash_native_separator() {
+        assert_eq!(
+            with_slashes(r"moved\one\mid.txt", '\\'),
+            "moved/one/mid.txt"
+        );
+    }
+
+    #[test]
+    fn with_slashes_keeps_a_mixed_path_slash_separated() {
+        assert_eq!(with_slashes(r"a/b\c.txt", '\\'), "a/b/c.txt");
+    }
+
+    #[test]
+    fn with_slashes_leaves_a_backslash_in_a_unix_file_name() {
+        assert_eq!(with_slashes(r"dir/a\b.txt", '/'), r"dir/a\b.txt");
+    }
+
+    #[test]
+    fn to_slash_keeps_a_native_unix_path() {
+        assert_eq!(to_slash(Path::new("docs/nested/a.md")), "docs/nested/a.md");
+    }
+
     #[test]
     fn compile_glob_rejects_an_invalid_pattern() {
         assert!(compile_glob("[").is_err());