b5f5be1 | plum | pyrossh

git clone https://git.pyrossh.dev/plum

A statically typed, imperative programming language inspired by rust, python

b5f5be1 — Peter John 2026-09-08T15:03:28+05:30

feat(cli): fix stale Helix grammar path and embed a precompiled grammar .so

Files changed (3) hide show

plum-cli/Cargo.toml +1 -0
plum-cli/build.rs +58 -0
plum-cli/src/editor.rs +91 -3

plum-cli/Cargo.toml CHANGED Viewed

@@ -2,6 +2,7 @@
 name = "plum-cli"
 version = "0.1.0"
 edition = "2021"
+build = "build.rs"
 [[bin]]
 name = "plum"

plum-cli/build.rs ADDED Viewed

@@ -0,0 +1,58 @@
+//! Precompiles the `tree-sitter-plum` grammar into a native shared library at
+//! `plum`-build time (using whatever C compiler is already on the machine —
+//! the same one Cargo itself needs to build `tree-sitter-plum`'s own
+//! `scanner.c`/`parser.c` for in-process parsing), so `plum editor helix` can
+//! just copy the finished `.so` into Helix's `runtime/grammars/` directory
+//! instead of shelling out to `hx --grammar build` (which requires `hx` on
+//! PATH, a working C compiler on the *installing* machine again, and a
+//! `languages.toml` grammar `source.path` that still resolves).
+//!
+//! If the compiler invocation fails (no C compiler found), this falls back to
+//! writing an empty placeholder rather than failing the whole `plum-cli`
+//! build — `editor::installHelix` detects the empty payload and falls back to
+//! the old `hx --grammar build` codepath at install time instead.
+use std::env;
+use std::path::PathBuf;
+use std::process::Command;
+fn main() {
+    let manifest_dir = PathBuf::from(env::var("CARGO_MANIFEST_DIR").unwrap());
+    let src_dir = manifest_dir.join("../plum-tooling/tree-sitter-plum/src");
+    let out_dir = PathBuf::from(env::var("OUT_DIR").unwrap());
+    let so_path = out_dir.join("plum-grammar.so");
+    println!("cargo:rerun-if-changed={}", src_dir.join("parser.c").display());
+    println!("cargo:rerun-if-changed={}", src_dir.join("scanner.c").display());
+    let cc = env::var("CC").unwrap_or_else(|_| "cc".to_string());
+    let status = Command::new(&cc)
+        .arg("-shared")
+        .arg("-fPIC")
+        .arg("-O2")
+        .arg("-I")
+        .arg(&src_dir)
+        .arg("-o")
+        .arg(&so_path)
+        .arg(src_dir.join("parser.c"))
+        .arg(src_dir.join("scanner.c"))
+        .status();
+    match status {
+        Ok(s) if s.success() => {
+            println!("cargo:rustc-env=PLUM_GRAMMAR_SO={}", so_path.display());
+        }
+        other => {
+            std::fs::write(&so_path, []).expect("failed to write placeholder grammar .so");
+            println!("cargo:rustc-env=PLUM_GRAMMAR_SO={}", so_path.display());
+            match other {
+                Ok(s) => println!(
+                    "cargo:warning=`{cc}` exited with {s} while precompiling the Plum tree-sitter grammar; `plum editor helix` will fall back to `hx --grammar build`"
+                ),
+                Err(e) => println!(
+                    "cargo:warning=could not run `{cc}` to precompile the Plum tree-sitter grammar ({e}); `plum editor helix` will fall back to `hx --grammar build`"
+                ),
+            }
+        }
+    }
+}

plum-cli/src/editor.rs CHANGED Viewed

@@ -44,6 +44,12 @@ const HELIX_TAGS: &str =
 const HELIX_TEXTOBJECTS: &str =
     include_str!("../../plum-tooling/tree-sitter-plum/queries/plum/textobjects.scm");
+/// Precompiled by `build.rs` from the same `parser.c`/`scanner.c` that back
+/// in-process parsing, on whatever machine builds this `plum` binary. Empty
+/// when `build.rs` couldn't find a C compiler — see `buildGrammar` for the
+/// fallback used in that case.
+const HELIX_GRAMMAR_SO: &[u8] = include_bytes!(env!("PLUM_GRAMMAR_SO"));
 /// The absolute path to the `tree-sitter-plum` grammar crate on the machine that
 /// *built* this `plum` binary. Baked in at compile time so a contributor running
 /// `cargo run -p plum-cli -- editor helix` from their own checkout gets a
