plum

//! Installs Plum syntax-highlighting support into the local editor configuration.

//!

//! Everything the installers write is embedded into the `plum` binary at compile

//! time (via `include_str!`, relative to this crate), so `plum editor ...` works

//! from any working directory — it doesn't depend on being run from inside a

//! checkout the way a plain relative-path copy would.

use std::env;

use std::fs;

use std::path::{Path, PathBuf};

use anyhow::{Context, Result};

use clap::ValueEnum;

#[derive(Clone, Copy, ValueEnum)]

pub enum EditorType {

    Helix,

    Vscode,

}

// ---- embedded VSCode extension assets -------------------------------------

const VSCODE_PACKAGE_JSON: &str =

    include_str!("../../tooling/vscode-plum/package.json");

const VSCODE_LANGUAGE_CONFIG: &str =

    include_str!("../../tooling/vscode-plum/language-configuration.json");

const VSCODE_TMLANGUAGE: &str =

    include_str!("../../tooling/vscode-plum/syntaxes/plum.tmLanguage.json");

const VSCODE_PUBLISHER: &str = "plum-lang";

const VSCODE_EXTENSION_NAME: &str = "plum";

const VSCODE_EXTENSION_VERSION: &str = "0.0.1";

// ---- embedded Helix / tree-sitter query assets ----------------------------

const HELIX_HIGHLIGHTS: &str =

    include_str!("../../tooling/tree-sitter-plum/queries/plum/highlights.scm");

const HELIX_INDENTS: &str =

    include_str!("../../tooling/tree-sitter-plum/queries/plum/indents.scm");

const HELIX_INJECTIONS: &str =

    include_str!("../../tooling/tree-sitter-plum/queries/plum/injections.scm");

const HELIX_TAGS: &str =

    include_str!("../../tooling/tree-sitter-plum/queries/plum/tags.scm");

const HELIX_TEXTOBJECTS: &str =

    include_str!("../../tooling/tree-sitter-plum/queries/plum/textobjects.scm");

/// 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

/// languages.toml entry that actually resolves, instead of a hand-copied path

/// that goes stale the moment the repo moves.

const TREE_SITTER_PLUM_DIR: &str =

    concat!(env!("CARGO_MANIFEST_DIR"), "/../tooling/tree-sitter-plum");

/// [`TREE_SITTER_PLUM_DIR`] with the `..` component resolved away, for a tidier

/// `languages.toml`. Falls back to the raw (still-correct, just uglier) path if

/// the directory has moved since this binary was built.

fn treeSitterPlumDir() -> String {

    fs::canonicalize(TREE_SITTER_PLUM_DIR)

        .map(|p| p.display().to_string())

        .unwrap_or_else(|_| TREE_SITTER_PLUM_DIR.to_string())

}

pub fn install(editor: EditorType, insiders: bool) -> Result<()> {

    match editor {

        EditorType::Helix => installHelix(),

        EditorType::Vscode => installVscode(insiders),

    }

}

// ---- Helix -----------------------------------------------------------------

fn helixConfigDir() -> Result<PathBuf> {

    if let Ok(dir) = env::var("HELIX_RUNTIME_CONFIG") {

        return Ok(PathBuf::from(dir));

    }

    if let Ok(dir) = env::var("XDG_CONFIG_HOME") {

        return Ok(PathBuf::from(dir).join("helix"));

    }

    if let Ok(appdata) = env::var("APPDATA") {

        return Ok(PathBuf::from(appdata).join("helix"));

    }

    let home = env::var("HOME")

        .or_else(|_| env::var("USERPROFILE"))

        .context("could not determine home directory (checked $HOME / $USERPROFILE)")?;

    Ok(PathBuf::from(home).join(".config").join("helix"))

}

