dirsql 0.4.19__tar.gz → 0.4.20__tar.gz

{dirsql-0.4.19 → dirsql-0.4.20}/Cargo.lock

@@ -499,7 +499,7 @@ dependencies = [
 
 [[package]]
 name = "dirsql-py-ext"
-version = "0.4.19"
+version = "0.4.20"
 dependencies = [
  "dirsql",
  "pyo3",

{dirsql-0.4.19 → dirsql-0.4.20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dirsql
-Version: 0.4.19
+Version: 0.4.20
 Requires-Dist: tomli>=2 ; python_full_version < '3.11'
 Requires-Dist: bin-shim>=0.1
 Summary: Ephemeral SQL index over a local directory

{dirsql-0.4.19 → dirsql-0.4.20}/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.19"
+version = "0.4.20"
 # 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.20/packages/python/e2e-attestations/claude-827-unquote-doubled-quotes.json

@@ -0,0 +1,7 @@
+{
+  "command": "uv run python -m pytest tests/e2e/ -x -q",
+  "ran_at": 1786553201,
+  "exit_code": 0,
+  "commit": "859a062ab1c795d43af357130dc1587ef9e77db0",
+  "branch": "claude/827-unquote-doubled-quotes"
+}

dirsql-0.4.20/packages/rust/changelog.d/2026-08-12-unquote-inverts-quote-literal.md

@@ -0,0 +1,3 @@
+**Fixed**
+
+- **A path-table argument containing a single quote now reaches the module as written.** `dirsql --on-file "sh -c 'jq . \"$1\"' sh {path}"` — `sh -c '…'` being the documented way to ask for a shell — arrived at the parser as `sh -c ''…''` and ran a different script. Minting a path-table writes its arguments as SQL literals, where an embedded quote is escaped by doubling; the modules stripped the surrounding quotes without undoing the doubling. The same corruption applied to any glob or ignore pattern carrying a quote. `quote_literal`, `quote_identifier` and `unquote` now live together in one module with a round-trip property test, so the encoder and decoder cannot drift apart again. (#827)

{dirsql-0.4.19 → dirsql-0.4.20}/packages/rust/src/db.rs

@@ -6,6 +6,7 @@ use thiserror::Error;
 use crate::parsed_vtab;
 use crate::path_table::{self, PathTable, Resolution};
 use crate::scanner;
+use crate::sql_literal::{quote_identifier, quote_literal};
 use crate::vtab;
 
 /// The user's home directory, if the platform reports one. Injected here so
@@ -94,15 +95,6 @@ fn no_home_path_table(name: &str) -> String {
 }
 
 /// Wrap `s` as a SQL string literal.
-fn quote_literal(s: &str) -> String {
-    format!("'{}'", s.replace('\'', "''"))
-}
-
-/// Wrap `s` as a double-quoted SQL identifier.
-fn quote_identifier(s: &str) -> String {
-    format!("\"{}\"", s.replace('"', "\"\""))
-}
-
 /// The DDL that mints a path-table.
 ///
 /// It lands in `temp`, which is per-connection and never written to the
@@ -2174,16 +2166,6 @@ mod tests {
         );
     }
 
-    #[test]
-    fn quote_literal_doubles_embedded_quotes() {
-        assert_eq!(quote_literal("it's"), "'it''s'");
-    }
-
-    #[test]
-    fn quote_identifier_doubles_embedded_quotes() {
-        assert_eq!(quote_identifier("a\"b"), "\"a\"\"b\"");
-    }
-
     fn docs_path_table() -> PathTable {
         PathTable {
             root: PathBuf::from("/root"),

{dirsql-0.4.19 → dirsql-0.4.20}/packages/rust/src/lib.rs

@@ -32,6 +32,8 @@ pub mod persist;
 #[doc(hidden)]
 pub mod scanner;
 #[doc(hidden)]
+pub mod sql_literal;
+#[doc(hidden)]
 pub mod vtab;
 #[doc(hidden)]
 pub mod watcher;

{dirsql-0.4.19 → dirsql-0.4.20}/packages/rust/src/parsed_vtab.rs

@@ -39,6 +39,7 @@ use crate::parsed_cache::{self, CachedParse, Entry, RowCache, SqliteRowCache};
 use crate::path_table;
 use crate::persist::{FileStat, hash_file, now_ns};
 use crate::scanner::{self, scan_glob};
+use crate::sql_literal::unquote;
 
 /// SQL module name a parsed path-table is created with.
 pub const MODULE_NAME: &str = "dirsql_parsed";
@@ -49,18 +50,6 @@ pub fn load_module(conn: &Connection) -> Result<()> {
     conn.create_module(MODULE_NAME, read_only_module::<ParsedTab>(), aux)
 }
 
-/// Strip one layer of SQL string quoting from a `CREATE VIRTUAL TABLE`
-/// argument. SQLite hands module arguments through verbatim, quotes included.
-fn unquote(arg: &str) -> &str {
-    let trimmed = arg.trim();
-    for quote in ['\'', '"'] {
-        if trimmed.len() >= 2 && trimmed.starts_with(quote) && trimmed.ends_with(quote) {
-            return &trimmed[1..trimmed.len() - 1];
-        }
-    }
-    trimmed
-}
-
 /// Number of module arguments that are not ignore patterns.
 const FIXED_ARGS: usize = 5;
 
@@ -485,36 +474,6 @@ mod tests {
         assert_eq!(MODULE_NAME, "dirsql_parsed");
     }
 
-    #[test]
-    fn unquote_strips_single_quotes() {
-        assert_eq!(unquote("'./docs'"), "./docs");
-    }
-
-    #[test]
-    fn unquote_strips_double_quotes() {
-        assert_eq!(unquote("\"./docs\""), "./docs");
-    }
-
-    #[test]
-    fn unquote_trims_surrounding_whitespace() {
-        assert_eq!(unquote("  './docs'  "), "./docs");
-    }
-
-    #[test]
-    fn unquote_leaves_unquoted_arguments_alone() {
-        assert_eq!(unquote("./docs"), "./docs");
-    }
-
-    #[test]
-    fn unquote_leaves_a_lone_quote_alone() {
-        assert_eq!(unquote("'"), "'");
-    }
-
-    #[test]
-    fn unquote_leaves_mismatched_quotes_alone() {
-        assert_eq!(unquote("'./docs\""), "'./docs\"");
-    }
-
     /// The three fixed arguments SQLite prepends before the module's own.
     fn args_with<'a>(user: &[&'a [u8]]) -> Vec<&'a [u8]> {
         let mut all: Vec<&'a [u8]> = vec![

dirsql-0.4.20/packages/rust/src/sql_literal.rs

@@ -0,0 +1,127 @@
+//! The one encoding a path-table's arguments travel through.
+//!
+//! `dirsql` mints a path-table by writing a `CREATE VIRTUAL TABLE` statement
+//! whose module arguments are SQL literals ([`quote_literal`]), and SQLite
+//! hands those arguments to the module verbatim, quotes included, for
+//! [`unquote`] to decode. The two are inverses, and they live together so they
+//! stay that way: a value that survives one but not the other reaches the
+//! module as something the user never wrote.
+
+use std::borrow::Cow;
+
+/// Wrap `s` as a single-quoted SQL string literal.
+pub fn quote_literal(s: &str) -> String {
+    format!("'{}'", s.replace('\'', "''"))
+}
+
+/// Wrap `s` as a double-quoted SQL identifier.
+pub fn quote_identifier(s: &str) -> String {
+    format!("\"{}\"", s.replace('"', "\"\""))
+}
+
+/// Decode one quoted `CREATE VIRTUAL TABLE` argument: strip the surrounding
+/// quotes and collapse the doubling that escaped them. Borrowed when there is
+/// nothing to collapse, which is the ordinary case.
+pub fn unquote(arg: &str) -> Cow<'_, str> {
+    let trimmed = arg.trim();
+    for quote in ['\'', '"'] {
+        if trimmed.len() >= 2 && trimmed.starts_with(quote) && trimmed.ends_with(quote) {
+            let inner = &trimmed[1..trimmed.len() - 1];
+            let doubled = [quote, quote].iter().collect::<String>();
+            return if inner.contains(&doubled) {
+                Cow::Owned(inner.replace(&doubled, &quote.to_string()))
+            } else {
+                Cow::Borrowed(inner)
+            };
+        }
+    }
+    Cow::Borrowed(trimmed)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn quote_literal_doubles_embedded_quotes() {
+        assert_eq!(quote_literal("it's"), "'it''s'");
+    }
+
+    #[test]
+    fn quote_identifier_doubles_embedded_quotes() {
+        assert_eq!(quote_identifier("a\"b"), "\"a\"\"b\"");
+    }
+
+    #[test]
+    fn unquote_strips_single_quotes() {
+        assert_eq!(unquote("'./docs'"), "./docs");
+    }
+
+    #[test]
+    fn unquote_strips_double_quotes() {
+        assert_eq!(unquote("\"./docs\""), "./docs");
+    }
+
+    #[test]
+    fn unquote_trims_surrounding_whitespace() {
+        assert_eq!(unquote("  './docs'  "), "./docs");
+    }
+
+    #[test]
+    fn unquote_leaves_unquoted_arguments_alone() {
+        assert_eq!(unquote("./docs"), "./docs");
+    }
+
+    #[test]
+    fn unquote_leaves_a_lone_quote_alone() {
+        assert_eq!(unquote("'"), "'");
+    }
+
+    #[test]
+    fn unquote_leaves_mismatched_quotes_alone() {
+        assert_eq!(unquote("'./docs\""), "'./docs\"");
+    }
+
+    #[test]
+    fn unquote_collapses_the_doubling_that_escaped_a_quote() {
+        assert_eq!(unquote("'sh -c ''echo hi'''"), "sh -c 'echo hi'");
+    }
+
+    #[test]
+    fn unquote_collapses_only_the_quote_character_it_stripped() {
+        // A double-quote inside a single-quoted literal was never doubled, so
+        // collapsing it would corrupt the value in the other direction.
+        assert_eq!(unquote("'say \"\"hi\"\"'"), "say \"\"hi\"\"");
+    }
+
+    #[test]
+    fn unquote_borrows_when_there_is_nothing_to_collapse() {
+        assert!(matches!(unquote("'plain'"), Cow::Borrowed("plain")));
+    }
+
+    #[test]
+    fn unquote_inverts_quote_literal() {
+        for value in [
+            "plain",
+            "it's",
+            "sh -c 'echo hi'",
+            "''",
+            "a''b",
+            "say \"hi\"",
+            "",
+        ] {
+            assert_eq!(
+                unquote(&quote_literal(value)),
+                value,
+                "round trip must be lossless for {value:?}"
+            );
+        }
+    }
+
+    #[test]
+    fn unquote_inverts_quote_identifier() {
+        for value in ["plain", "a\"b", "./docs/*.md"] {
+            assert_eq!(unquote(&quote_identifier(value)), value);
+        }
+    }
+}

{dirsql-0.4.19 → dirsql-0.4.20}/packages/rust/src/vtab.rs

@@ -13,6 +13,7 @@ use crate::compute_stat_virtuals;
 use crate::matcher::TableMatcher;
 use crate::path_table;
 use crate::scanner::{self, scan_glob};
+use crate::sql_literal::unquote;
 use crate::{Row, Value};
 
 /// SQL module name a path-table is created with:
@@ -58,18 +59,6 @@ fn compile_glob(pattern: &str) -> Result<GlobSet> {
     scanner::compile_glob(pattern).map_err(|e| Error::ModuleError(e.to_string()))
 }
 
-/// Strip one layer of SQL string quoting from a `CREATE VIRTUAL TABLE`
-/// argument. SQLite hands module arguments through verbatim, quotes included.
-fn unquote(arg: &str) -> &str {
-    let trimmed = arg.trim();
-    for quote in ['\'', '"'] {
-        if trimmed.len() >= 2 && trimmed.starts_with(quote) && trimmed.ends_with(quote) {
-            return &trimmed[1..trimmed.len() - 1];
-        }
-    }
-    trimmed
-}
-
 /// Read `path` as text, yielding `None` when it is unreadable or not valid
 /// UTF-8. A file that cannot be read is a NULL cell, never a failed row: the
 /// filesystem is allowed to be messy and a query over it should still return.
@@ -376,36 +365,6 @@ mod tests {
         assert_eq!(MODULE_NAME, "dirsql_path");
     }
 
-    #[test]
-    fn unquote_strips_single_quotes() {
-        assert_eq!(unquote("'./docs'"), "./docs");
-    }
-
-    #[test]
-    fn unquote_strips_double_quotes() {
-        assert_eq!(unquote("\"./docs\""), "./docs");
-    }
-
-    #[test]
-    fn unquote_trims_surrounding_whitespace() {
-        assert_eq!(unquote("  './docs'  "), "./docs");
-    }
-
-    #[test]
-    fn unquote_leaves_unquoted_arguments_alone() {
-        assert_eq!(unquote("./docs"), "./docs");
-    }
-
-    #[test]
-    fn unquote_leaves_a_lone_quote_alone() {
-        assert_eq!(unquote("'"), "'");
-    }
-
-    #[test]
-    fn unquote_leaves_mismatched_quotes_alone() {
-        assert_eq!(unquote("'./docs\""), "'./docs\"");
-    }
-
     #[test]
     fn compile_glob_accepts_a_valid_pattern() {
         assert!(compile_glob("**/*.md").is_ok());