@@ -109,8 +115,20 @@ fn installHelix() -> Result<()> {
     // into a shared library under runtime/grammars/. `hx --health <lang>`
     // reports the tree-sitter parser as present just because the config is
     // valid, even when that .so has never been built, which makes a missing
-    // build step easy to miss. Build it now instead of just telling the user to.
+    // build step easy to miss. We already have one precompiled (by our own
+    // `build.rs`, on this same machine) embedded in the binary, so just drop
+    // it in directly instead of shelling out to `hx --grammar build`.
+    if HELIX_GRAMMAR_SO.is_empty() {
-    buildGrammar();
+        buildGrammar();
+    } else {
+        let grammars_dir = config_dir.join("runtime").join("grammars");
+        fs::create_dir_all(&grammars_dir)
+            .with_context(|| format!("failed to create {}", grammars_dir.display()))?;
+        let so_path = grammars_dir.join("plum.so");
+        fs::write(&so_path, HELIX_GRAMMAR_SO)
+            .with_context(|| format!("failed to write {}", so_path.display()))?;
+        println!("installed precompiled Plum tree-sitter grammar to {}", so_path.display());
+    }
     Ok(())
 }
@@ -169,7 +187,41 @@ fn mergeLanguagesToml(path: &Path) -> Result<()> {
         .unwrap_or(false);
     if already_present {
+        let current_path = treeSitterPlumDir();
+        let stale_path = doc
+            .get_mut("grammar")
+            .and_then(|v| v.as_array_of_tables_mut())
+            .and_then(|arr| arr.iter_mut().find(|t| t.get("name").and_then(|n| n.as_str()) == Some("plum")))
+            .and_then(|grammar| {
+                let existing_path = grammar
+                    .get("source")
+                    .and_then(|s| s.as_inline_table())
+                    .and_then(|s| s.get("path"))
+                    .and_then(|p| p.as_str())
+                    .map(|s| s.to_string());
+                if existing_path.as_deref() != Some(current_path.as_str()) {
+                    let mut source = toml_edit::InlineTable::new();
+                    source.insert("path", current_path.clone().into());
+                    grammar["source"] = toml_edit::Item::Value(toml_edit::Value::InlineTable(source));
+                    existing_path
+                } else {
+                    None
+                }
+            });
+        match stale_path {
+            Some(old) => {
+                fs::write(path, doc.to_string())
+                    .with_context(|| format!("failed to write {}", path.display()))?;
+                println!(
+                    "{} already has a `plum` language entry; updated its stale grammar path ({old} -> {current_path})",
+                    path.display()
+                );
+            }
+            None => {
-        println!("{} already has a `plum` language entry, leaving it as-is", path.display());
+                println!("{} already has a `plum` language entry, leaving it as-is", path.display());
+            }
+        }
         return Ok(());
     }
@@ -265,4 +317,40 @@ mod tests {
         std::fs::remove_dir_all(&dir).ok();
     }
+    #[test]
+    fn mergeLanguagesTomlFixesStaleGrammarPath() {
+        let dir = std::env::temp_dir().join(format!("plum-editor-test-stale-{}", std::process::id()));
+        std::fs::create_dir_all(&dir).unwrap();
+        let path = dir.join("languages.toml");
+        std::fs::write(
+            &path,
+            r##"[[language]]
+name = "plum"
+scope = "source.plum"
+injection-regex = "plum"
+file-types = ["plum"]
+comment-tokens = "#"
+indent = { tab-width = 2, unit = "  " }
+[[grammar]]
+name = "plum"
+source = { path = "/some/stale/path/tree-sitter-plum" }
+"##,
+        )
+        .unwrap();
+        mergeLanguagesToml(&path).unwrap();
+        let updated = std::fs::read_to_string(&path).unwrap();
+        assert!(!updated.contains("/some/stale/path/tree-sitter-plum"));
+        assert!(updated.contains(&treeSitterPlumDir()));
+        // running again should now be a stable no-op
+        mergeLanguagesToml(&path).unwrap();
+        let second = std::fs::read_to_string(&path).unwrap();
+        assert_eq!(updated, second, "re-running after the fix should be a no-op");
+        std::fs::remove_dir_all(&dir).ok();
+    }
 }