fn installHelix() -> Result<()> {

    let config_dir = helixConfigDir()?;

    fs::create_dir_all(&config_dir)

        .with_context(|| format!("failed to create {}", config_dir.display()))?;

    mergeLanguagesToml(&config_dir.join("languages.toml"))?;

    let queries_dir = config_dir.join("runtime").join("queries").join("plum");

    fs::create_dir_all(&queries_dir)

        .with_context(|| format!("failed to create {}", queries_dir.display()))?;

    fs::write(queries_dir.join("highlights.scm"), HELIX_HIGHLIGHTS)?;

    fs::write(queries_dir.join("indents.scm"), HELIX_INDENTS)?;

    fs::write(queries_dir.join("injections.scm"), HELIX_INJECTIONS)?;

    fs::write(queries_dir.join("tags.scm"), HELIX_TAGS)?;

    fs::write(queries_dir.join("textobjects.scm"), HELIX_TEXTOBJECTS)?;

    println!("installed Plum support for Helix in {}", config_dir.display());

    // Registering the language and dropping in query files isn't enough on its

    // own — Helix only highlights a file once the grammar has been compiled

    // 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.

    buildGrammar();

    Ok(())

}

fn buildGrammar() {

    let mut cmd = std::process::Command::new("hx");

    cmd.arg("--grammar").arg("build");

    // When `plum` itself is run via `cargo run`/`cargo test`, Cargo sets

    // CARGO_MANIFEST_DIR (and friends) in *this* process's environment, and a

    // plain `Command` inherits it into the `hx` child. Helix's own runtime-dir

    // resolution treats a present CARGO_MANIFEST_DIR as "I'm Helix's own dev

    // build running under cargo", and resolves grammar output relative to

    // *our* workspace root instead of the user's real Helix config — so `hx`

    // silently tries to write the compiled grammar to `<plum repo>/runtime/`

    // rather than `~/.config/helix/runtime/`. Strip every CARGO_* var so `hx`

    // falls back to its normal (non-dev) config/runtime-dir resolution.

    for (key, _) in env::vars() {

        if key.starts_with("CARGO") {

            cmd.env_remove(key);

        }

    }

    match cmd.status() {

        Ok(status) if status.success() => {

            println!("compiled the Plum tree-sitter grammar (hx --grammar build)");

        }

        Ok(status) => {

            println!(

                "`hx --grammar build` exited with {status}; run it manually to compile the Plum grammar"

            );

        }

        Err(_) => {

            println!("could not find `hx` on PATH; run `hx --grammar build` manually to compile the Plum grammar");

        }

    }

}

/// Structurally merges (rather than blindly appends, unlike a plain text-append)

/// a `[[language]]` + `[[grammar]]` entry for `plum` into the user's

/// `languages.toml`, using `toml_edit` so existing formatting/comments survive

/// and re-running the install is a no-op if the entry is already present.

fn mergeLanguagesToml(path: &Path) -> Result<()> {

    let existing = if path.exists() {

        fs::read_to_string(path).with_context(|| format!("failed to read {}", path.display()))?

    } else {

        String::new()

    };

    let mut doc = existing

        .parse::<toml_edit::DocumentMut>()

        .with_context(|| format!("failed to parse {} as TOML", path.display()))?;

    let already_present = doc

        .get("language")

        .and_then(|v| v.as_array_of_tables())

        .map(|arr| arr.iter().any(|t| t.get("name").and_then(|n| n.as_str()) == Some("plum")))

        .unwrap_or(false);

    if already_present {

        println!("{} already has a `plum` language entry, leaving it as-is", path.display());

        return Ok(());

    }

    let mut language = toml_edit::Table::new();

    language["name"] = toml_edit::value("plum");

    language["scope"] = toml_edit::value("source.plum");

    language["injection-regex"] = toml_edit::value("plum");

    let mut file_types = toml_edit::Array::new();

    file_types.push("plum");

    language["file-types"] = toml_edit::value(file_types);

    language["comment-tokens"] = toml_edit::value("#");

    let mut indent = toml_edit::InlineTable::new();

    indent.insert("tab-width", 2.into());

    indent.insert("unit", "  ".into());

    language["indent"] = toml_edit::Item::Value(toml_edit::Value::InlineTable(indent));

    doc.entry("language")

        .or_insert(toml_edit::Item::ArrayOfTables(toml_edit::ArrayOfTables::new()))

        .as_array_of_tables_mut()

        .context("`language` key in languages.toml is not an array of tables")?

        .push(language);

    let mut grammar = toml_edit::Table::new();

    grammar["name"] = toml_edit::value("plum");

    let mut source = toml_edit::InlineTable::new();

    source.insert("path", treeSitterPlumDir().into());

    grammar["source"] = toml_edit::Item::Value(toml_edit::Value::InlineTable(source));

    doc.entry("grammar")

        .or_insert(toml_edit::Item::ArrayOfTables(toml_edit::ArrayOfTables::new()))

        .as_array_of_tables_mut()

        .context("`grammar` key in languages.toml is not an array of tables")?

        .push(grammar);

    fs::write(path, doc.to_string()).with_context(|| format!("failed to write {}", path.display()))?;

    Ok(())

}

