dirsql 0.3.17__tar.gz → 0.3.18__tar.gz

{dirsql-0.3.17 → dirsql-0.3.18}/Cargo.lock

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

{dirsql-0.3.17 → dirsql-0.3.18}/PKG-INFO

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

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

dirsql-0.3.18/packages/python/tests/integration/__fixtures__/dirsql.config.py

@@ -0,0 +1,29 @@
+"""A native Python config file for dirsql.
+
+When ``dirsql --config <path-to-this-file>`` runs, the Rust binary
+spawns ``dirsql interpret`` against this file. The helper loads the
+module, takes its module-level ``app``, and dispatches ``extract``
+callbacks over NDJSON.
+"""
+
+import json
+import os
+
+from dirsql import DirSQL, Table
+
+
+def _extract(path):
+    with open(path) as f:
+        return [json.load(f)]
+
+
+app = DirSQL(
+    root=os.path.join(os.path.dirname(__file__), "data"),
+    tables=[
+        Table(
+            ddl="CREATE TABLE papers (title TEXT)",
+            glob="**/meta.json",
+            extract=_extract,
+        )
+    ],
+)

dirsql-0.3.18/packages/python/tests/integration/__fixtures__/interpret/data/a/meta.json

@@ -0,0 +1 @@
+{"title": "Alpha"}

dirsql-0.3.18/packages/python/tests/integration/__fixtures__/interpret/data/b/meta.json

@@ -0,0 +1 @@
+{"title": "Beta"}

dirsql-0.3.18/packages/python/tests/integration/test_native_config.py

@@ -0,0 +1,100 @@
+"""CLI integration test for native Python config file support.
+
+Spawns the bundled Rust binary directly against the
+``__fixtures__/dirsql.config.py`` fixture and asserts the HTTP server
+serves the ``papers`` table. Bypasses the Python launcher because the
+architectural property under test ("the Rust binary dispatches
+non-TOML configs to ``dirsql interpret``") is the binary's job — the
+launcher is a transparent forwarder.
+
+The binary's `dirsql interpret <X>` subprocess resolves via PATH; in
+this dev/CI tree the pip-installed `dirsql` console script (entry
+point ``dirsql.cli.main:main``) is on PATH and handles the
+``interpret`` subcommand directly.
+"""
+
+import json
+import os
+import socket
+import subprocess
+import time
+import urllib.error
+import urllib.request
+
+FIXTURE_DIR = os.path.join(os.path.dirname(__file__), "__fixtures__")
+CONFIG_PATH = os.path.join(FIXTURE_DIR, "dirsql.config.py")
+
+# Workspace root → cargo's target dir. The CI workflow builds the
+# binary with `cargo build --release -p dirsql --features cli` before
+# running integration tests; locally, `cargo build --release` does the
+# same. Fall back to debug if release isn't present.
+_REPO_ROOT = os.path.abspath(
+    os.path.join(os.path.dirname(__file__), "..", "..", "..", "..")
+)
+_RELEASE = os.path.join(_REPO_ROOT, "target", "release", "dirsql")
+_DEBUG = os.path.join(_REPO_ROOT, "target", "debug", "dirsql")
+BINARY = _RELEASE if os.path.exists(_RELEASE) else _DEBUG
+
+
+def _free_port() -> int:
+    with socket.socket() as s:
+        s.bind(("", 0))
+        return s.getsockname()[1]
+
+
+def _wait_for_server(proc: subprocess.Popen, port: int, timeout: float = 5.0) -> bool:
+    """Return True once the server accepts a connection, False if the process
+    exits first or the timeout elapses."""
+    deadline = time.monotonic() + timeout
+    while time.monotonic() < deadline:
+        if proc.poll() is not None:
+            return False
+        try:
+            urllib.request.urlopen(f"http://localhost:{port}/query", timeout=0.5)
+            return True
+        except urllib.error.HTTPError:
+            return True  # any HTTP response means the server is up
+        except Exception:
+            time.sleep(0.05)
+    return False
+
+
+def _query(port: int, sql: str) -> list:
+    body = json.dumps({"sql": sql}).encode()
+    req = urllib.request.Request(
+        f"http://localhost:{port}/query",
+        data=body,
+        headers={"content-type": "application/json"},
+    )
+    with urllib.request.urlopen(req) as resp:
+        return json.loads(resp.read())
+
+
+def describe_cli_py_config():
+    def it_starts_an_http_server_serving_the_config_tables():
+        assert os.path.exists(BINARY), (
+            f"dirsql binary not built at {BINARY}; "
+            "run `cargo build --release -p dirsql --features cli` first"
+        )
+        port = _free_port()
+        proc = subprocess.Popen(
+            [
+                BINARY,
+                "--config",
+                CONFIG_PATH,
+                "--host",
+                "127.0.0.1",
+                "--port",
+                str(port),
+            ],
+            stderr=subprocess.PIPE,
+        )
+        try:
+            assert _wait_for_server(proc, port), (
+                "dirsql server did not start with --config .py"
+            )
+            rows = _query(port, "SELECT title FROM papers ORDER BY title")
+            assert rows == [{"title": "Alpha"}, {"title": "Beta"}]
+        finally:
+            proc.terminate()
+            proc.wait(timeout=5)

