dirsql 0.3.24__tar.gz → 0.3.25__tar.gz

{dirsql-0.3.24 → dirsql-0.3.25}/Cargo.lock

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

{dirsql-0.3.24 → dirsql-0.3.25}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dirsql
-Version: 0.3.24
+Version: 0.3.25
 Requires-Dist: pytest>=8 ; extra == 'dev'
 Requires-Dist: pytest-describe>=2 ; extra == 'dev'
 Requires-Dist: pytest-asyncio>=0.23 ; extra == 'dev'

{dirsql-0.3.24 → dirsql-0.3.25}/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.3.24"
+version = "0.3.25"
 edition.workspace = true
 publish = false
 readme = "README.md"

{dirsql-0.3.24 → dirsql-0.3.25}/packages/rust/src/config.rs

@@ -256,23 +256,6 @@ glob = "*.json"
         assert!(config.ignore.is_empty());
     }
 
-    #[test]
-    fn load_config_from_file() {
-        let dir = tempfile::tempdir().unwrap();
-        let path = dir.path().join(".dirsql.toml");
-        std::fs::write(
-            &path,
-            r#"
-[[table]]
-ddl = "CREATE TABLE t (_path TEXT)"
-glob = "*.csv"
-"#,
-        )
-        .unwrap();
-        let config = load_config(&path).unwrap();
-        assert_eq!(config.tables.len(), 1);
-    }
-
     #[test]
     fn load_config_missing_file_returns_io_error() {
         let err = load_config(Path::new("/nonexistent/.dirsql.toml")).unwrap_err();

dirsql-0.3.25/packages/rust/src/scanner.rs

@@ -0,0 +1,83 @@
+use crate::matcher::TableMatcher;
+use std::path::{Path, PathBuf};
+use walkdir::WalkDir;
+
+/// Top-level directory name reserved for `dirsql`'s own metadata (e.g. the
+/// persistent cache database). Always excluded from the scan, regardless of
+/// whether persistence is enabled.
+pub const RESERVED_DIR: &str = ".dirsql";
+
+/// 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.
+///
+/// The top-level `.dirsql/` directory is unconditionally excluded.
+pub fn scan_directory(root: &Path, matcher: &TableMatcher) -> Vec<(PathBuf, String)> {
+    let mut results = Vec::new();
+
+    let walker = WalkDir::new(root).into_iter().filter_entry(|entry| {
+        // Skip the reserved `.dirsql/` directory at the top level.
+        !is_reserved_dir(entry.depth(), entry.file_type().is_dir(), entry.file_name())
+    });
+
+    for entry in walker.filter_map(|e| e.ok()) {
+        let path = entry.path();
+
+        // Match against relative path so globs like "comments/**/*.jsonl" work
+        // regardless of the absolute root directory.
+        let rel_path = path.strip_prefix(root).unwrap_or(path);
+
+        if matcher.is_ignored(rel_path) {
+            continue;
+        }
+
+        if !entry.file_type().is_file() {
+            continue;
+        }
+
+        if let Some(table_name) = matcher.match_file(rel_path) {
+            results.push((path.to_path_buf(), table_name.to_string()));
+        }
+    }
+
+    results
+}
+
+/// True for the reserved top-level `.dirsql/` directory (`depth == 1`), which
+/// the scan unconditionally excludes. Factored out as a pure predicate over the
+/// facts `WalkDir` exposes so it can be unit-tested without walking a real tree
+/// -- the directory-walk behavior itself is covered by `tests/scanner.rs`.
+fn is_reserved_dir(depth: usize, is_dir: bool, file_name: &std::ffi::OsStr) -> bool {
+    depth == 1 && is_dir && file_name == RESERVED_DIR
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::ffi::OsStr;
+
+    // The directory-walk behavior of `scan_directory` (real temp trees, real
+    // files) is exercised by `tests/scanner.rs` -- those are integration tests
+    // and stay out of this inline unit module, which the `unit lint` isolation
+    // rule keeps free of effectful std. What remains here is the pure
+    // reserved-dir predicate the walker filters on.
+
+    #[test]
+    fn is_reserved_dir_matches_top_level_dirsql() {
+        assert!(is_reserved_dir(1, true, OsStr::new(RESERVED_DIR)));
+    }
+
+    #[test]
+    fn is_reserved_dir_rejects_nested_dirsql() {
+        // Only the *top-level* `.dirsql/` (depth 1) is reserved; a nested one
+        // (e.g. `sub/.dirsql/`) is an ordinary directory.
+        assert!(!is_reserved_dir(2, true, OsStr::new(RESERVED_DIR)));
+    }
+
+    #[test]
+    fn is_reserved_dir_rejects_files_and_other_names() {
+        // A file named `.dirsql` is not the reserved directory ...
+        assert!(!is_reserved_dir(1, false, OsStr::new(RESERVED_DIR)));
+        // ... and an ordinary top-level directory is not reserved.
+        assert!(!is_reserved_dir(1, true, OsStr::new("data")));
+    }
+}

dirsql-0.3.25/packages/rust/tests/config.rs

@@ -0,0 +1,26 @@
+//! Integration test for `load_config` reading a real `.dirsql.toml` off disk.
+//!
+//! The pure TOML-parsing tests (`load_config_str`) stay inline in `config.rs`;
+//! this exercises the thin file-reading wrapper, which needs a real file
+//! (effectful std), so per the `unit lint` isolation rule it belongs in the
+//! integration tier rather than the inline unit module.
+
+use dirsql::config::load_config;
+use tempfile::TempDir;
+
+#[test]
+fn load_config_from_file() {
+    let dir = TempDir::new().unwrap();
+    let path = dir.path().join(".dirsql.toml");
+    std::fs::write(
+        &path,
+        r#"
+[[table]]
+ddl = "CREATE TABLE t (_path TEXT)"
+glob = "*.csv"
+"#,
+    )
+    .unwrap();
+    let config = load_config(&path).unwrap();
+    assert_eq!(config.tables.len(), 1);
+}

dirsql-0.3.25/packages/rust/tests/scanner.rs

@@ -0,0 +1,97 @@
+//! Integration tests for `scan_directory`.
+//!
+//! These build real temp directory trees with real files and assert what the
+//! scanner returns end-to-end through its public API. They were moved out of
+//! `scanner.rs`'s inline `#[cfg(test)]` module so that module stays pure (the
+//! `testing-conventions` `unit lint` isolation rule forbids effectful std --
+//! `std::fs`, temp dirs -- in unit tests). The pure reserved-dir predicate
+//! test remains inline next to the function it covers.
+
+use std::fs;
+
+use dirsql::matcher::TableMatcher;
+use dirsql::scanner::scan_directory;
+use tempfile::TempDir;
+
+#[test]
+fn scan_finds_matching_files() {
+    let dir = TempDir::new().unwrap();
+    fs::write(dir.path().join("data.csv"), "a,b\n1,2").unwrap();
+    fs::write(dir.path().join("readme.md"), "# hi").unwrap();
+
+    let matcher = TableMatcher::new(&[("**/*.csv", "csv_table")], &[]).unwrap();
+    let results = scan_directory(dir.path(), &matcher);
+
+    assert_eq!(results.len(), 1);
+    assert!(results[0].0.ends_with("data.csv"));
+    assert_eq!(results[0].1, "csv_table");
+}
+
+#[test]
+fn scan_skips_ignored_files() {
+    let dir = TempDir::new().unwrap();
+    fs::write(dir.path().join("data.csv"), "a,b").unwrap();
+    fs::write(dir.path().join("data.tmp"), "junk").unwrap();
+
+    let matcher =
+        TableMatcher::new(&[("**/*.csv", "t"), ("**/*.tmp", "t2")], &["**/*.tmp"]).unwrap();
+    let results = scan_directory(dir.path(), &matcher);
+
+    assert_eq!(results.len(), 1);
+    assert!(results[0].0.ends_with("data.csv"));
+}
+
+#[test]
+fn scan_recurses_into_subdirectories() {
+    let dir = TempDir::new().unwrap();
+    let sub = dir.path().join("nested").join("deep");
+    fs::create_dir_all(&sub).unwrap();
+    fs::write(sub.join("events.jsonl"), "{}").unwrap();
+
+    let matcher = TableMatcher::new(&[("**/*.jsonl", "events")], &[]).unwrap();
+    let results = scan_directory(dir.path(), &matcher);
+
+    assert_eq!(results.len(), 1);
+    assert!(results[0].0.ends_with("events.jsonl"));
+    assert_eq!(results[0].1, "events");
+}
+
+#[test]
+fn scan_returns_empty_for_no_matches() {
+    let dir = TempDir::new().unwrap();
+    fs::write(dir.path().join("readme.md"), "# hi").unwrap();
+
+    let matcher = TableMatcher::new(&[("**/*.csv", "t")], &[]).unwrap();
+    let results = scan_directory(dir.path(), &matcher);
+
+    assert!(results.is_empty());
+}
+
+#[test]
+fn scan_skips_directories() {
+    let dir = TempDir::new().unwrap();
+    // Create a directory that matches the glob -- it should not appear in results
+    fs::create_dir(dir.path().join("data.csv")).unwrap();
+
+    let matcher = TableMatcher::new(&[("**/*.csv", "t")], &[]).unwrap();
+    let results = scan_directory(dir.path(), &matcher);
+
+    assert!(results.is_empty());
+}
+
+#[test]
+fn scan_excludes_top_level_dirsql_directory() {
+    let dir = TempDir::new().unwrap();
+    fs::write(dir.path().join("real.csv"), "a,b\n1,2").unwrap();
+
+    // Files inside the reserved `.dirsql/` directory (e.g. the cache db)
+    // must never be picked up by the scanner.
+    fs::create_dir(dir.path().join(".dirsql")).unwrap();
+    fs::write(dir.path().join(".dirsql").join("cache.csv"), "a,b\n1,2").unwrap();
+
+    let matcher = TableMatcher::new(&[("**/*.csv", "t")], &[]).unwrap();
+    let results = scan_directory(dir.path(), &matcher);
+
+    assert_eq!(results.len(), 1);
+    assert!(results[0].0.ends_with("real.csv"));
+}

dirsql-0.3.24/packages/rust/src/scanner.rs

@@ -1,136 +0,0 @@
-use crate::matcher::TableMatcher;
-use std::path::{Path, PathBuf};
-use walkdir::WalkDir;
-
-/// Top-level directory name reserved for `dirsql`'s own metadata (e.g. the
-/// persistent cache database). Always excluded from the scan, regardless of
-/// whether persistence is enabled.
-pub const RESERVED_DIR: &str = ".dirsql";
-
-/// 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.
-///
-/// The top-level `.dirsql/` directory is unconditionally excluded.
-pub fn scan_directory(root: &Path, matcher: &TableMatcher) -> Vec<(PathBuf, String)> {
-    let mut results = Vec::new();
-
-    let walker = WalkDir::new(root).into_iter().filter_entry(|entry| {
-        // Skip the reserved `.dirsql/` directory at the top level.
-        if entry.depth() == 1 && entry.file_type().is_dir() && entry.file_name() == RESERVED_DIR {
-            return false;
-        }
-        true
-    });
-
-    for entry in walker.filter_map(|e| e.ok()) {
-        let path = entry.path();
-
-        // Match against relative path so globs like "comments/**/*.jsonl" work
-        // regardless of the absolute root directory.
-        let rel_path = path.strip_prefix(root).unwrap_or(path);
-
-        if matcher.is_ignored(rel_path) {
-            continue;
-        }
-
-        if !entry.file_type().is_file() {
-            continue;
-        }
-
-        if let Some(table_name) = matcher.match_file(rel_path) {
-            results.push((path.to_path_buf(), table_name.to_string()));
-        }
-    }
-
-    results
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use std::fs;
-    use tempfile::TempDir;
-
-    #[test]
-    fn scan_finds_matching_files() {
-        let dir = TempDir::new().unwrap();
-        fs::write(dir.path().join("data.csv"), "a,b\n1,2").unwrap();
-        fs::write(dir.path().join("readme.md"), "# hi").unwrap();
-
-        let matcher = TableMatcher::new(&[("**/*.csv", "csv_table")], &[]).unwrap();
-        let results = scan_directory(dir.path(), &matcher);
-
-        assert_eq!(results.len(), 1);
-        assert!(results[0].0.ends_with("data.csv"));
-        assert_eq!(results[0].1, "csv_table");
-    }
-
-    #[test]
-    fn scan_skips_ignored_files() {
-        let dir = TempDir::new().unwrap();
-        fs::write(dir.path().join("data.csv"), "a,b").unwrap();
-        fs::write(dir.path().join("data.tmp"), "junk").unwrap();
-
-        let matcher =
-            TableMatcher::new(&[("**/*.csv", "t"), ("**/*.tmp", "t2")], &["**/*.tmp"]).unwrap();
-        let results = scan_directory(dir.path(), &matcher);
-
-        assert_eq!(results.len(), 1);
-        assert!(results[0].0.ends_with("data.csv"));
-    }
-
-    #[test]
-    fn scan_recurses_into_subdirectories() {
-        let dir = TempDir::new().unwrap();
-        let sub = dir.path().join("nested").join("deep");
-        fs::create_dir_all(&sub).unwrap();
-        fs::write(sub.join("events.jsonl"), "{}").unwrap();
-
-        let matcher = TableMatcher::new(&[("**/*.jsonl", "events")], &[]).unwrap();
-        let results = scan_directory(dir.path(), &matcher);
-
-        assert_eq!(results.len(), 1);
-        assert!(results[0].0.ends_with("events.jsonl"));
-        assert_eq!(results[0].1, "events");
-    }
-
-    #[test]
-    fn scan_returns_empty_for_no_matches() {
-        let dir = TempDir::new().unwrap();
-        fs::write(dir.path().join("readme.md"), "# hi").unwrap();
-
-        let matcher = TableMatcher::new(&[("**/*.csv", "t")], &[]).unwrap();
-        let results = scan_directory(dir.path(), &matcher);
-
-        assert!(results.is_empty());
-    }
-
-    #[test]
-    fn scan_skips_directories() {
-        let dir = TempDir::new().unwrap();
-        // Create a directory that matches the glob -- it should not appear in results
-        fs::create_dir(dir.path().join("data.csv")).unwrap();
-
-        let matcher = TableMatcher::new(&[("**/*.csv", "t")], &[]).unwrap();
-        let results = scan_directory(dir.path(), &matcher);
-
-        assert!(results.is_empty());
-    }
-
-    #[test]
-    fn scan_excludes_top_level_dirsql_directory() {
-        let dir = TempDir::new().unwrap();
-        fs::write(dir.path().join("real.csv"), "a,b\n1,2").unwrap();
-
-        // Files inside the reserved `.dirsql/` directory (e.g. the cache db)
-        // must never be picked up by the scanner.
-        fs::create_dir(dir.path().join(".dirsql")).unwrap();
-        fs::write(dir.path().join(".dirsql").join("cache.csv"), "a,b\n1,2").unwrap();
-
-        let matcher = TableMatcher::new(&[("**/*.csv", "t")], &[]).unwrap();
-        let results = scan_directory(dir.path(), &matcher);
-
-        assert_eq!(results.len(), 1);
-        assert!(results[0].0.ends_with("real.csv"));
-    }
-}