// ---- VSCode -----------------------------------------------------------------

fn homeDir() -> Result<PathBuf> {

    let home = env::var("HOME")

        .or_else(|_| env::var("USERPROFILE"))

        .context("could not determine home directory (checked $HOME / $USERPROFILE)")?;

    Ok(PathBuf::from(home))

}

fn installVscode(insiders: bool) -> Result<()> {

    let vscode_dir_name = if insiders { ".vscode-insiders" } else { ".vscode" };

    let extension_id = format!("{VSCODE_PUBLISHER}.{VSCODE_EXTENSION_NAME}-{VSCODE_EXTENSION_VERSION}");

    let target = homeDir()?.join(vscode_dir_name).join("extensions").join(&extension_id);

    if target.exists() {

        fs::remove_dir_all(&target)

            .with_context(|| format!("failed to remove existing {}", target.display()))?;

    }

    let syntaxes_dir = target.join("syntaxes");

    fs::create_dir_all(&syntaxes_dir)

        .with_context(|| format!("failed to create {}", syntaxes_dir.display()))?;

    fs::write(target.join("package.json"), VSCODE_PACKAGE_JSON)?;

    fs::write(target.join("language-configuration.json"), VSCODE_LANGUAGE_CONFIG)?;

    fs::write(syntaxes_dir.join("plum.tmLanguage.json"), VSCODE_TMLANGUAGE)?;

    println!("installed Plum extension for VSCode{} at {}", if insiders { " Insiders" } else { "" }, target.display());

    println!("reload the editor window (or restart VSCode) to pick it up");

    Ok(())

}

#[cfg(test)]

mod tests {

    use super::*;

    #[test]

    fn embeddedVscodePackageJsonMatchesPinnedIdentity() {

        assert!(VSCODE_PACKAGE_JSON.contains(&format!("\"version\": \"{VSCODE_EXTENSION_VERSION}\"")));

        assert!(VSCODE_PACKAGE_JSON.contains(&format!("\"publisher\": \"{VSCODE_PUBLISHER}\"")));

    }

    #[test]

    fn mergeLanguagesTomlIsIdempotent() {

        let dir = std::env::temp_dir().join(format!("plum-editor-test-{}", std::process::id()));

        std::fs::create_dir_all(&dir).unwrap();

        let path = dir.join("languages.toml");

        mergeLanguagesToml(&path).unwrap();

        let first = std::fs::read_to_string(&path).unwrap();

        assert!(first.contains("name = \"plum\""));

        mergeLanguagesToml(&path).unwrap();

        let second = std::fs::read_to_string(&path).unwrap();

        assert_eq!(first, second, "second install should be a no-op");

        std::fs::remove_dir_all(&dir).ok();

    }

}