@tishlang/tish-format 1.0.12 → 1.0.13

package/crates/tishlang_cargo_bindgen/src/lib.rs

@@ -0,0 +1,349 @@
+//! Generate Rust glue for Tish `cargo:` imports by **reading the dependency crate’s source**
+//! (via `cargo metadata` + `syn`), classifying each `pub fn` by **signature shape**, then emitting
+//! `pub fn …(args: &[Value]) -> Value` shims.
+//!
+//! This avoids a fixed catalog of crate names: behavior follows **discovered** `pub fn` signatures
+//! (e.g. `Serialize` + `Result<String, _>`, or `&str` + `Deserialize` + `Result`).
+//!
+//! **Standalone use:** the CLI does not link `tishlang_runtime` (it only emits source). For generated
+//! crates, pass **`--tishlang-runtime-version`** so `Cargo.toml` uses a crates.io semver requirement
+//! instead of a `path` into the Tish repo (no workspace checkout required to **build** the glue crate).
+//!
+//! **Project mode (default):** with **`--project-root`** and **no** `--dependency`, the tool reads
+//! **`package.json` → `tish.rustDependencies`**, picks the path-based glue crate, and reads the
+//! **upstream** crate + semver from that glue crate’s **`Cargo.toml`** `[dependencies]` if it
+//! exists; otherwise from the **project root** **`Cargo.toml`** (`[dependencies]` and
+//! **`[dev-dependencies]`**), skipping **`tishlang_core`** / **`tishlang_runtime`** and path-only entries.
+
+mod classify;
+mod discover;
+pub mod infer;
+mod metadata;
+
+pub use classify::SignatureClass;
+pub use discover::rust_public_fn_location;
+pub use metadata::{
+    resolve_dependency_from_manifest, resolve_registry_dependency, ResolvedDependency,
+};
+
+use std::fs;
+use std::io;
+use std::path::Path;
+
+use classify::classify_public_fn;
+
+/// How the generated crate depends on `tishlang_runtime`.
+#[derive(Debug, Clone)]
+pub enum TishlangRuntimeDep {
+    /// `tishlang_runtime = { path = "..." }` (relative to `--out-dir`).
+    Path(String),
+    /// `tishlang_runtime = "1.0"` style crates.io requirement (standalone builds; publish `tishlang_runtime` first).
+    Version(String),
+}
+
+/// Configuration for a generated wrapper crate on disk.
+#[derive(Debug, Clone)]
+pub struct BindgenConfig {
+    /// Cargo `[package].name` of the **generated** crate (must match `cargo:` / `rustDependencies`).
+    pub output_crate_name: String,
+    pub tishlang_runtime: TishlangRuntimeDep,
+    pub out_dir: std::path::PathBuf,
+    /// Registry dependency name (e.g. `serde_json`) and semver req for the probe + generated dep.
+    pub dependency_name: String,
+    pub dependency_version_req: String,
+    /// Tish export names to wrap (must match a `pub fn` in the dependency).
+    pub exports: Vec<String>,
+}
+
+/// Full generation: resolve dependency, scan sources, classify, write crate.
+pub fn generate_from_registry_dependency(cfg: &BindgenConfig) -> Result<(), String> {
+    let resolved = resolve_registry_dependency(&cfg.dependency_name, &cfg.dependency_version_req)?;
+    generate_from_resolved(cfg, &resolved)
+}
+
+/// Same as [`generate_from_registry_dependency`] but dependency is already in `manifest_path`’s workspace.
+pub fn generate_from_manifest(
+    cfg: &BindgenConfig,
+    manifest_path: &Path,
+    dependency_package_name: &str,
+) -> Result<(), String> {
+    let resolved = resolve_dependency_from_manifest(manifest_path, dependency_package_name)?;
+    generate_from_resolved(cfg, &resolved)
+}
+
+fn generate_from_resolved(
+    cfg: &BindgenConfig,
+    resolved: &ResolvedDependency,
+) -> Result<(), String> {
+    let root = resolved.source_root();
+    let fns = discover::discover_public_functions(&root)?;
+
+    let mut need_json_helpers = false;
+    let mut emitted = Vec::new();
+
+    for export in &cfg.exports {
+        let item = fns.get(export).ok_or_else(|| {
+            format!(
+                "no public fn `{}` found under {}/src (exports must match a `pub fn` in the dependency sources)",
+                export,
+                root.display()
+            )
+        })?;
+
+        let class = classify_public_fn(item).ok_or_else(|| {
+            format!(
+                "public fn `{}` has no supported signature for automatic binding (need `&[Value] -> Value`, or `&T where T: Serialize` with `Result<String, _>`, or `&str` with `Deserialize` and `Result`)",
+                export
+            )
+        })?;
+
+        match class {
+            SignatureClass::SerializeRefToResultString | SignatureClass::DeserializeStrToResult => {
+                need_json_helpers = true;
+            }
+            SignatureClass::TishValueAbi => {}
+        }
+
+        emitted.push((export.clone(), class));
+    }
+
+    let lib_rs = render_generated_lib(&cfg.dependency_name, &emitted, need_json_helpers)?;
+
+    let cargo_toml = render_output_cargo_toml(cfg, resolved.version(), need_json_helpers)?;
+
+    fs::create_dir_all(cfg.out_dir.join("src")).map_err(|e| e.to_string())?;
+    fs::write(cfg.out_dir.join("Cargo.toml"), cargo_toml).map_err(|e| e.to_string())?;
+    fs::write(cfg.out_dir.join("src").join("lib.rs"), lib_rs).map_err(|e| e.to_string())?;
+
+    Ok(())
+}
+
+impl BindgenConfig {
+    /// Write using [`generate_from_registry_dependency`].
+    pub fn write_files(&self) -> io::Result<()> {
+        generate_from_registry_dependency(self).map_err(|e| io::Error::new(io::ErrorKind::Other, e))
+    }
+}
+
+fn render_output_cargo_toml(
+    cfg: &BindgenConfig,
+    dep_exact_version: &str,
+    need_serde_json: bool,
+) -> Result<String, String> {
+    let rt_line = match &cfg.tishlang_runtime {
+        TishlangRuntimeDep::Path(p) => {
+            format!("tishlang_runtime = {{ path = {} }}\n", toml_string_value(p))
+        }
+        TishlangRuntimeDep::Version(req) => {
+            format!("tishlang_runtime = {}\n", toml_string_value(req))
+        }
+    };
+    let dep_line = format!(
+        "{} = {}\n",
+        cfg.dependency_name,
+        toml_string_value(dep_exact_version)
+    );
+    // JSON bridge helpers use `serde_json::Value`; only add a second dep when the upstream crate is not serde_json.
+    let extra_serde = if need_serde_json && cfg.dependency_name != "serde_json" {
+        "serde_json = \"1.0\"\n"
+    } else {
+        ""
+    };
+
+    Ok(format!(
+        r#"[package]
+name = "{name}"
+version = "0.1.0"
+edition = "2021"
+publish = false
+
+[lib]
+path = "src/lib.rs"
+
+[dependencies]
+{rt_line}{dep_line}{extra_serde}"#,
+        name = cfg.output_crate_name,
+        rt_line = rt_line,
+        dep_line = dep_line,
+        extra_serde = extra_serde
+    ))
+}
+
+fn render_generated_lib(
+    dependency_cargo_name: &str,
+    exports: &[(String, SignatureClass)],
+    need_json_helpers: bool,
+) -> Result<String, String> {
+    let crate_ident = dependency_cargo_name.replace('-', "_");
+    let mut out = String::from(
+        "//! Generated by `tishlang-cargo-bindgen` — do not edit.\n\
+         //! Bindings inferred from the dependency crate’s `pub fn` signatures (syn + cargo metadata).\n\n\
+         use std::cell::RefCell;\n\
+         use std::rc::Rc;\n\
+         use std::sync::Arc;\n\
+         use tishlang_runtime::{ObjectMap, Value, VmRef};\n\n",
+    );
+
+    out.push_str(&format!("use {} as _tish_upstream;\n\n", crate_ident));
+
+    if need_json_helpers {
+        out.push_str(JSON_HELPERS);
+    }
+
+    for (name, class) in exports {
+        let rust_fn = syn::parse_str::<syn::Ident>(name)
+            .map_err(|e| format!("invalid export name {}: {}", name, e))?;
+        let block = match class {
+            SignatureClass::TishValueAbi => format!(
+                "pub fn {name}(args: &[Value]) -> Value {{\n    _tish_upstream::{name}(args)\n}}\n\n",
+                name = rust_fn
+            ),
+            SignatureClass::SerializeRefToResultString => format!(
+                "pub fn {name}(args: &[Value]) -> Value {{\n    let Some(v) = args.first() else {{ return Value::Null }};\n    match _tish_upstream::{name}(&tish_to_json(v)) {{\n        Ok(s) => Value::String(Arc::from(s)),\n        Err(_) => Value::Null,\n    }}\n}}\n\n",
+                name = rust_fn
+            ),
+            SignatureClass::DeserializeStrToResult => format!(
+                "pub fn {name}(args: &[Value]) -> Value {{\n    let s = match args.first() {{\n        Some(Value::String(x)) => x.as_ref(),\n        _ => return Value::Null,\n    }};\n    match _tish_upstream::{name}::<serde_json::Value>(s) {{\n        Ok(j) => json_to_tish(j),\n        Err(_) => Value::Null,\n    }}\n}}\n\n",
+                name = rust_fn
+            ),
+        };
+        out.push_str(&block);
+    }
+
+    Ok(out)
+}
+
+const JSON_HELPERS: &str = r#"fn tish_to_json(v: &Value) -> serde_json::Value {
+    match v {
+        Value::Null => serde_json::Value::Null,
+        Value::Bool(b) => serde_json::Value::Bool(*b),
+        Value::Number(n) => serde_json::Number::from_f64(*n)
+            .map(serde_json::Value::Number)
+            .unwrap_or(serde_json::Value::Null),
+        Value::String(s) => serde_json::Value::String(s.to_string()),
+        Value::Array(a) => {
+            serde_json::Value::Array(a.borrow().iter().map(|x| tish_to_json(x)).collect())
+        }
+        Value::Object(o) => {
+            let mut m = serde_json::Map::new();
+            for (k, v) in o.borrow().iter() {
+                m.insert(k.to_string(), tish_to_json(v));
+            }
+            serde_json::Value::Object(m)
+        }
+        _ => serde_json::Value::Null,
+    }
+}
+
+fn json_to_tish(v: serde_json::Value) -> Value {
+    match v {
+        serde_json::Value::Null => Value::Null,
+        serde_json::Value::Bool(b) => Value::Bool(b),
+        serde_json::Value::Number(n) => Value::Number(n.as_f64().unwrap_or(0.0)),
+        serde_json::Value::String(s) => Value::String(s.into()),
+        serde_json::Value::Array(a) => Value::Array(VmRef::new(
+            a.into_iter().map(json_to_tish).collect(),
+        )),
+        serde_json::Value::Object(m) => {
+            let mut om = ObjectMap::default();
+            for (k, v) in m {
+                om.insert(Arc::from(k), json_to_tish(v));
+            }
+            Value::Object(VmRef::new(om))
+        }
+    }
+}
+
+"#;
+
+fn toml_string_value(s: &str) -> String {
+    let escaped = s.replace('\\', "\\\\").replace('"', "\\\"");
+    format!("\"{}\"", escaped)
+}
+
+/// Resolve a path to `tishlang_runtime` for writing into generated `Cargo.toml`.
+pub fn resolve_runtime_path_for_output(start: &Path) -> Result<String, String> {
+    if let Ok(p) = std::env::var("TISHLANG_RUNTIME_PATH") {
+        let pb = Path::new(&p);
+        if pb.join("Cargo.toml").is_file() {
+            return canonical_path_string(pb);
+        }
+        return Err(format!(
+            "TISHLANG_RUNTIME_PATH does not point to tishlang_runtime: {}",
+            p
+        ));
+    }
+
+    let mut dir = if start.is_file() {
+        start.parent().unwrap_or(start).to_path_buf()
+    } else {
+        start.to_path_buf()
+    };
+
+    for _ in 0..64 {
+        let npm_rt = dir
+            .join("node_modules")
+            .join("@tishlang")
+            .join("tish")
+            .join("crates")
+            .join("tish_runtime");
+        if npm_rt.join("Cargo.toml").is_file() {
+            return canonical_path_string(&npm_rt);
+        }
+
+        let ws_rt = dir.join("crates").join("tish_runtime");
+        if ws_rt.join("Cargo.toml").is_file() {
+            return canonical_path_string(&ws_rt);
+        }
+
+        if !dir.pop() {
+            break;
+        }
+    }
+
+    Err(
+        "Could not find tishlang_runtime (set TISHLANG_RUNTIME_PATH or run from a project with node_modules/@tishlang/tish or a Tish repo checkout)"
+            .into(),
+    )
+}
+
+fn canonical_path_string(p: &Path) -> Result<String, String> {
+    p.canonicalize()
+        .map_err(|e| format!("Cannot canonicalize {}: {}", p.display(), e))
+        .map(|p| p.display().to_string().replace('\\', "/"))
+}
+
+/// Relative path from `out_dir` to `runtime` for Cargo.toml `path =`.
+pub fn runtime_path_relative_to_out_dir(
+    out_dir: &Path,
+    runtime: impl AsRef<Path>,
+) -> Result<String, String> {
+    let abs_rt = runtime
+        .as_ref()
+        .canonicalize()
+        .map_err(|e| format!("Cannot canonicalize runtime path: {}", e))?;
+    fs::create_dir_all(out_dir).map_err(|e| e.to_string())?;
+    let abs_out = out_dir
+        .canonicalize()
+        .map_err(|e| format!("Cannot canonicalize out dir: {}", e))?;
+
+    pathdiff::diff_paths(&abs_rt, &abs_out)
+        .ok_or_else(|| "Could not compute relative path from out_dir to runtime".to_string())
+        .map(|p| p.display().to_string().replace('\\', "/"))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn generated_lib_contains_tish_abi_forward() {
+        let s = render_generated_lib(
+            "demo",
+            &[("greet".into(), SignatureClass::TishValueAbi)],
+            false,
+        )
+        .unwrap();
+        assert!(s.contains("_tish_upstream::greet"));
+    }
+}