{dirsql-0.3.17 → dirsql-0.3.18}/packages/rust/src/bin/dirsql.rs

@@ -8,7 +8,12 @@ use std::path::{Path, PathBuf};
 use std::process::ExitCode;
 
 use clap::{Args, Parser, Subcommand};
-use dirsql::cli::{AppState, ServerConfig, init::InitOptions, serve_with_state};
+use dirsql::cli::{
+    AppState, ServerConfig,
+    init::InitOptions,
+    native_config::{InterpretHelper, build_dirsql},
+    serve_with_state,
+};
 use dirsql::{DirSQL, Row, Table};
 
 #[derive(Debug, Parser)]
@@ -152,12 +157,73 @@ fn load_state(cli: &Cli) -> AppState {
         }
     };
 
+    if is_native_config(&resolved) {
+        return load_native_state(&resolved);
+    }
+
     match DirSQL::from_config_path(&resolved) {
         Ok(db) => AppState::Ready(db),
         Err(err) => AppState::Unavailable(format!("failed to load config: {err}")),
     }
 }
 
+/// Native-language config support: `--config X.{py,js,mjs,cjs}` delegates
+/// to `dirsql interpret <X>` (spawned via PATH) for `extract` execution.
+/// The binary still owns SQL, HTTP, and the file watcher.
+fn is_native_config(path: &Path) -> bool {
+    matches!(
+        path.extension().and_then(|s| s.to_str()),
+        Some("py") | Some("js") | Some("mjs") | Some("cjs")
+    )
+}
+
+fn load_native_state(config_path: &Path) -> AppState {
+    let (helper, config) = match spawn_interpret_helper(config_path) {
+        Ok(x) => x,
+        Err(err) => return AppState::Unavailable(err),
+    };
+    match build_dirsql(helper, config) {
+        Ok(db) => AppState::Ready(db),
+        Err(err) => AppState::Unavailable(format!(
+            "failed to build DirSQL from {}: {err}",
+            config_path.display()
+        )),
+    }
+}
+
+/// Spawn `dirsql interpret <config_path>` via PATH and hand the child
+/// off to [`InterpretHelper::from_child`]. Lives in the CLI binary
+/// (rather than the lib's `cli::native_config` module) because the
+/// `Command::new("dirsql")` plumbing is only meaningfully exercised
+/// end-to-end via the `dirsql --config X.{py,js,mjs,cjs}` integration
+/// path — there's no useful in-process unit test for it.
+fn spawn_interpret_helper(
+    config_path: &Path,
+) -> Result<
+    (
+        std::sync::Arc<InterpretHelper>,
+        dirsql::cli::native_config::NativeConfig,
+    ),
+    String,
+> {
+    use std::process::{Command, Stdio};
+    let child = Command::new("dirsql")
+        .arg("interpret")
+        .arg(config_path)
+        .stdin(Stdio::piped())
+        .stdout(Stdio::piped())
+        .stderr(Stdio::inherit())
+        .spawn()
+        .map_err(|e| {
+            format!(
+                "failed to spawn `dirsql interpret`: {e}. \
+                 Native-language configs require a launcher that implements `interpret` \
+                 on PATH (install dirsql via pip/uv or npm/npx)."
+            )
+        })?;
+    InterpretHelper::from_child(child)
+}
+
 /// Zero-config fallback. When no `.dirsql.toml` is found, dirsql indexes the
 /// directory that would have held the config with a single default `files`
 /// table — one row per file, columns drawn entirely from filesystem facts —

{dirsql-0.3.17 → dirsql-0.3.18}/packages/rust/src/cli/mod.rs

@@ -28,6 +28,7 @@ use tokio::task::JoinHandle;
 use crate::DirSQL;
 
 pub mod init;
+pub mod native_config;
 pub mod router;
 pub mod serialize;
 pub mod server;