Skip to content

The IDE you know, rebuilt in Rust. IntelliJ IDEA–style keymap, tool windows and search-everywhere in a fast native app: editor, code insight, debugger, Git, terminal, database and HTTP clients for 60+ languages.

feat(run): import the Node interpreter of JetBrains npm configurations (#1144)

l0ng-ai425a7da003c8
diff --git a/crates/ide-run/src/import/jetbrains.rs b/crates/ide-run/src/import/jetbrains.rs
index 777843a59..6d9dac06b 100644
--- a/crates/ide-run/src/import/jetbrains.rs
+++ b/crates/ide-run/src/import/jetbrains.rs
@@ -189,6 +189,21 @@ fn json_string(raw: &str) -> String {
serde_json::from_str::<String>(raw).unwrap_or_else(|_| raw.to_owned())
}
+/// A command line the run configuration forms parse back into `args` (`formatArgs` in the UI):
+/// single quotes only where needed.
+fn format_args(args: &[String]) -> String {
+ let quote = |a: &String| {
+ if a.is_empty() {
+ "''".to_owned()
+ } else if a.chars().any(|c| c.is_whitespace() || "'\"\\$`".contains(c)) {
+ format!("'{}'", a.replace('\'', "'\\''"))
+ } else {
+ a.clone()
+ }
+ };
+ args.iter().map(quote).collect::<Vec<_>>().join(" ")
+}
+
/// Regex-escaped for Jest / Vitest `-t`.
fn regex_escape(s: &str) -> String {
let mut out = String::with_capacity(s.len());
@@ -550,11 +565,20 @@ impl Cx<'_> {
// ------------------------------------------------------------- JavaScript
- fn node_interpreter(&self, c: &El, ignored: &mut Vec<String>) {
- let interpreter = c.value("node-interpreter").or_else(|| c.attr("node-interpreter"));
- if interpreter.is_some_and(|i| !i.is_empty() && i != "project") {
+ /// The configuration's own Node interpreter; `None` for the project's (`project`).
+ fn node_interpreter(&self, c: &El) -> Res<Option<String>> {
+ match c.value("node-interpreter").or_else(|| c.attr("node-interpreter")).map(str::trim) {
+ None | Some("" | "project") => Ok(None),
+ interpreter => self.text(interpreter),
+ }
+ }
+
+ /// Kinds without an interpreter field keep the project's and list the setting as ignored.
+ fn node_interpreter_ignored(&self, c: &El, ignored: &mut Vec<String>) -> Res<()> {
+ if self.node_interpreter(c)?.is_some() {
ignored.push("node-interpreter".into());
}
+ Ok(())
}
fn npm(&self, name: &str, c: &El, ignored: &mut Vec<String>) -> Res<RunConfig> {
@@ -590,10 +614,29 @@ impl Cx<'_> {
ignored.push("scripts".into());
}
}
- args.extend(self.words(c.value("arguments"))?);
- self.node_interpreter(c, ignored);
- let mut rc = config(name, "npm", manager, args, Some("js-debug"));
- rc.cwd = working_dir(self.root, &dir.to_string_lossy()).1.map(Into::into);
+ let arguments = self.words(c.value("arguments"))?;
+ args.extend(arguments.iter().cloned());
+ let interpreter = self.node_interpreter(c)?;
+ let package_dir = working_dir(self.root, &dir.to_string_lossy()).1;
+ let mut rc = config(name, "npm", manager.clone(), args, Some("js-debug"));
+ if let Some(interpreter) = interpreter {
+ // The npm form's fields, so the interpreter shows there (and the rest still match).
+ let script = if command == "run" { scripts.first().map(|s| (*s).to_owned()) } else { None };
+ let mut params = BTreeMap::from([
+ ("packageManager".to_owned(), manager),
+ ("command".to_owned(), command),
+ ("script".to_owned(), script.unwrap_or_default()),
+ ("arguments".to_owned(), format_args(&arguments)),
+ (
+ "packageDir".to_owned(),
+ package_dir.as_ref().map(|d| d.to_string_lossy().into_owned()).unwrap_or_default(),
+ ),
+ ("nodeInterpreter".to_owned(), interpreter),
+ ]);
+ params.retain(|_, v| !v.is_empty());
+ rc.extras.params = params;
+ }
+ rc.cwd = package_dir.map(Into::into);
rc.is_test = test;
self.envs(c, &mut rc);
Ok(rc)
@@ -628,7 +671,7 @@ impl Cx<'_> {
}
_ => {}
}
- self.node_interpreter(c, ignored);
+ self.node_interpreter_ignored(c, ignored)?;
let mut rc = config(name, "node", "npx".into(), args, Some("js-debug"));
rc.cwd = cwd.map(Into::into);
rc.is_test = true;
@@ -644,7 +687,7 @@ impl Cx<'_> {
let mut args = self.words(c.attr("node-parameters"))?;
args.push(path_from(self.root, file, &dir));
args.extend(self.args(c.attr("application-parameters"), &dir)?);
- self.node_interpreter(c, ignored);
+ self.node_interpreter_ignored(c, ignored)?;
let mut rc = config(name, "node", "node".into(), args, Some("js-debug"));
rc.cwd = cwd.map(Into::into);
self.envs(c, &mut rc);
diff --git a/crates/ide-run/tests/import_jetbrains.rs b/crates/ide-run/tests/import_jetbrains.rs
index 9bcee229d..f2f1da94d 100644
--- a/crates/ide-run/tests/import_jetbrains.rs
+++ b/crates/ide-run/tests/import_jetbrains.rs
@@ -279,7 +279,20 @@ fn workspace_run_manager_skips_templates_and_temporary_configurations() {
assert_eq!(dev.args, s(&["run", "dev", "--host", "0.0.0.0"]));
assert_eq!(cwd(dev), Some(PathBuf::from("web")));
assert_eq!(dev.env["VITE_API"], "http://localhost:8000");
- assert_eq!(ignored(&r, "dev"), ["node-interpreter", "scripts"]);
+ // The configuration's Node interpreter goes to the npm form, with the fields it shows.
+ let params: Vec<(&str, &str)> = dev.extras.params.iter().map(|(k, v)| (k.as_str(), v.as_str())).collect();
+ assert_eq!(
+ params,
+ [
+ ("arguments", "--host 0.0.0.0"),
+ ("command", "run"),
+ ("nodeInterpreter", "/opt/node22/bin/node"),
+ ("packageDir", "web"),
+ ("packageManager", "pnpm"),
+ ("script", "dev"),
+ ]
+ );
+ assert_eq!(ignored(&r, "dev"), ["scripts"]);
// Neither the template nor the temporary `build` is listed as skipped.
assert_eq!(r.skipped.len(), 2);
}