package/crates/tishlang_cargo_bindgen/src/main.rs

@@ -0,0 +1,167 @@
+//! CLI for pre-generating `cargo:` binding crates (bindgen-style).
+//!
+//! Resolves the dependency with `cargo metadata`, scans its `src/**/*.rs` with `syn`, classifies
+//! each requested `pub fn` by signature, and emits a wrapper crate.
+
+use std::path::PathBuf;
+
+use clap::Parser;
+use tishlang_cargo_bindgen::{
+    generate_from_manifest, generate_from_registry_dependency, infer,
+    resolve_runtime_path_for_output, runtime_path_relative_to_out_dir, BindgenConfig,
+    TishlangRuntimeDep,
+};
+
+#[derive(Parser, Debug)]
+#[command(name = "tishlang-cargo-bindgen")]
+#[command(about = "Generate Rust glue for Tish `cargo:` imports from dependency source + metadata")]
+struct Args {
+    /// Upstream Cargo package to wrap (e.g. serde_json). Omit to read `tish.rustDependencies` + glue `Cargo.toml`.
+    #[arg(long)]
+    dependency: Option<String>,
+
+    /// Semver for the upstream crate when using `--dependency` (ignored in full project auto mode).
+    #[arg(long, default_value = "1.0")]
+    dependency_version: String,
+
+    /// Generated crate `[package].name` when using `--dependency` with `--out-dir` (default: tish_serde_json).
+    #[arg(long)]
+    crate_name: Option<String>,
+
+    /// Output directory. Required with `--dependency` unless `--project-root` selects a path from `package.json`.
+    #[arg(long)]
+    out_dir: Option<PathBuf>,
+
+    /// Comma-separated export names to bind (must match `pub fn` names in the dependency).
+    #[arg(long, default_value = "to_string,from_str")]
+    exports: String,
+
+    /// If set, resolve `dependency` from this workspace instead of a temporary probe crate.
+    #[arg(long)]
+    manifest_path: Option<PathBuf>,
+
+    /// Directory containing `package.json` (default: current directory). Drives automatic glue discovery.
+    #[arg(long)]
+    project_root: Option<PathBuf>,
+
+    /// Crates.io semver for `tishlang_runtime` in the generated `Cargo.toml` (no path into the Tish repo).
+    /// Mutually exclusive with `--tishlang-runtime-path`.
+    #[arg(long, conflicts_with = "tishlang_runtime_path")]
+    tishlang_runtime_version: Option<String>,
+
+    /// Absolute path to the `tishlang_runtime` crate root for generated `path = ...` (overrides search).
+    /// Mutually exclusive with `--tishlang-runtime-version`.
+    #[arg(long, conflicts_with = "tishlang_runtime_version")]
+    tishlang_runtime_path: Option<PathBuf>,
+}
+
+fn main() {
+    if let Err(e) = run() {
+        eprintln!("tishlang-cargo-bindgen: error: {}", e);
+        std::process::exit(1);
+    }
+}
+
+fn run() -> Result<(), String> {
+    let args = Args::parse();
+
+    let exports: Vec<String> = args
+        .exports
+        .split(',')
+        .map(|s| s.trim().to_string())
+        .filter(|s| !s.is_empty())
+        .collect();
+    if exports.is_empty() {
+        return Err("no exports given".into());
+    }
+
+    if args.dependency.is_none() && args.out_dir.is_some() {
+        return Err(
+            "--out-dir is only used with --dependency (without --dependency, output path comes from package.json tish.rustDependencies)"
+                .into(),
+        );
+    }
+
+    let current_dir = std::env::current_dir().map_err(|e| e.to_string())?;
+
+    let (output_crate_name, out_dir, dependency_name, dependency_version_req, search_root) =
+        if let Some(dep) = args.dependency.as_ref() {
+            if let Some(out) = args.out_dir.as_ref() {
+                let root = args
+                    .project_root
+                    .clone()
+                    .unwrap_or_else(|| out.parent().unwrap_or(out).to_path_buf());
+                (
+                    args.crate_name
+                        .clone()
+                        .unwrap_or_else(|| "tish_serde_json".into()),
+                    out.clone(),
+                    dep.clone(),
+                    args.dependency_version.clone(),
+                    root,
+                )
+            } else {
+                let root = args
+                    .project_root
+                    .clone()
+                    .unwrap_or_else(|| current_dir.clone());
+                let (crate_key, od) =
+                    infer::infer_glue_paths_only(&root, args.crate_name.as_deref())?;
+                (
+                    crate_key,
+                    od,
+                    dep.clone(),
+                    args.dependency_version.clone(),
+                    root,
+                )
+            }
+        } else {
+            let root = args
+                .project_root
+                .clone()
+                .unwrap_or_else(|| current_dir.clone());
+            let inf = infer::infer_from_project_root(&root, args.crate_name.as_deref())?;
+            (
+                inf.output_crate_name,
+                inf.out_dir,
+                inf.dependency_name,
+                inf.dependency_version_req,
+                root,
+            )
+        };
+
+    let tishlang_runtime = if let Some(req) = args.tishlang_runtime_version.clone() {
+        TishlangRuntimeDep::Version(req)
+    } else if let Some(p) = args.tishlang_runtime_path.as_ref() {
+        let abs = p
+            .canonicalize()
+            .map_err(|e| format!("tishlang_runtime path {}: {}", p.display(), e))?;
+        TishlangRuntimeDep::Path(runtime_path_relative_to_out_dir(&out_dir, &abs)?)
+    } else {
+        let runtime_abs = resolve_runtime_path_for_output(&search_root)?;
+        let rt_rel = runtime_path_relative_to_out_dir(&out_dir, &runtime_abs)?;
+        TishlangRuntimeDep::Path(rt_rel)
+    };
+
+    let cfg = BindgenConfig {
+        output_crate_name,
+        tishlang_runtime,
+        out_dir: out_dir.clone(),
+        dependency_name,
+        dependency_version_req,
+        exports,
+    };
+
+    if let Some(manifest) = args.manifest_path {
+        generate_from_manifest(&cfg, &manifest, &cfg.dependency_name)?;
+    } else {
+        generate_from_registry_dependency(&cfg)?;
+    }
+
+    println!(
+        "Wrote {} (upstream `{}`, metadata + syn)",
+        out_dir.display(),
+        cfg.dependency_name
+    );
+    Ok(())
+}

package/crates/tishlang_cargo_bindgen/src/metadata.rs

@@ -0,0 +1,117 @@
+//! Resolve a crates.io (or registry) dependency to its on-disk source tree via `cargo metadata`.
+
+use std::fs;
+use std::path::{Path, PathBuf};
+
+use cargo_metadata::{MetadataCommand, Package, TargetKind};
+
+/// Root directory of the resolved dependency (contains `Cargo.toml` and usually `src/`).
+#[derive(Debug, Clone)]
+pub struct ResolvedDependency {
+    pub name: String,
+    pub version: String,
+    pub manifest_path: PathBuf,
+}
+
+impl ResolvedDependency {
+    pub fn source_root(&self) -> PathBuf {
+        self.manifest_path
+            .parent()
+            .expect("manifest has parent")
+            .to_path_buf()
+    }
+
+    pub fn version(&self) -> &str {
+        &self.version
+    }
+}
+
+fn from_package(pkg: &Package) -> ResolvedDependency {
+    ResolvedDependency {
+        name: pkg.name.clone(),
+        version: pkg.version.to_string(),
+        manifest_path: pkg.manifest_path.as_std_path().to_path_buf(),
+    }
+}
+
+/// Build a tiny probe crate, run `cargo metadata`, and return the named package.
+pub fn resolve_registry_dependency(
+    name: &str,
+    version_req: &str,
+) -> Result<ResolvedDependency, String> {
+    let probe_dir = tempfile::tempdir().map_err(|e| format!("tempdir: {}", e))?;
+    let probe_toml = format!(
+        r#"[package]
+name = "_tishlang_bindgen_probe"
+version = "0.0.0"
+edition = "2021"
+[dependencies]
+{} = "{}"
+"#,
+        name, version_req
+    );
+    let manifest = probe_dir.path().join("Cargo.toml");
+    fs::write(&manifest, probe_toml).map_err(|e| format!("write probe Cargo.toml: {}", e))?;
+    // `cargo metadata` requires at least one target in the root package.
+    let src_dir = probe_dir.path().join("src");
+    fs::create_dir_all(&src_dir).map_err(|e| format!("probe src dir: {}", e))?;
+    fs::write(src_dir.join("lib.rs"), "// probe only\n")
+        .map_err(|e| format!("write probe lib.rs: {}", e))?;
+
+    let meta = MetadataCommand::new()
+        .manifest_path(&manifest)
+        .exec()
+        .map_err(|e| format!("cargo metadata failed: {} (is `cargo` on PATH?)", e))?;
+
+    let pkg = meta
+        .packages
+        .iter()
+        .find(|p| p.name == name)
+        .ok_or_else(|| {
+            format!(
+                "dependency `{}` not found in metadata (check name and version req `{}`)",
+                name, version_req
+            )
+        })?;
+
+    let root = pkg.manifest_path.as_std_path().parent().unwrap();
+    if !root.join("src").is_dir()
+        && !pkg
+            .targets
+            .iter()
+            .any(|t| t.kind.iter().any(|k| *k == TargetKind::Lib))
+    {
+        return Err(format!(
+            "package `{}` has no src/ or lib target at {}",
+            name,
+            root.display()
+        ));
+    }
+
+    Ok(from_package(pkg))
+}
+
+/// Resolve using an existing workspace manifest (no temporary probe).
+pub fn resolve_dependency_from_manifest(
+    manifest_path: &Path,
+    package_name: &str,
+) -> Result<ResolvedDependency, String> {
+    let meta = MetadataCommand::new()
+        .manifest_path(manifest_path)
+        .exec()
+        .map_err(|e| format!("cargo metadata: {}", e))?;
+
+    let pkg = meta
+        .packages
+        .iter()
+        .find(|p| p.name == package_name)
+        .ok_or_else(|| {
+            format!(
+                "package `{}` not found in metadata for {}",
+                package_name,
+                manifest_path.display()
+            )
+        })?;
+
+    Ok(from_package(pkg))
+}