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 JetBrains run configurations (.run/*.run.xml, .idea/workspace.xml) (#1039)

Andrea Basile9a6b84e2871a
diff --git a/crates/ide-run/src/detect.rs b/crates/ide-run/src/detect.rs
index c9195b404..acb7e87dc 100644
--- a/crates/ide-run/src/detect.rs
+++ b/crates/ide-run/src/detect.rs
@@ -151,7 +151,7 @@ fn relative(root: &Path, dir: &Path) -> PathBuf {
// ---------------------------------------------------------------- node
-fn package_manager(root: &Path, pkg: &Json) -> &'static str {
+pub(crate) fn package_manager(root: &Path, pkg: &Json) -> &'static str {
if let Some(pm) = pkg.get("packageManager").and_then(Json::as_str) {
match pm.split('@').next().unwrap_or_default() {
"pnpm" => return "pnpm",
@@ -172,7 +172,7 @@ fn package_manager(root: &Path, pkg: &Json) -> &'static str {
}
}
-fn is_test_script(name: &str) -> bool {
+pub(crate) fn is_test_script(name: &str) -> bool {
matches!(name, "test" | "vitest" | "jest") || name.starts_with("test:")
}
diff --git a/crates/ide-run/src/import/jetbrains.rs b/crates/ide-run/src/import/jetbrains.rs
new file mode 100644
index 000000000..777843a59
--- /dev/null
+++ b/crates/ide-run/src/import/jetbrains.rs
@@ -0,0 +1,879 @@
+//! JetBrains run configurations (PyCharm, WebStorm, IntelliJ IDEA): the shared `.run/*.run.xml`
+//! files, `.idea/runConfigurations/*.xml`, and the `RunManager` of `.idea/workspace.xml` without
+//! its templates (`default="true"`) and temporary configurations. A configuration found in more
+//! than one place is taken from the first, in that order.
+//!
+//! Python, Django server, Django tests, pytest, npm, Jest, Vitest, Node.js, Shell Script and
+//! compound configurations become the matching kinds; other types are skipped with their type.
+//! `$PROJECT_DIR$` (and `$MODULE_DIR$`, `$MODULE_WORKING_DIR$`, `$ContentRoot$`,
+//! `$ProjectFileDir$`, all the project directory here) and `$USER_HOME$` are replaced; another
+//! path variable skips the configuration.
+
+use super::{
+ Entry, Found, SkipReason, command_name, config, env_var, normalize, path_from, project_python, relative_to,
+ working_dir,
+};
+use crate::RunConfig;
+use ide_core::IdeResult;
+use quick_xml::{Reader, XmlVersion, events::Event};
+use std::cell::Cell;
+use std::collections::BTreeMap;
+use std::path::{Path, PathBuf};
+
+/// The files read, in order of precedence, with the name the summary gives them.
+pub(crate) fn files(root: &Path) -> Vec<(String, PathBuf)> {
+ let mut out = Vec::new();
+ for (dir, suffix) in [(".run", ".run.xml"), (".idea/runConfigurations", ".xml")] {
+ let mut found: Vec<PathBuf> = std::fs::read_dir(root.join(dir))
+ .into_iter()
+ .flatten()
+ .flatten()
+ .map(|e| e.path())
+ .filter(|p| p.is_file() && p.file_name().is_some_and(|n| n.to_string_lossy().ends_with(suffix)))
+ .collect();
+ found.sort();
+ for p in found {
+ let name = p.file_name().map(|n| n.to_string_lossy().into_owned()).unwrap_or_default();
+ out.push((format!("{dir}/{name}"), p));
+ }
+ }
+ // IDEA writes a workspace.xml in every project it opens: it counts only with configurations to import.
+ let workspace = root.join(".idea/workspace.xml");
+ let has_configurations = std::fs::read_to_string(&workspace).is_ok_and(|text| {
+ text.contains("RunManager")
+ && parse(&text).map_or(true, |doc| configurations(&doc, "RunManager").next().is_some())
+ });
+ if has_configurations {
+ out.push((".idea/workspace.xml".into(), workspace));
+ }
+ out
+}
+
+/// The configurations of `manager` (`RunManager` in workspace.xml), without IDEA's templates for
+/// new configurations and the temporary ones it makes for a single run.
+fn configurations<'a>(doc: &'a El, manager: &'a str) -> impl Iterator<Item = &'a El> {
+ std::iter::once(doc)
+ .chain(doc.children.iter())
+ .filter(move |c| c.name == "component" && c.attr("name") == Some(manager))
+ .flat_map(|component| component.children_named("configuration"))
+ .filter(|c| c.attr("default") != Some("true") && c.attr("temporary") != Some("true"))
+}
+
+pub(crate) fn entries(root: &Path, env: &BTreeMap<String, String>) -> IdeResult<Vec<Entry>> {
+ let windows = cfg!(windows);
+ let homes = if windows { ["USERPROFILE", "HOME"] } else { ["HOME", "USERPROFILE"] };
+ let home = homes.into_iter().find_map(|k| env_var(env, k, windows));
+ let cx = Cx { root: &normalize(root), home, modules: module_count(root), machine_values: Cell::new(false) };
+ let mut out = Vec::new();
+ for (label, path) in files(root) {
+ let doc = std::fs::read_to_string(&path).map_err(|e| e.to_string()).and_then(|text| parse(&text));
+ let doc = match doc {
+ Ok(doc) => doc,
+ Err(detail) => {
+ out.push(Entry { name: label, result: Err(SkipReason::InvalidFile { detail }) });
+ continue;
+ }
+ };
+ let workspace = label == ".idea/workspace.xml";
+ let manager = if workspace { "RunManager" } else { "ProjectRunConfigurationManager" };
+ out.extend(configurations(&doc, manager).map(|c| cx.entry(c)));
+ }
+ Ok(out)
+}
+
+// ------------------------------------------------------------------------- XML
+
+/// An element of the file, with its attributes (values unescaped) and child elements.
+#[derive(Debug, Default)]
+struct El {
+ name: String,
+ attrs: Vec<(String, String)>,
+ children: Vec<El>,
+}
+
+impl El {
+ fn attr(&self, key: &str) -> Option<&str> {
+ self.attrs.iter().find(|(k, _)| k == key).map(|(_, v)| v.as_str())
+ }
+
+ fn child(&self, name: &str) -> Option<&El> {
+ self.children.iter().find(|c| c.name == name)
+ }
+
+ fn children_named<'a>(&'a self, name: &'a str) -> impl Iterator<Item = &'a El> {
+ self.children.iter().filter(move |c| c.name == name)
+ }
+
+ /// `<option name="KEY" value="…"/>`, a direct child.
+ fn option(&self, key: &str) -> Option<&str> {
+ self.children_named("option").find(|o| o.attr("name") == Some(key)).and_then(|o| o.attr("value"))
+ }
+
+ /// `<KEY value="…"/>` (the WebStorm types write their fields so).
+ fn value(&self, key: &str) -> Option<&str> {
+ self.child(key).and_then(|c| c.attr("value"))
+ }
+
+ fn flag(&self, key: &str) -> bool {
+ self.option(key) == Some("true")
+ }
+}
+
+fn parse(xml: &str) -> Result<El, String> {
+ let mut reader = Reader::from_str(xml);
+ let mut stack: Vec<El> = vec![El::default()];
+ loop {
+ let event = reader.read_event().map_err(|e| e.to_string())?;
+ match event {
+ Event::Start(ref tag) | Event::Empty(ref tag) => {
+ let mut el = El { name: tag.name().as_ref().to_owned(), ..El::default() };
+ for a in tag.attributes() {
+ let a = a.map_err(|e| e.to_string())?;
+ let value = a.normalized_value(XmlVersion::Implicit1_0).map_err(|e| e.to_string())?;
+ el.attrs.push((a.key.as_ref().to_owned(), value.into_owned()));
+ }
+ if matches!(event, Event::Start(_)) {
+ stack.push(el);
+ } else if let Some(parent) = stack.last_mut() {
+ parent.children.push(el);
+ }
+ }
+ Event::End(_) => {
+ let el = stack.pop().ok_or("unbalanced element")?;
+ stack.last_mut().ok_or("unbalanced element")?.children.push(el);
+ }
+ Event::Eof => break,
+ _ => {}
+ }
+ }
+ let mut document = stack.pop().filter(|_| stack.is_empty()).ok_or("unclosed element")?;
+ document.children.pop().ok_or_else(|| "no root element".to_owned())
+}
+
+// ------------------------------------------------------------------- mapping
+
+const PYTHON: &str = "PythonConfigurationType";
+const DJANGO_SERVER: &str = "Python.DjangoServer";
+const DJANGO_TESTS: &str = "DjangoTestsConfigurationType";
+const PYTHON_TESTS: &str = "tests";
+const NPM: &str = "js.build_tools.npm";
+const JEST: &str = "JavaScriptTestRunnerJest";
+const VITEST: &str = "JavaScriptTestRunnerVitest";
+const NODE: &str = "NodeJSConfigurationType";
+const SHELL: &str = "ShConfigurationType";
+const COMPOUND: &str = "CompoundRunConfigurationType";
+
+type Res<T> = Result<T, SkipReason>;
+
+/// What a `$NAME$` that isn't a known path macro does.
+#[derive(Clone, Copy, PartialEq)]
+enum Unknown {
+ /// Skips the configuration: a path variable defined in the IDE, with no value here.
+ Skip,
+ /// Stays as written: script text, where `$` belongs to the shell.
+ Keep,
+}
+
+struct Cx<'a> {
+ root: &'a Path,
+ home: Option<String>,
+ /// Modules `.idea/modules.xml` lists. `$MODULE_DIR$` is the module's content root: the project
+ /// directory in a single-module project, unknown here with several.
+ modules: usize,
+ /// The configuration being converted used `$USER_HOME$`: its values belong to this machine.
+ machine_values: Cell<bool>,
+}
+
+/// A JSON string as the pytest configuration stores its `_new_*` fields (`"\"tests\""`).
+fn json_string(raw: &str) -> String {
+ serde_json::from_str::<String>(raw).unwrap_or_else(|_| raw.to_owned())
+}
+
+/// Regex-escaped for Jest / Vitest `-t`.
+fn regex_escape(s: &str) -> String {
+ let mut out = String::with_capacity(s.len());
+ for c in s.chars() {
+ if r"\^$.|?*+()[]{}".contains(c) {
+ out.push('\\');
+ }
+ out.push(c);
+ }
+ out
+}
+
+impl Cx<'_> {
+ /// Replaces the path macros in `s`; another `$NAME$` skips the configuration.
+ fn expand(&self, s: &str) -> Res<String> {
+ self.expand_with(s, Unknown::Skip)
+ }
+
+ /// Replaces the path macros in `s`, which IDEA writes in every option of a configuration
+ /// (script text included); `unknown` says what another `$NAME$` does.
+ fn expand_with(&self, s: &str, unknown: Unknown) -> Res<String> {
+ let mut out = String::with_capacity(s.len());
+ let mut rest = s;
+ while let Some(start) = rest.find('$') {
+ let after = &rest[start + 1..];
+ let len =
+ after.find('$').filter(|&n| n > 0 && after[..n].chars().all(|c| c.is_ascii_alphanumeric() || c == '_'));
+ let Some(len) = len else {
+ out.push_str(&rest[..=start]);
+ rest = after;
+ continue;
+ };
+ out.push_str(&rest[..start]);
+ let name = &after[..len];
+ let value = match name {
+ "PROJECT_DIR" | "ContentRoot" | "ProjectFileDir" => self.root.to_string_lossy().into_owned(),
+ // Which module's directory is unknown here when there are several.
+ "MODULE_DIR" | "MODULE_WORKING_DIR" if self.modules > 1 => {
+ return Err(SkipReason::SeveralModules { variable: format!("${name}$") });
+ }
+ "MODULE_DIR" | "MODULE_WORKING_DIR" => self.root.to_string_lossy().into_owned(),
+ "USER_HOME" => {
+ self.machine_values.set(true);
+ self.home.clone().ok_or(SkipReason::PathVariable { variable: format!("${name}$") })?
+ }
+ _ => match unknown {
+ Unknown::Skip => return Err(SkipReason::PathVariable { variable: format!("${name}$") }),
+ Unknown::Keep => format!("${name}$"),
+ },
+ };
+ out.push_str(&value);
+ rest = &after[len + 1..];
+ }
+ out.push_str(rest);
+ Ok(out)
+ }
+
+ fn text(&self, value: Option<&str>) -> Res<Option<String>> {
+ match value.map(str::trim) {
+ Some(v) if !v.is_empty() => self.expand(v).map(Some),
+ _ => Ok(None),
+ }
+ }
+
+ /// Words of a parameters field, split like IDEA's `ParametersListUtil.parse`.
+ fn words(&self, value: Option<&str>) -> Res<Vec<String>> {
+ self.words_quoted(value, Quotes::Double)
+ }
+
+ fn words_quoted(&self, value: Option<&str>, quotes: Quotes) -> Res<Vec<String>> {
+ Ok(self.text(value)?.map(|v| parse_params(&v, quotes)).unwrap_or_default())
+ }
+
+ /// Words of a command line, paths inside the project relative to `dir`.
+ fn args(&self, value: Option<&str>, dir: &Path) -> Res<Vec<String>> {
+ self.args_quoted(value, Quotes::Double, dir)
+ }
+
+ fn args_quoted(&self, value: Option<&str>, quotes: Quotes, dir: &Path) -> Res<Vec<String>> {
+ Ok(self.words_quoted(value, quotes)?.into_iter().map(|a| path_from(self.root, a, dir)).collect())
+ }
+
+ /// The working directory (absolute) and the configuration's `cwd`.
+ fn cwd(&self, value: Option<&str>) -> Res<(PathBuf, Option<PathBuf>)> {
+ Ok(match self.text(value)? {
+ Some(dir) => working_dir(self.root, &dir),
+ None => (self.root.to_path_buf(), None),
+ })
+ }
+
+ fn entry(&self, c: &El) -> Entry {
+ let name = c.attr("name").unwrap_or_default().trim().to_owned();
+ self.machine_values.set(false);
+ let result = if name.is_empty() { Err(SkipReason::Invalid) } else { self.convert(&name, c) };
+ let result = result.map(|mut found| {
+ // Values of this machine (its home) stay out of the shared run.toml.
+ found.config.extras.local = self.machine_values.get();
+ if let Some(folder) = c.attr("folderName").filter(|f| !f.trim().is_empty()) {
+ found.config.extras.folder = Some(folder.trim().to_owned());
+ }
+ // IDEA's "Allow multiple instances".
+ found.config.allow_parallel = c.attr("singleton") == Some("false");
+ if c.child("method").is_some_and(|m| !m.children.is_empty()) {
+ found.ignored.push("before launch".into());
+ }
+ found.ignored.sort();
+ found
+ });
+ Entry { name, result }
+ }
+
+ fn convert(&self, name: &str, c: &El) -> Res<Found> {
+ let ty = c.attr("type").unwrap_or_default();
+ let factory = c.attr("factoryName").unwrap_or_default();
+ let mut ignored = Vec::new();
+ let mut members = Vec::new();
+ let config = match ty {
+ PYTHON => self.python(name, c, &mut ignored)?,
+ DJANGO_SERVER => self.django_server(name, c, &mut ignored)?,
+ DJANGO_TESTS => self.django_tests(name, c, &mut ignored)?,
+ PYTHON_TESTS if matches!(factory, "py.test" | "pytest") => self.pytest(name, c, &mut ignored)?,
+ NPM => self.npm(name, c, &mut ignored)?,
+ JEST | VITEST => self.js_tests(name, c, ty == VITEST, &mut ignored)?,
+ NODE => self.node(name, c, &mut ignored)?,
+ SHELL => self.shell(name, c)?,
+ COMPOUND => {
+ members = c.children_named("toRun").filter_map(|t| t.attr("name")).map(str::to_owned).collect();
+ config(name, "compound", String::new(), Vec::new(), None)
+ }
+ PYTHON_TESTS => return Err(SkipReason::UnsupportedType { type_: format!("{ty} ({factory})") }),
+ other => return Err(SkipReason::UnsupportedType { type_: other.to_owned() }),
+ };
+ Ok(Found { config, members, ignored })
+ }
+
+ // ------------------------------------------------------------- Python
+
+ /// The interpreter (`SDK_HOME` when the configuration doesn't use the module's), its
+ /// options, and the working directory.
+ fn interpreter(&self, c: &El, ignored: &mut Vec<String>) -> Res<(String, Vec<String>, PathBuf, Option<PathBuf>)> {
+ let (dir, cwd) = self.cwd(c.option("WORKING_DIRECTORY"))?;
+ let sdk = if c.flag("IS_MODULE_SDK") { None } else { self.text(c.option("SDK_HOME"))? };
+ let (exe, mut args) = match sdk {
+ Some(sdk) => (path_from(self.root, sdk, &dir), Vec::new()),
+ None => project_python(self.root, &dir),
+ };
+ args.extend(self.words(c.option("INTERPRETER_OPTIONS"))?);
+ // A flag (`AbstractPythonRunConfiguration.java:320-321`): `false` leaves nothing out.
+ if c.option("RUN_TOOL") == Some("true") {
+ ignored.push("RUN_TOOL".into());
+ }
+ Ok((exe, args, dir, cwd))
+ }
+
+ /// `envs`, `PARENT_ENVS`, `ENV_FILES` and the EnvFile plugin's files.
+ fn python_env(&self, c: &El, rc: &mut RunConfig, ignored: &mut Vec<String>) -> Res<()> {
+ self.envs(c, rc);
+ rc.extras.include_system_env = c.option("PARENT_ENVS") != Some("false");
+ // PyCharm 2024+: "Paths to .env files", joined with `File.pathSeparator`.
+ for file in split_env_files(c.option("ENV_FILES").unwrap_or_default(), PATH_SEPARATOR) {
+ if let Some(file) = self.text(Some(file))? {
+ rc.extras.env_files.push(path_from(self.root, file, self.root));
+ }
+ }
+ self.envfile_plugin(c, rc, ignored)
+ }
+
+ /// Environment variables, as written: IDEA doesn't put path macros there
+ /// (`RunConfigurationPathMacroFilter`), and the Python and Shell types pass `$NAME$` through as is.
+ fn envs(&self, c: &El, rc: &mut RunConfig) {
+ for env in c.child("envs").into_iter().flat_map(|e| e.children_named("env")) {
+ if let Some(key) = env.attr("name").filter(|k| !k.is_empty()) {
+ rc.env.insert(key.to_owned(), env.attr("value").unwrap_or_default().to_owned());
+ }
+ }
+ }
+
+ /// The EnvFile plugin (`net.ashald.envfile`): its enabled `.env` entries.
+ fn envfile_plugin(&self, c: &El, rc: &mut RunConfig, ignored: &mut Vec<String>) -> Res<()> {
+ let Some(ext) = c.children_named("extension").find(|e| e.attr("name") == Some("net.ashald.envfile")) else {
+ return Ok(());
+ };
+ if !ext.flag("IS_ENABLED") {
+ return Ok(());
+ }
+ for entry in ext.child("ENTRIES").into_iter().flat_map(|e| e.children_named("ENTRY")) {
+ let path = entry.attr("PATH").unwrap_or_default();
+ if entry.attr("IS_ENABLED") == Some("false") || path.is_empty() {
+ continue;
+ }
+ if entry.attr("PARSER").is_some_and(|p| p != "env") || entry.attr("IS_EXECUTABLE") == Some("true") {
+ ignored.push(format!("EnvFile {path}"));
+ continue;
+ }
+ if let Some(file) = self.text(Some(path))? {
+ rc.extras.env_files.push(path_from(self.root, file, self.root));
+ }
+ }
+ Ok(())
+ }
+
+ fn python(&self, name: &str, c: &El, ignored: &mut Vec<String>) -> Res<RunConfig> {
+ let (exe, mut args, dir, cwd) = self.interpreter(c, ignored)?;
+ let Some(script) = self.text(c.option("SCRIPT_NAME"))? else {
+ return Err(SkipReason::NothingToRun);
+ };
+ if c.flag("MODULE_MODE") {
+ args.extend(["-m".to_owned(), script]);
+ } else {
+ args.push(path_from(self.root, script, &dir));
+ }
+ args.extend(self.args(c.option("PARAMETERS"), &dir)?);
+ let mut rc = config(name, "python", exe, args, Some("debugpy"));
+ rc.cwd = cwd.map(Into::into);
+ rc.extras.emulate_terminal = c.flag("EMULATE_TERMINAL");
+ if c.flag("REDIRECT_INPUT") {
+ ignored.push("REDIRECT_INPUT".into());
+ }
+ self.python_env(c, &mut rc, ignored)?;
+ Ok(rc)
+ }
+
+ /// `manage.py` relative to the working directory: there, at the root, or one level down.
+ fn manage_py(&self, dir: &Path) -> Res<String> {
+ let mut candidates = vec![dir.join("manage.py"), self.root.join("manage.py")];
+ if let Ok(read) = std::fs::read_dir(self.root) {
+ let mut nested: Vec<PathBuf> =
+ read.flatten().map(|e| e.path().join("manage.py")).filter(|p| p.is_file()).collect();
+ if nested.len() == 1 {
+ candidates.append(&mut nested);
+ }
+ }
+ let found =
+ candidates.into_iter().find(|p| p.is_file()).ok_or(SkipReason::MissingFile { file: "manage.py".into() })?;
+ Ok(relative_to(&normalize(&found), dir).unwrap_or_else(|| found.to_string_lossy().into_owned()))
+ }
+
+ fn django_server(&self, name: &str, c: &El, ignored: &mut Vec<String>) -> Res<RunConfig> {
+ let (exe, mut args, dir, cwd) = self.interpreter(c, ignored)?;
+ args.push(self.manage_py(&dir)?);
+ let custom = if c.flag("useCustomRunCommand") { self.text(c.option("customRunCommand"))? } else { None };
+ args.push(custom.unwrap_or_else(|| "runserver".into()));
+ let port = self.text(c.option("port"))?;
+ match (self.text(c.option("host"))?, port) {
+ (Some(host), port) => args.push(format!("{host}:{}", port.as_deref().unwrap_or("8000"))),
+ (None, Some(port)) => args.push(port),
+ (None, None) => {}
+ }
+ if c.flag("runNoReload") {
+ args.push("--noreload".into());
+ }
+ args.extend(self.words(c.option("additionalOptions"))?);
+ for key in ["browserUrl", "launchJavascriptDebuger", "runTestServer"] {
+ if c.option(key).is_some_and(|v| !v.is_empty() && v != "false") {
+ ignored.push(key.into());
+ }
+ }
+ let mut rc = config(name, "python", exe, args, Some("debugpy"));
+ rc.cwd = cwd.map(Into::into);
+ self.python_env(c, &mut rc, ignored)?;
+ Ok(rc)
+ }
+
+ fn django_tests(&self, name: &str, c: &El, ignored: &mut Vec<String>) -> Res<RunConfig> {
+ let (exe, mut args, dir, cwd) = self.interpreter(c, ignored)?;
+ let manage = self.manage_py(&dir)?;
+ // The Django tests form runs `manage.py` from the working directory; another place stays a Python run.
+ let kind = if manage == "manage.py" { "django-test" } else { "python" };
+ args.extend([manage, "test".to_owned()]);
+ args.extend(self.words(c.option("TARGET"))?);
+ if c.flag("CUSTOM_SETTINGS")
+ && let Some(settings) = self.text(c.option("SETTINGS_FILE"))?
+ {
+ args.extend(["--settings".to_owned(), settings_module(&settings, self.root, &dir)]);
+ }
+ if c.flag("USE_OPTIONS") {
+ args.extend(self.words(c.option("OPTIONS"))?);
+ }
+ let mut rc = config(name, kind, exe, args, Some("debugpy"));
+ rc.cwd = cwd.map(Into::into);
+ // A test configuration either way: the test tree reads `manage.py test` output in a Python run too.
+ rc.is_test = true;
+ self.python_env(c, &mut rc, ignored)?;
+ Ok(rc)
+ }
+
+ fn pytest(&self, name: &str, c: &El, ignored: &mut Vec<String>) -> Res<RunConfig> {
+ let (exe, mut args, dir, cwd) = self.interpreter(c, ignored)?;
+ args.extend(["-m".to_owned(), "pytest".to_owned()]);
+ let field = |key: &str| c.option(key).map(json_string).filter(|v| !v.trim().is_empty());
+ // As `PyTestConfiguration` (intellij-community `PyTest.kt:151-153`, `:181-183`): parameters only
+ // follow a Python target (`name[params]`), keywords go to `-k` unless the target is custom.
+ let target_type = field("_new_targetType");
+ if let Some(target) = field("_new_target") {
+ let target = self.expand(&target)?;
+ match target_type.as_deref() {
+ Some("PYTHON") => {
+ let params = field("_new_parameters").map(|p| format!("[{p}]")).unwrap_or_default();
+ match self.python_target(&target, &dir) {
+ Some(node_id) => args.push(format!("{node_id}{params}")),
+ // Not a module of the project (an installed package): pytest finds it by name.
+ None => {
+ args.extend(["--pyargs".to_owned(), target]);
+ if !params.is_empty() {
+ ignored.push("_new_parameters".into());
+ }
+ }
+ }
+ }
+ Some("CUSTOM") => {}
+ _ => args.push(path_from(self.root, target, &dir)),
+ }
+ }
+ if target_type.as_deref() != Some("CUSTOM")
+ && let Some(keywords) =
+ field("_new_keywords").map(|k| strip_quotes(&k).to_owned()).filter(|k| !k.is_empty())
+ {
+ args.extend(["-k".to_owned(), keywords]);
+ }
+ // Single quotes group words here too (`PyTestsShared.kt:671`).
+ args.extend(self.args_quoted(field("_new_additionalArguments").as_deref(), Quotes::Single, &dir)?);
+ let mut rc = config(name, "pytest", exe, args, Some("debugpy"));
+ rc.cwd = cwd.map(Into::into);
+ rc.is_test = true;
+ self.python_env(c, &mut rc, ignored)?;
+ Ok(rc)
+ }
+
+ /// A pytest Python target (`tests.test_money.TestRound.test_eur`) as the node id PyCharm
+ /// passes (`tests/test_money.py::TestRound::test_eur`, intellij-community `PyTestsShared.kt:366-400`):
+ /// the longest prefix that is a module on disk (`a/b.py` or `a/b/__init__.py`, from the working
+ /// directory, then the project root), then the rest as `::` symbols. Relative to `dir`.
+ fn python_target(&self, dotted: &str, dir: &Path) -> Option<String> {
+ let parts: Vec<&str> = dotted.split('.').collect();
+ if parts.iter().any(|p| p.is_empty()) {
+ return None;
+ }
+ for base in [dir, self.root] {
+ for n in (1..=parts.len()).rev() {
+ let module = parts[..n].join("/");
+ let (file, node) = if base.join(format!("{module}.py")).is_file() {
+ (base.join(format!("{module}.py")), format!("{module}.py"))
+ } else if base.join(&module).join("__init__.py").is_file() {
+ (base.join(&module), module.clone())
+ } else {
+ continue;
+ };
+ let path = if base == dir { node } else { path_from(self.root, file.to_string_lossy().into(), dir) };
+ return Some(
+ std::iter::once(path)
+ .chain(parts[n..].iter().map(|s| (*s).to_owned()))
+ .collect::<Vec<_>>()
+ .join("::"),
+ );
+ }
+ }
+ None
+ }
+
+ // ------------------------------------------------------------- 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") {
+ ignored.push("node-interpreter".into());
+ }
+ }
+
+ fn npm(&self, name: &str, c: &El, ignored: &mut Vec<String>) -> Res<RunConfig> {
+ let package_json = self.text(c.value("package-json"))?;
+ let dir = match &package_json {
+ Some(p) => normalize(&self.root.join(p)).parent().map(Path::to_path_buf).unwrap_or(self.root.to_path_buf()),
+ None => self.root.to_path_buf(),
+ };
+ let manager = match self.text(c.value("package-manager"))? {
+ Some(pm) if ["npm", "pnpm", "yarn", "bun"].contains(&command_name(&pm)) => command_name(&pm).to_owned(),
+ _ => {
+ let pkg = std::fs::read_to_string(dir.join("package.json"))
+ .ok()
+ .and_then(|t| serde_json::from_str(&t).ok())
+ .unwrap_or_default();
+ crate::detect::package_manager(&dir, &pkg).to_owned()
+ }
+ };
+ let command = self.text(c.value("command"))?.unwrap_or_else(|| "run".into());
+ let scripts: Vec<&str> = c
+ .child("scripts")
+ .into_iter()
+ .flat_map(|s| s.children_named("script"))
+ .filter_map(|s| s.attr("value"))
+ .collect();
+ let mut args = vec![command.clone()];
+ let mut test = command == "test";
+ if command == "run" {
+ let Some(script) = scripts.first() else { return Err(SkipReason::NothingToRun) };
+ test = crate::detect::is_test_script(script);
+ args.push((*script).to_owned());
+ if scripts.len() > 1 {
+ 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);
+ rc.is_test = test;
+ self.envs(c, &mut rc);
+ Ok(rc)
+ }
+
+ fn js_tests(&self, name: &str, c: &El, vitest: bool, ignored: &mut Vec<String>) -> Res<RunConfig> {
+ let (dir, cwd) = self.cwd(c.value("working-dir"))?;
+ let mut args: Vec<String> = if vitest { vec!["vitest".into(), "run".into()] } else { vec!["jest".into()] };
+ if !vitest && let Some(config_file) = self.text(c.value("config-file"))? {
+ args.extend(["--config".to_owned(), path_from(self.root, config_file, &dir)]);
+ }
+ args.extend(self.args(c.value(if vitest { "vitest-options" } else { "jest-options" }), &dir)?);
+ match c.value("scope-kind").unwrap_or("ALL") {
+ "DIRECTORY" => args.extend(self.text(c.value("test-directory"))?.map(|d| path_from(self.root, d, &dir))),
+ "TEST_FILE" | "SUITE" | "TEST" => {
+ args.extend(self.text(c.value("test-file"))?.map(|f| path_from(self.root, f, &dir)));
+ let names: Vec<&str> = c
+ .child("test-names")
+ .into_iter()
+ .flat_map(|n| n.children_named("test-name"))
+ .filter_map(|n| n.attr("value"))
+ .collect();
+ if !names.is_empty() {
+ let pattern = names.iter().map(|n| regex_escape(n)).collect::<Vec<_>>().join(" ");
+ let anchored = if c.value("scope-kind") == Some("TEST") {
+ format!("^{pattern}$")
+ } else {
+ format!("^{pattern}")
+ };
+ args.extend(["-t".to_owned(), anchored]);
+ }
+ }
+ _ => {}
+ }
+ self.node_interpreter(c, ignored);
+ let mut rc = config(name, "node", "npx".into(), args, Some("js-debug"));
+ rc.cwd = cwd.map(Into::into);
+ rc.is_test = true;
+ self.envs(c, &mut rc);
+ Ok(rc)
+ }
+
+ fn node(&self, name: &str, c: &El, ignored: &mut Vec<String>) -> Res<RunConfig> {
+ let (dir, cwd) = self.cwd(c.attr("working-dir"))?;
+ let Some(file) = self.text(c.attr("path-to-js-file"))? else {
+ return Err(SkipReason::NothingToRun);
+ };
+ 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);
+ let mut rc = config(name, "node", "node".into(), args, Some("js-debug"));
+ rc.cwd = cwd.map(Into::into);
+ self.envs(c, &mut rc);
+ rc.extras.include_system_env = c.attr("pass-parent-envs") != Some("false");
+ Ok(rc)
+ }
+
+ // ------------------------------------------------------------- Shell
+
+ /// A script file (with its interpreter) or script text, kept as the Shell Script form's fields.
+ fn shell(&self, name: &str, c: &El) -> Res<RunConfig> {
+ let (dir, cwd) = self.cwd(c.option("SCRIPT_WORKING_DIRECTORY"))?;
+ let mut params = BTreeMap::new();
+ // Both default to true when missing (`ShRunConfiguration.java:148-149`).
+ let rc = if c.option("EXECUTE_SCRIPT_FILE") != Some("false") {
+ let Some(path) = self.text(c.option("SCRIPT_PATH"))? else { return Err(SkipReason::NothingToRun) };
+ let path = path_from(self.root, path, &dir);
+ let options = self.text(c.option("SCRIPT_OPTIONS"))?.unwrap_or_default();
+ let interpreter =
+ self.text(c.option("INTERPRETER_PATH"))?.map(|i| path_from(self.root, i, &dir)).unwrap_or_default();
+ let interpreter_options = self.text(c.option("INTERPRETER_OPTIONS"))?.unwrap_or_default();
+ // Run directly, the script is the program: `./run.sh`, so it isn't looked up on the PATH.
+ let path = if interpreter.is_empty() { dot_slash(path) } else { path };
+ let (command, args) = if interpreter.is_empty() {
+ (path.clone(), parse_params(&options, Quotes::Double))
+ } else {
+ let mut args = parse_params(&interpreter_options, Quotes::Double);
+ args.push(path.clone());
+ args.extend(parse_params(&options, Quotes::Double));
+ (interpreter.clone(), args)
+ };
+ params.extend([
+ ("mode".to_owned(), "file".to_owned()),
+ ("path".to_owned(), path),
+ ("options".to_owned(), options),
+ ("interpreter".to_owned(), interpreter),
+ ("interpreterOptions".to_owned(), interpreter_options),
+ ]);
+ config(name, "shell", command, args, None)
+ } else {
+ // IDEA writes `$PROJECT_DIR$` / `$USER_HOME$` into the text too; any other `$` is the shell's.
+ let script = self.expand_with(c.option("SCRIPT_TEXT").unwrap_or_default().trim(), Unknown::Keep)?;
+ if script.is_empty() {
+ return Err(SkipReason::NothingToRun);
+ }
+ params.extend([("mode".to_owned(), "text".to_owned()), ("script".to_owned(), script.clone())]);
+ config(name, "shell", script, Vec::new(), None)
+ };
+ let mut rc = rc;
+ params.retain(|_, v| !v.is_empty());
+ rc.extras.params = params;
+ rc.cwd = cwd.map(Into::into);
+ rc.extras.emulate_terminal = c.option("EXECUTE_IN_TERMINAL") != Some("false");
+ self.envs(c, &mut rc);
+ Ok(rc)
+ }
+}
+
+/// Which quotes group words in a parameters field.
+#[derive(Clone, Copy)]
+enum Quotes {
+ Double,
+ Single,
+}
+
+/// IDEA's `ParametersListUtil.parse`: words split at whitespace, grouped by quotes (dropped);
+/// a backslash escapes only a quote, so Windows paths (`C:\p\out`) keep theirs.
+fn parse_params(line: &str, quotes: Quotes) -> Vec<String> {
+ let is_quote = |c: char| c == '"' || (matches!(quotes, Quotes::Single) && c == '\'');
+ let mut out = Vec::new();
+ let mut token = String::new();
+ let mut quote: Option<char> = None;
+ let mut escaped = false;
+ let mut non_empty = false;
+ let mut chars = line.trim().chars().peekable();
+ while let Some(c) = chars.next() {
+ if quote.map_or(is_quote(c), |q| q == c) {
+ if !escaped {
+ quote = if quote.is_some() { None } else { Some(c) };
+ non_empty = true;
+ continue;
+ }
+ escaped = false;
+ } else if c.is_whitespace() && quote.is_none() {
+ if !token.is_empty() || non_empty {
+ out.push(std::mem::take(&mut token));
+ non_empty = false;
+ }
+ continue;
+ } else if c == '\\'
+ && let Some(&next) = chars.peek()
+ && quote.map_or(is_quote(next), |q| q == next)
+ {
+ escaped = true;
+ continue;
+ }
+ token.push(c);
+ }
+ if !token.is_empty() || non_empty {
+ out.push(token);
+ }
+ out
+}
+
+/// A relative path as a program: `run.sh` → `./run.sh` (`../x` and rooted paths stay; `/opt/x`
+/// has no drive on Windows but isn't relative either).
+fn dot_slash(path: String) -> String {
+ if Path::new(&path).has_root() || path.starts_with("./") || path.starts_with("../") {
+ path
+ } else {
+ format!("./{path}")
+ }
+}
+
+/// How IDEA joins a configuration's `.env` files (`File.pathSeparator`).
+const PATH_SEPARATOR: char = if cfg!(windows) { ';' } else { ':' };
+
+/// The `ENV_FILES` paths, joined with `separator` (intellij-community
+/// `AbstractPythonRunConfiguration.java:303-304`, `:337`).
+fn split_env_files(value: &str, separator: char) -> impl Iterator<Item = &str> {
+ value.split(separator).filter(|f| !f.trim().is_empty())
+}
+
+/// Keywords without the quotes around them (`"not slow"` → `not slow`).
+fn strip_quotes(s: &str) -> &str {
+ let s = s.trim();
+ for q in ['"', '\''] {
+ if let Some(inner) = s.strip_prefix(q).and_then(|r| r.strip_suffix(q)) {
+ return inner;
+ }
+ }
+ s
+}
+
+/// Modules in `.idea/modules.xml` (0 without the file).
+fn module_count(root: &Path) -> usize {
+ let Some(doc) = std::fs::read_to_string(root.join(".idea/modules.xml")).ok().and_then(|t| parse(&t).ok()) else {
+ return 0;
+ };
+ let components = std::iter::once(&doc).chain(doc.children.iter());
+ components
+ .filter(|c| c.name == "component" && c.attr("name") == Some("ProjectModuleManager"))
+ .flat_map(|c| c.children_named("modules"))
+ .map(|m| m.children_named("module").count())
+ .sum()
+}
+
+/// `--settings` from PyCharm's "Settings" field: a file (`mysite/settings/dev.py`, relative to
+/// the project) becomes its module relative to the working directory; a module stays as it is.
+fn settings_module(value: &str, root: &Path, dir: &Path) -> String {
+ let Some(stem) = value.strip_suffix(".py") else { return value.to_owned() };
+ let file = normalize(&root.join(stem));
+ let rel = file.strip_prefix(dir).map(Path::to_path_buf).unwrap_or_else(|_| PathBuf::from(stem));
+ rel.components().map(|c| c.as_os_str().to_string_lossy().into_owned()).collect::<Vec<_>>().join(".")
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn parses_elements_attributes_and_escapes() {
+ let doc = parse(
+ "<?xml version=\"1.0\"?>\n<project><component name=\"RunManager\"><configuration name=\"a &amp; b\">\
+ <option name=\"SCRIPT_TEXT\" value=\"echo 1&#10;echo 2\" /></configuration></component></project>",
+ )
+ .unwrap();
+ assert_eq!(doc.name, "project");
+ let c = &doc.children[0].children[0];
+ assert_eq!(c.attr("name"), Some("a & b"));
+ assert_eq!(c.option("SCRIPT_TEXT"), Some("echo 1\necho 2"));
+ assert!(parse("<a><b></a>").is_err());
+ }
+
+ #[test]
+ fn env_files_split_on_the_path_separator() {
+ assert_eq!(
+ split_env_files("$PROJECT_DIR$/.env:$PROJECT_DIR$/.env.local", ':').collect::<Vec<_>>(),
+ ["$PROJECT_DIR$/.env", "$PROJECT_DIR$/.env.local"]
+ );
+ assert_eq!(
+ split_env_files(r"C:\p\.env;C:\p\.env.local", ';').collect::<Vec<_>>(),
+ [r"C:\p\.env", r"C:\p\.env.local"]
+ );
+ assert_eq!(split_env_files("", ':').count(), 0);
+ assert_eq!(PATH_SEPARATOR, if cfg!(windows) { ';' } else { ':' });
+ }
+
+ #[test]
+ fn parameters_split_like_idea() {
+ let p = |s: &str| parse_params(s, Quotes::Double);
+ assert_eq!(p(r"--out C:\p\out \\srv\share"), [r"--out", r"C:\p\out", r"\\srv\share"]);
+ assert_eq!(p(r#" a "b c" "" d\"e "f\"g" "#), ["a", "b c", "", r#"d"e"#, r#"f"g"#]);
+ assert_eq!(p("'a b'"), ["'a", "b'"]);
+ assert_eq!(parse_params("-k 'a b' \"c d\"", Quotes::Single), ["-k", "a b", "c d"]);
+ assert!(p(" ").is_empty());
+ }
+
+ #[test]
+ fn macros_and_settings_modules() {
+ let cx =
+ Cx { root: Path::new("/p"), home: Some("/home/me".into()), modules: 1, machine_values: Cell::new(false) };
+ assert_eq!(cx.expand("$PROJECT_DIR$/src $5 a$b").unwrap(), "/p/src $5 a$b");
+ assert_eq!(cx.expand_with("cd $PROJECT_DIR$ && $PATH$", Unknown::Keep).unwrap(), "cd /p && $PATH$");
+ assert!(!cx.machine_values.get());
+ assert_eq!(dot_slash("run.sh".into()), "./run.sh");
+ assert_eq!(dot_slash("../run.sh".into()), "../run.sh");
+ assert_eq!(dot_slash("/opt/run.sh".into()), "/opt/run.sh");
+ assert_eq!(cx.expand("$USER_HOME$/.venvs").unwrap(), "/home/me/.venvs");
+ assert!(cx.machine_values.get());
+ assert_eq!(
+ cx.expand("$MAVEN_REPOSITORY$/x"),
+ Err(SkipReason::PathVariable { variable: "$MAVEN_REPOSITORY$".into() })
+ );
+ assert_eq!(
+ settings_module("src/mysite/settings/dev.py", Path::new("/p"), Path::new("/p/src")),
+ "mysite.settings.dev"
+ );
+ assert_eq!(settings_module("mysite.settings.dev", Path::new("/p"), Path::new("/p")), "mysite.settings.dev");
+ assert_eq!(json_string("\"tests\""), "tests");
+ let several = Cx { modules: 2, ..cx };
+ assert_eq!(
+ several.expand("$MODULE_DIR$/x"),
+ Err(SkipReason::SeveralModules { variable: "$MODULE_DIR$".into() })
+ );
+ assert_eq!(several.expand("$PROJECT_DIR$/x").unwrap(), "/p/x");
+ assert_eq!(strip_quotes("\"not slow\""), "not slow");
+ assert_eq!(strip_quotes("'a or b'"), "a or b");
+ assert_eq!(strip_quotes("plain"), "plain");
+ assert_eq!(regex_escape("adds 1+1 (sum)"), r"adds 1\+1 \(sum\)");
+ }
+}
diff --git a/crates/ide-run/src/import/mod.rs b/crates/ide-run/src/import/mod.rs
index 2961e2134..074bb4057 100644
--- a/crates/ide-run/src/import/mod.rs
+++ b/crates/ide-run/src/import/mod.rs
@@ -1,8 +1,9 @@
//! Run configurations imported on request from another IDE's project files
-//! (`.vscode/launch.json`). Each source turns its entries into [`Entry`]s; [`finish`]
-//! gives them ids, skips names that already exist (so importing again adds nothing
-//! twice) and resolves compound members by name.
+//! (`.vscode/launch.json`, JetBrains `.run/*.run.xml` and `.idea/workspace.xml`). Each source
+//! turns its entries into [`Entry`]s; [`finish`] gives them ids, skips names that already exist
+//! (so importing again adds nothing twice) and resolves compound members by name.
+mod jetbrains;
mod vscode;
use crate::RunConfig;
@@ -12,21 +13,31 @@ use specta::Type;
use std::collections::{BTreeMap, HashMap, HashSet};
use std::path::{Component, Path, PathBuf};
-/// A project file run configurations can be imported from.
+/// Project files run configurations can be imported from.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub enum RunImportSource {
/// VS Code's `.vscode/launch.json`.
Vscode,
+ /// JetBrains IDEs' `.run/*.run.xml`, `.idea/runConfigurations/*.xml` and `.idea/workspace.xml`.
+ Jetbrains,
}
impl RunImportSource {
- pub const ALL: [Self; 1] = [Self::Vscode];
+ pub const ALL: [Self; 2] = [Self::Vscode, Self::Jetbrains];
- /// The file read, relative to the project root.
+ /// The files read, relative to the project root, as the summary names them.
pub fn file(self) -> &'static str {
match self {
Self::Vscode => ".vscode/launch.json",
+ Self::Jetbrains => ".run, .idea",
+ }
+ }
+
+ fn is_present(self, root: &Path) -> bool {
+ match self {
+ Self::Vscode => root.join(self.file()).is_file(),
+ Self::Jetbrains => !jetbrains::files(root).is_empty(),
}
}
}
@@ -62,7 +73,7 @@ pub struct SkippedRunConfig {
pub enum SkipReason {
/// A configuration with this name already exists.
NameTaken,
- /// The debugger type (`type`) has no equivalent here, e.g. `cppdbg`.
+ /// The configuration type has no equivalent here: a VS Code debugger (`cppdbg`), a JetBrains type (`Application`).
UnsupportedType {
#[serde(rename = "type")]
type_: String,
@@ -75,6 +86,14 @@ pub enum SkipReason {
Variable { variable: String },
/// No program, module or command.
NothingToRun,
+ /// A JetBrains path variable with no value here (`$MAVEN_REPOSITORY$`, user-defined ones).
+ PathVariable { variable: String },
+ /// `$MODULE_DIR$` in a project with several modules: which module's directory is unknown.
+ SeveralModules { variable: String },
+ /// A file the configuration needs isn't in the project (Django's `manage.py`).
+ MissingFile { file: String },
+ /// A project file that can't be read, or isn't XML; `name` is the file.
+ InvalidFile { detail: String },
/// A compound member that is neither imported nor an existing configuration.
MissingMember { member: String },
/// Not an object with a name.
@@ -104,22 +123,19 @@ pub fn import(
env: &BTreeMap<String, String>,
) -> IdeResult<RunImport> {
let file = source.file();
- let text = match std::fs::read_to_string(root.join(file)) {
- Ok(t) => t,
- Err(e) if e.kind() == std::io::ErrorKind::NotFound => {
- return Err(IdeError::not_found(format!("{file} not found")));
- }
- Err(e) => return Err(e.into()),
- };
+ if !source.is_present(root) {
+ return Err(IdeError::not_found(format!("{file} not found")));
+ }
let entries = match source {
- RunImportSource::Vscode => vscode::entries(&text, root, env)?,
+ RunImportSource::Vscode => vscode::entries(&std::fs::read_to_string(root.join(file))?, root, env)?,
+ RunImportSource::Jetbrains => jetbrains::entries(root, env)?,
};
Ok(finish(source, entries, existing))
}
-/// The sources whose file exists under `root`.
+/// The sources with files under `root`.
pub fn available(root: &Path) -> Vec<RunImportSource> {
- RunImportSource::ALL.into_iter().filter(|s| root.join(s.file()).is_file()).collect()
+ RunImportSource::ALL.into_iter().filter(|s| s.is_present(root)).collect()
}
fn unique_id(name: &str, ids: &mut HashSet<String>) -> String {
@@ -189,6 +205,107 @@ pub(crate) fn finish(source: RunImportSource, entries: Vec<Entry>, existing: &[R
}
}
+// ------------------------------------------------------------- shared by the sources
+
+/// The variable `name` of `env`; Windows names ignore case (`${env:PATH}` finds `Path`).
+pub(crate) fn env_var(env: &BTreeMap<String, String>, name: &str, windows: bool) -> Option<String> {
+ match env.get(name) {
+ Some(v) => Some(v.clone()),
+ None if windows => env.iter().find(|(k, _)| k.eq_ignore_ascii_case(name)).map(|(_, v)| v.clone()),
+ None => None,
+ }
+}
+
+/// The program's file name without a Windows extension (`npm.cmd` → `npm`).
+pub(crate) fn command_name(cmd: &str) -> &str {
+ let name = cmd.rsplit(['/', '\\']).next().unwrap_or(cmd);
+ name.strip_suffix(".cmd").or_else(|| name.strip_suffix(".exe")).unwrap_or(name)
+}
+
+pub(crate) fn config(name: &str, kind: &str, command: String, args: Vec<String>, debug: Option<&str>) -> RunConfig {
+ RunConfig {
+ id: String::new(),
+ name: name.to_owned(),
+ kind: kind.to_owned(),
+ command,
+ args,
+ cwd: None,
+ env: BTreeMap::new(),
+ detected: false,
+ is_test: false,
+ debug_adapter: debug.map(str::to_owned),
+ allow_parallel: false,
+ extras: crate::RunExtras::default(),
+ }
+}
+
+/// Splits a command line into words: whitespace, `'…'` and `"…"` quoting, backslash escapes
+/// (like `parseArgs` in `src/platform/commandLine.ts`).
+pub(crate) fn split_args(line: &str) -> Vec<String> {
+ let mut out = Vec::new();
+ let mut cur = String::new();
+ let mut has = false;
+ let mut quote: Option<char> = None;
+ let mut chars = line.chars().peekable();
+ while let Some(c) = chars.next() {
+ match quote {
+ Some(q) if c == q => quote = None,
+ Some('"') if c == '\\' && chars.peek().is_some_and(|n| "\"\\$`".contains(*n)) => {
+ cur.extend(chars.next());
+ }
+ Some(_) => cur.push(c),
+ None if c == '\'' || c == '"' => {
+ quote = Some(c);
+ has = true;
+ }
+ None if c == '\\' && chars.peek().is_some() => {
+ cur.extend(chars.next());
+ has = true;
+ }
+ None if c.is_whitespace() => {
+ if has || !cur.is_empty() {
+ out.push(std::mem::take(&mut cur));
+ }
+ has = false;
+ }
+ None => cur.push(c),
+ }
+ }
+ if has || !cur.is_empty() {
+ out.push(cur);
+ }
+ out
+}
+
+/// An absolute path inside the project, written relative to `dir` (the run's working
+/// directory, where the process resolves it); anything else as it is.
+pub(crate) fn path_from(root: &Path, value: String, dir: &Path) -> String {
+ let path = Path::new(&value);
+ if !path.is_absolute() {
+ return value;
+ }
+ let path = normalize(path);
+ if path.starts_with(root) && dir.starts_with(root) { relative_to(&path, dir).unwrap_or(value) } else { value }
+}
+
+/// The project's interpreter (see [`crate::detect::project_python`]), relative to `dir`.
+pub(crate) fn project_python(root: &Path, dir: &Path) -> (String, Vec<String>) {
+ let (exe, lead) = crate::detect::project_python(root);
+ let exe = if exe.contains('/') { path_from(root, root.join(&exe).to_string_lossy().into(), dir) } else { exe };
+ (exe, lead)
+}
+
+/// The working directory `cwd` (absolute) and the configuration's `cwd` (relative to the root, `None` for the root).
+pub(crate) fn working_dir(root: &Path, cwd: &str) -> (PathBuf, Option<PathBuf>) {
+ let abs = normalize(&root.join(cwd));
+ let rel = match abs.strip_prefix(root) {
+ Ok(r) if r.as_os_str().is_empty() => None,
+ Ok(r) => Some(PathBuf::from(relative_to(&abs, root).unwrap_or_else(|| r.to_string_lossy().into()))),
+ Err(_) => Some(abs.clone()),
+ };
+ (abs, rel)
+}
+
/// `path` as written relative to `base` (both absolute, without `..`), with `/` separators;
/// `None` when they don't share a prefix (another drive).
pub(crate) fn relative_to(path: &Path, base: &Path) -> Option<String> {
diff --git a/crates/ide-run/src/import/vscode.rs b/crates/ide-run/src/import/vscode.rs
index 254f3b2d4..608429da0 100644
--- a/crates/ide-run/src/import/vscode.rs
+++ b/crates/ide-run/src/import/vscode.rs
@@ -6,8 +6,11 @@
//! an entry using one that depends on the moment VS Code launches it (`${file}`,
//! `${input:…}`, `${command:…}`) is skipped.
-use super::{Entry, Found, SkipReason, normalize, relative_to};
-use crate::{RunConfig, RunExtras};
+use super::{
+ Entry, Found, SkipReason, command_name, config, env_var, normalize, path_from, project_python, split_args,
+ working_dir,
+};
+use crate::RunConfig;
use ide_core::{IdeError, IdeResult};
use serde_json::{Map, Value};
use std::cell::Cell;
@@ -87,15 +90,6 @@ fn name_of(v: &Value) -> String {
v.get("name").and_then(Value::as_str).unwrap_or_default().trim().to_owned()
}
-/// The variable `name` of `env`; Windows names ignore case (`${env:PATH}` finds `Path`).
-fn env_var(env: &BTreeMap<String, String>, name: &str, windows: bool) -> Option<String> {
- match env.get(name) {
- Some(v) => Some(v.clone()),
- None if windows => env.iter().find(|(k, _)| k.eq_ignore_ascii_case(name)).map(|(_, v)| v.clone()),
- None => None,
- }
-}
-
/// String form of a scalar (`"args": [8000]`, `"env": { "DEBUG": true }`).
fn scalar(v: &Value) -> Option<String> {
match v {
@@ -106,29 +100,6 @@ fn scalar(v: &Value) -> Option<String> {
}
}
-/// The program's file name without a Windows extension (`npm.cmd` → `npm`).
-fn command_name(cmd: &str) -> &str {
- let name = cmd.rsplit(['/', '\\']).next().unwrap_or(cmd);
- name.strip_suffix(".cmd").or_else(|| name.strip_suffix(".exe")).unwrap_or(name)
-}
-
-fn config(name: &str, kind: &str, command: String, args: Vec<String>, debug: Option<&str>) -> RunConfig {
- RunConfig {
- id: String::new(),
- name: name.to_owned(),
- kind: kind.to_owned(),
- command,
- args,
- cwd: None,
- env: BTreeMap::new(),
- detected: false,
- is_test: false,
- debug_adapter: debug.map(str::to_owned),
- allow_parallel: false,
- extras: RunExtras::default(),
- }
-}
-
/// `npm run dev`-style words: an npm configuration's `(command, args)`, `run-script` read as `run`.
fn npm_line(words: &[String]) -> Option<(String, Vec<String>)> {
let (exe, rest) = words.split_first()?;
@@ -142,44 +113,6 @@ fn npm_line(words: &[String]) -> Option<(String, Vec<String>)> {
NPM_COMMANDS.contains(&args.first()?.as_str()).then(|| (exe.clone(), args))
}
-/// Splits a command line into words: whitespace, `'…'` and `"…"` quoting, backslash escapes
-/// (like `parseArgs` in `src/platform/commandLine.ts`).
-fn split_args(line: &str) -> Vec<String> {
- let mut out = Vec::new();
- let mut cur = String::new();
- let mut has = false;
- let mut quote: Option<char> = None;
- let mut chars = line.chars().peekable();
- while let Some(c) = chars.next() {
- match quote {
- Some(q) if c == q => quote = None,
- Some('"') if c == '\\' && chars.peek().is_some_and(|n| "\"\\$`".contains(*n)) => {
- cur.extend(chars.next());
- }
- Some(_) => cur.push(c),
- None if c == '\'' || c == '"' => {
- quote = Some(c);
- has = true;
- }
- None if c == '\\' && chars.peek().is_some() => {
- cur.extend(chars.next());
- has = true;
- }
- None if c.is_whitespace() => {
- if has || !cur.is_empty() {
- out.push(std::mem::take(&mut cur));
- }
- has = false;
- }
- None => cur.push(c),
- }
- }
- if has || !cur.is_empty() {
- out.push(cur);
- }
- out
-}
-
impl Cx<'_> {
/// Replaces the variables in `s`.
fn expand(&self, s: &str) -> Res<String> {
@@ -235,16 +168,7 @@ impl Cx<'_> {
/// An absolute path inside the project, written relative to `dir` (the run's working
/// directory, where the process resolves it); anything else as it is.
fn path_from(&self, value: String, dir: &Path) -> String {
- let path = Path::new(&value);
- if !path.is_absolute() {
- return value;
- }
- let path = normalize(path);
- if path.starts_with(self.root) && dir.starts_with(self.root) {
- relative_to(&path, dir).unwrap_or(value)
- } else {
- value
- }
+ path_from(self.root, value, dir)
}
/// The working directory (absolute) and the configuration's `cwd` (relative to the root).
@@ -252,13 +176,7 @@ impl Cx<'_> {
let Some(cwd) = self.string(obj, "cwd")? else {
return Ok((self.root.to_path_buf(), None));
};
- let abs = normalize(&self.root.join(cwd));
- let rel = match abs.strip_prefix(self.root) {
- Ok(r) if r.as_os_str().is_empty() => None,
- Ok(r) => Some(PathBuf::from(relative_to(&abs, self.root).unwrap_or_else(|| r.to_string_lossy().into()))),
- Err(_) => Some(abs.clone()),
- };
- Ok((abs, rel))
+ Ok(working_dir(self.root, &cwd))
}
/// `env` (a variable set to itself is inherited anyway) and `envFile`.
@@ -341,14 +259,14 @@ impl Cx<'_> {
Some((exe, opts)) => {
let opts = opts.iter().map(|o| self.expand(o)).collect::<Res<Vec<_>>>()?;
if exe.trim().is_empty() || selected(exe) {
- let (exe, mut lead) = self.project_python(&dir);
+ let (exe, mut lead) = project_python(self.root, &dir);
lead.extend(opts);
(exe, lead)
} else {
(self.path_from(self.expand(exe)?, &dir), opts)
}
}
- None => self.project_python(&dir),
+ None => project_python(self.root, &dir),
};
args.extend(self.words(obj, "pythonArgs")?);
let rest = self.words(obj, "args")?;
@@ -375,14 +293,6 @@ impl Cx<'_> {
Ok(c)
}
- /// The project's interpreter (see [`crate::detect::project_python`]), relative to `dir`.
- fn project_python(&self, dir: &Path) -> (String, Vec<String>) {
- let (exe, lead) = crate::detect::project_python(self.root);
- let exe =
- if exe.contains('/') { self.path_from(self.root.join(&exe).to_string_lossy().into(), dir) } else { exe };
- (exe, lead)
- }
-
fn python_attach(&self, name: &str, obj: &Map<String, Value>) -> Res<RunConfig> {
if obj.contains_key("processId") || obj.contains_key("listen") {
return Err(SkipReason::UnsupportedAttach);
diff --git a/crates/ide-run/tests/import_jetbrains.rs b/crates/ide-run/tests/import_jetbrains.rs
new file mode 100644
index 000000000..9bcee229d
--- /dev/null
+++ b/crates/ide-run/tests/import_jetbrains.rs
@@ -0,0 +1,691 @@
+//! JetBrains run configuration import. The fixtures are synthetic: they follow the structure
+//! PyCharm and WebStorm write (`.run/*.run.xml`, `.idea/workspace.xml`), with invented names and values.
+
+use ide_run::RunConfig;
+use ide_run::import::{RunImport, RunImportSource, SkipReason, available, import};
+use std::collections::BTreeMap;
+use std::fs;
+use std::path::{Path, PathBuf};
+
+/// IDEA joins `ENV_FILES` with `File.pathSeparator`.
+const SEP: char = if cfg!(windows) { ';' } else { ':' };
+const VENV_PYTHON: &str = if cfg!(windows) { ".venv/Scripts/python.exe" } else { ".venv/bin/python" };
+
+fn env() -> BTreeMap<String, String> {
+ BTreeMap::from([("HOME".into(), "/home/me".into()), ("USERPROFILE".into(), "/home/me".into())])
+}
+
+fn write(root: &Path, rel: &str, text: &str) {
+ let path = root.join(rel);
+ fs::create_dir_all(path.parent().unwrap()).unwrap();
+ fs::write(path, text).unwrap();
+}
+
+fn run_file(name: &str, body: &str) -> String {
+ format!(
+ "<component name=\"ProjectRunConfigurationManager\">\n {}\n</component>\n",
+ body.replace("name=\"NAME\"", &format!("name=\"{name}\""))
+ )
+}
+
+fn workspace(configs: &str) -> String {
+ format!(
+ "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<project version=\"4\">\n <component name=\"ChangeListManager\" />\n \
+ <component name=\"RunManager\" selected=\"Python.App\">\n{configs}\n <list>\n <item itemvalue=\"Python.App\" />\n \
+ </list>\n </component>\n</project>\n"
+ )
+}
+
+fn import_from(root: &Path, existing: &[RunConfig]) -> RunImport {
+ import(root, RunImportSource::Jetbrains, existing, &env()).unwrap()
+}
+
+fn get<'a>(r: &'a RunImport, name: &str) -> &'a RunConfig {
+ &r.imported.iter().find(|c| c.config.name == name).unwrap_or_else(|| panic!("{name} not imported: {r:#?}")).config
+}
+
+fn ignored<'a>(r: &'a RunImport, name: &str) -> &'a [String] {
+ &r.imported.iter().find(|c| c.config.name == name).unwrap().ignored
+}
+
+fn reason<'a>(r: &'a RunImport, name: &str) -> &'a SkipReason {
+ &r.skipped.iter().find(|s| s.name == name).unwrap_or_else(|| panic!("{name} not skipped: {r:#?}")).reason
+}
+
+fn s(v: &[&str]) -> Vec<String> {
+ v.iter().map(|a| (*a).to_owned()).collect()
+}
+
+fn cwd(c: &RunConfig) -> Option<PathBuf> {
+ c.cwd.as_ref().map(|p| p.as_ref().to_path_buf())
+}
+
+/// A Django project in `src/` with a root virtualenv.
+fn django_project() -> tempfile::TempDir {
+ let dir = tempfile::tempdir().unwrap();
+ write(dir.path(), "src/manage.py", "");
+ write(dir.path(), VENV_PYTHON, "");
+ dir
+}
+
+const PY_COMMON: &str = r#"<module name="shop" />
+ <option name="ENV_FILES" value="" />
+ <option name="INTERPRETER_OPTIONS" value="" />
+ <option name="PARENT_ENVS" value="true" />
+ <option name="SDK_HOME" value="" />
+ <option name="IS_MODULE_SDK" value="true" />
+ <option name="ADD_CONTENT_ROOTS" value="true" />
+ <option name="ADD_SOURCE_ROOTS" value="true" />"#;
+
+#[test]
+fn django_server_and_tests_from_shared_run_files() {
+ let dir = django_project();
+ write(
+ dir.path(),
+ ".run/Server.run.xml",
+ &run_file(
+ "Server",
+ &format!(
+ r#"<configuration default="false" name="NAME" type="Python.DjangoServer" factoryName="Django server">
+ {PY_COMMON}
+ <envs>
+ <env name="PYTHONUNBUFFERED" value="1" />
+ <env name="DJANGO_SETTINGS_MODULE" value="shop.settings.dev" />
+ </envs>
+ <option name="WORKING_DIRECTORY" value="$PROJECT_DIR$/src" />
+ <option name="launchJavascriptDebuger" value="false" />
+ <option name="port" value="8001" />
+ <option name="host" value="0.0.0.0" />
+ <option name="additionalOptions" value="--insecure" />
+ <option name="browserUrl" value="" />
+ <option name="runTestServer" value="false" />
+ <option name="runNoReload" value="true" />
+ <option name="useCustomRunCommand" value="true" />
+ <option name="customRunCommand" value="runserver_plus" />
+ <method v="2" />
+ </configuration>"#
+ ),
+ ),
+ );
+ write(
+ dir.path(),
+ ".run/Tests.run.xml",
+ &run_file(
+ "Tests",
+ &format!(
+ r#"<configuration default="false" name="NAME" type="DjangoTestsConfigurationType">
+ {PY_COMMON}
+ <option name="WORKING_DIRECTORY" value="$PROJECT_DIR$/src" />
+ <EXTENSION ID="PythonCoverageRunConfigurationExtension" runner="coverage.py" />
+ <option name="TARGET" value="orders.tests catalog" />
+ <option name="SETTINGS_FILE" value="$PROJECT_DIR$/src/shop/settings/test.py" />
+ <option name="CUSTOM_SETTINGS" value="true" />
+ <option name="USE_OPTIONS" value="false" />
+ <option name="OPTIONS" value="--keepdb" />
+ <method v="2" />
+ </configuration>"#
+ ),
+ ),
+ );
+ let r = import_from(dir.path(), &[]);
+ assert!(r.skipped.is_empty(), "{r:#?}");
+ assert_eq!(r.file, ".run, .idea");
+
+ let server = get(&r, "Server");
+ assert_eq!(server.kind, "python");
+ assert_eq!(server.command, format!("../{VENV_PYTHON}"));
+ assert_eq!(server.args, s(&["manage.py", "runserver_plus", "0.0.0.0:8001", "--noreload", "--insecure"]));
+ assert_eq!(cwd(server), Some(PathBuf::from("src")));
+ assert_eq!(server.env["DJANGO_SETTINGS_MODULE"], "shop.settings.dev");
+ assert_eq!(server.debug_adapter.as_deref(), Some("debugpy"));
+ assert!(server.extras.include_system_env && !server.extras.local);
+
+ let tests = get(&r, "Tests");
+ assert_eq!(tests.kind, "django-test");
+ assert!(tests.is_test);
+ // OPTIONS count only with USE_OPTIONS, as in PyCharm; the settings file becomes its module.
+ assert_eq!(tests.args, s(&["manage.py", "test", "orders.tests", "catalog", "--settings", "shop.settings.test"]));
+}
+
+#[test]
+fn workspace_run_manager_skips_templates_and_temporary_configurations() {
+ let dir = tempfile::tempdir().unwrap();
+ write(dir.path(), "web/package.json", r#"{ "name": "web", "scripts": { "dev": "vite", "test": "vitest" } }"#);
+ write(dir.path(), "web/pnpm-lock.yaml", "");
+ write(dir.path(), "tests/__init__.py", "");
+ write(dir.path(), "tests/test_money.py", "");
+ write(
+ dir.path(),
+ ".idea/workspace.xml",
+ &workspace(&format!(
+ r#" <configuration default="true" type="PythonConfigurationType" factoryName="Python">
+ {PY_COMMON}
+ <option name="SCRIPT_NAME" value="" />
+ <method v="2" />
+ </configuration>
+ <configuration name="build" type="js.build_tools.npm" temporary="true" nameIsGenerated="true">
+ <package-json value="$PROJECT_DIR$/web/package.json" />
+ <command value="run" />
+ <scripts><script value="build" /></scripts>
+ <node-interpreter value="project" />
+ <envs />
+ <method v="2" />
+ </configuration>
+ <configuration name="App" type="PythonConfigurationType" factoryName="Python" folderName="Tools" singleton="false">
+ <module name="shop" />
+ <option name="ENV_FILES" value="$PROJECT_DIR$/.env{SEP}$PROJECT_DIR$/.env.local" />
+ <option name="INTERPRETER_OPTIONS" value="-X dev" />
+ <option name="PARENT_ENVS" value="false" />
+ <envs><env name="LOG_LEVEL" value="debug" /></envs>
+ <option name="SDK_HOME" value="$USER_HOME$/.virtualenvs/shop/bin/python" />
+ <option name="WORKING_DIRECTORY" value="$PROJECT_DIR$" />
+ <option name="IS_MODULE_SDK" value="false" />
+ <option name="RUN_TOOL" value="" />
+ <option name="SCRIPT_NAME" value="shop.tools.sync" />
+ <option name="PARAMETERS" value="--since 2024-01-01 --out $PROJECT_DIR$/out" />
+ <option name="SHOW_COMMAND_LINE" value="false" />
+ <option name="EMULATE_TERMINAL" value="true" />
+ <option name="MODULE_MODE" value="true" />
+ <option name="REDIRECT_INPUT" value="false" />
+ <option name="INPUT_FILE" value="" />
+ <method v="2">
+ <option name="RunConfigurationTask" enabled="true" run_configuration_name="Migrate" run_configuration_type="PythonConfigurationType" />
+ </method>
+ </configuration>
+ <configuration name="Unit" type="tests" factoryName="py.test">
+ {PY_COMMON}
+ <option name="WORKING_DIRECTORY" value="" />
+ <option name="_new_keywords" value="&quot;not slow&quot;" />
+ <option name="_new_parameters" value="&quot;&quot;" />
+ <option name="_new_additionalArguments" value="&quot;-x --tb=short&quot;" />
+ <option name="_new_target" value="&quot;$PROJECT_DIR$/tests/test_orders.py&quot;" />
+ <option name="_new_targetType" value="&quot;PATH&quot;" />
+ <method v="2" />
+ </configuration>
+ <configuration name="Case" type="tests" factoryName="py.test">
+ {PY_COMMON}
+ <option name="_new_parameters" value="&quot;eur-2&quot;" />
+ <option name="_new_target" value="&quot;tests.test_money.test_round&quot;" />
+ <option name="_new_targetType" value="&quot;PYTHON&quot;" />
+ <method v="2" />
+ </configuration>
+ <configuration name="Path params" type="tests" factoryName="py.test">
+ {PY_COMMON}
+ <option name="_new_keywords" value="&quot;'slow or fast'&quot;" />
+ <option name="_new_parameters" value="&quot;eur-2&quot;" />
+ <option name="_new_target" value="&quot;$PROJECT_DIR$/tests/test_money.py&quot;" />
+ <option name="_new_targetType" value="&quot;PATH&quot;" />
+ <method v="2" />
+ </configuration>
+ <configuration name="Custom" type="tests" factoryName="py.test">
+ {PY_COMMON}
+ <option name="_new_keywords" value="&quot;slow&quot;" />
+ <option name="_new_additionalArguments" value="&quot;tests/a.py --maxfail=2&quot;" />
+ <option name="_new_target" value="&quot;&quot;" />
+ <option name="_new_targetType" value="&quot;CUSTOM&quot;" />
+ <method v="2" />
+ </configuration>
+ <configuration name="Unittests in tests" type="tests" factoryName="Unittests">
+ {PY_COMMON}
+ <option name="_new_target" value="&quot;tests&quot;" />
+ <method v="2" />
+ </configuration>
+ <configuration name="dev" type="js.build_tools.npm">
+ <package-json value="$PROJECT_DIR$/web/package.json" />
+ <command value="run" />
+ <scripts><script value="dev" /><script value="test" /></scripts>
+ <arguments value="--host 0.0.0.0" />
+ <node-interpreter value="/opt/node22/bin/node" />
+ <envs><env name="VITE_API" value="http://localhost:8000" /></envs>
+ <method v="2" />
+ </configuration>
+ <configuration name="Main" type="Application" factoryName="Application">
+ <option name="MAIN_CLASS_NAME" value="shop.Main" />
+ <method v="2" />
+ </configuration>"#
+ )),
+ );
+ let r = import_from(dir.path(), &[]);
+ let names: Vec<&str> = r.imported.iter().map(|c| c.config.name.as_str()).collect();
+ assert_eq!(names, ["App", "Unit", "Case", "Path params", "Custom", "dev"]);
+
+ let app = get(&r, "App");
+ // `$USER_HOME$` is this machine's: the configuration goes to run.local.toml.
+ assert!(app.extras.local);
+ assert_eq!(app.command, "/home/me/.virtualenvs/shop/bin/python");
+ assert_eq!(app.args, s(&["-X", "dev", "-m", "shop.tools.sync", "--since", "2024-01-01", "--out", "out"]));
+ assert_eq!(app.extras.env_files, s(&[".env", ".env.local"]));
+ assert!(!app.extras.include_system_env && app.extras.emulate_terminal && app.allow_parallel);
+ assert_eq!(app.extras.folder.as_deref(), Some("Tools"));
+ assert_eq!(ignored(&r, "App"), ["before launch"]);
+
+ let unit = get(&r, "Unit");
+ assert_eq!(unit.kind, "pytest");
+ assert!(unit.is_test);
+ let py = if cfg!(windows) { "python" } else { "python3" };
+ assert_eq!(unit.command, py);
+ assert_eq!(unit.args, s(&["-m", "pytest", "tests/test_orders.py", "-k", "not slow", "-x", "--tb=short"]));
+ // intellij-community PyTest.kt: parameters follow only a Python target; keywords lose their
+ // quotes and are left out for a custom target; additional arguments split like a command line.
+ assert_eq!(get(&r, "Case").args, s(&["-m", "pytest", "tests/test_money.py::test_round[eur-2]"]));
+ assert_eq!(get(&r, "Path params").args, s(&["-m", "pytest", "tests/test_money.py", "-k", "slow or fast"]));
+ assert_eq!(get(&r, "Custom").args, s(&["-m", "pytest", "tests/a.py", "--maxfail=2"]));
+
+ assert_eq!(reason(&r, "Unittests in tests"), &SkipReason::UnsupportedType { type_: "tests (Unittests)".into() });
+ assert_eq!(reason(&r, "Main"), &SkipReason::UnsupportedType { type_: "Application".into() });
+
+ let dev = get(&r, "dev");
+ assert_eq!((dev.kind.as_str(), dev.command.as_str()), ("npm", "pnpm"));
+ 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"]);
+ // Neither the template nor the temporary `build` is listed as skipped.
+ assert_eq!(r.skipped.len(), 2);
+}
+
+#[test]
+fn javascript_tests_node_shell_and_compounds() {
+ let dir = tempfile::tempdir().unwrap();
+ write(
+ dir.path(),
+ ".idea/workspace.xml",
+ &workspace(
+ r#" <configuration name="cart total" type="JavaScriptTestRunnerVitest">
+ <node-interpreter value="project" />
+ <vitest-package value="$PROJECT_DIR$/web/node_modules/vitest" />
+ <working-dir value="$PROJECT_DIR$/web" />
+ <vitest-options value="--reporter verbose" />
+ <envs />
+ <scope-kind value="TEST" />
+ <test-file value="$PROJECT_DIR$/web/src/cart.test.ts" />
+ <test-names>
+ <test-name value="cart" />
+ <test-name value="total (with tax)" />
+ </test-names>
+ <method v="2" />
+ </configuration>
+ <configuration name="api tests" type="JavaScriptTestRunnerJest">
+ <node-interpreter value="project" />
+ <jest-package value="$PROJECT_DIR$/node_modules/jest" />
+ <working-dir value="$PROJECT_DIR$" />
+ <jest-options value="--runInBand" />
+ <config-file value="$PROJECT_DIR$/jest.config.js" />
+ <envs><env name="NODE_ENV" value="test" /></envs>
+ <scope-kind value="DIRECTORY" />
+ <test-directory value="$PROJECT_DIR$/api/__tests__" />
+ <method v="2" />
+ </configuration>
+ <configuration name="server.js" type="NodeJSConfigurationType" path-to-js-file="server/index.js" working-dir="$PROJECT_DIR$" node-parameters="--enable-source-maps" application-parameters="--port 3000">
+ <envs><env name="PORT" value="3000" /></envs>
+ <method v="2" />
+ </configuration>
+ <configuration name="seed" type="ShConfigurationType">
+ <option name="SCRIPT_TEXT" value="" />
+ <option name="INDEPENDENT_SCRIPT_PATH" value="true" />
+ <option name="SCRIPT_PATH" value="$PROJECT_DIR$/scripts/seed.sh" />
+ <option name="SCRIPT_OPTIONS" value="--small" />
+ <option name="INDEPENDENT_SCRIPT_WORKING_DIRECTORY" value="true" />
+ <option name="SCRIPT_WORKING_DIRECTORY" value="$PROJECT_DIR$" />
+ <option name="INDEPENDENT_INTERPRETER_PATH" value="true" />
+ <option name="INTERPRETER_PATH" value="/bin/bash" />
+ <option name="INTERPRETER_OPTIONS" value="-e" />
+ <option name="EXECUTE_IN_TERMINAL" value="true" />
+ <option name="EXECUTE_SCRIPT_FILE" value="true" />
+ <envs />
+ <method v="2" />
+ </configuration>
+ <configuration name="clean" type="ShConfigurationType">
+ <option name="SCRIPT_TEXT" value="cd $PROJECT_DIR$/web &amp;&amp; npm run dev &amp;&amp; echo $HOME$PATH $1 $HOME" />
+ <option name="EXECUTE_IN_TERMINAL" value="false" />
+ <option name="EXECUTE_SCRIPT_FILE" value="false" />
+ <envs />
+ <method v="2" />
+ </configuration>
+ <configuration name="Stack" type="CompoundRunConfigurationType">
+ <toRun name="server.js" type="NodeJSConfigurationType" />
+ <toRun name="seed" type="ShConfigurationType" />
+ <method v="2" />
+ </configuration>
+ <configuration name="Broken" type="CompoundRunConfigurationType">
+ <toRun name="Gone" type="NodeJSConfigurationType" />
+ <method v="2" />
+ </configuration>"#,
+ ),
+ );
+ let r = import_from(dir.path(), &[]);
+
+ let vitest = get(&r, "cart total");
+ assert_eq!((vitest.kind.as_str(), vitest.command.as_str()), ("node", "npx"));
+ assert_eq!(
+ vitest.args,
+ s(&["vitest", "run", "--reporter", "verbose", "src/cart.test.ts", "-t", r"^cart total \(with tax\)$"])
+ );
+ assert_eq!(cwd(vitest), Some(PathBuf::from("web")));
+ assert!(vitest.is_test);
+
+ let jest = get(&r, "api tests");
+ assert_eq!(jest.args, s(&["jest", "--config", "jest.config.js", "--runInBand", "api/__tests__"]));
+ assert_eq!(jest.env["NODE_ENV"], "test");
+
+ let node = get(&r, "server.js");
+ assert_eq!((node.kind.as_str(), node.command.as_str()), ("node", "node"));
+ assert_eq!(node.args, s(&["--enable-source-maps", "server/index.js", "--port", "3000"]));
+ assert_eq!(node.debug_adapter.as_deref(), Some("js-debug"));
+
+ let seed = get(&r, "seed");
+ assert_eq!((seed.kind.as_str(), seed.command.as_str()), ("shell", "/bin/bash"));
+ assert_eq!(seed.args, s(&["-e", "scripts/seed.sh", "--small"]));
+ assert_eq!(seed.extras.params["mode"], "file");
+ assert_eq!(seed.extras.params["path"], "scripts/seed.sh");
+ assert!(seed.extras.emulate_terminal);
+
+ // Script text is the shell's own: `$HOME$` there is not a macro.
+ let clean = get(&r, "clean");
+ // IDEA writes `$PROJECT_DIR$` into script text too; the shell's own `$HOME`, `$1`, `$HOME$PATH` stay.
+ let root = dir.path().to_string_lossy();
+ let line = format!("cd {root}/web && npm run dev && echo $HOME$PATH $1 $HOME");
+ assert_eq!(clean.command, line);
+ assert_eq!(clean.extras.params["script"], line);
+ assert_eq!(clean.extras.params["mode"], "text");
+ assert!(!clean.extras.local);
+
+ let stack = get(&r, "Stack");
+ assert_eq!(stack.kind, "compound");
+ assert_eq!(stack.extras.compound, s(&["user:server-js", "user:seed"]));
+ assert_eq!(reason(&r, "Broken"), &SkipReason::MissingMember { member: "Gone".into() });
+}
+
+#[test]
+fn shared_files_win_and_reimport_adds_nothing() {
+ let dir = django_project();
+ let tests = |name: &str, target: &str| {
+ run_file(
+ name,
+ &format!(
+ r#"<configuration name="NAME" type="DjangoTestsConfigurationType">
+ {PY_COMMON}
+ <option name="WORKING_DIRECTORY" value="$PROJECT_DIR$/src" />
+ <option name="TARGET" value="{target}" />
+ <method v="2" />
+ </configuration>"#
+ ),
+ )
+ };
+ write(dir.path(), ".run/Tests.run.xml", &tests("Tests", "shared"));
+ write(dir.path(), ".idea/runConfigurations/Other.xml", &tests("Other", "other"));
+ let mine = tests("Tests", "mine").replace("ProjectRunConfigurationManager", "RunManager");
+ write(dir.path(), ".idea/workspace.xml", &format!("<project version=\"4\">{mine}</project>"));
+ write(dir.path(), ".run/Broken.run.xml", "<component name=\"ProjectRunConfigurationManager\"><configuration");
+
+ let r = import_from(dir.path(), &[]);
+ assert_eq!(get(&r, "Tests").args.last().map(String::as_str), Some("shared"));
+ assert_eq!(get(&r, "Other").args.last().map(String::as_str), Some("other"));
+ assert_eq!(reason(&r, "Tests"), &SkipReason::NameTaken);
+ // The parser's message says where the file breaks.
+ assert!(matches!(reason(&r, ".run/Broken.run.xml"), SkipReason::InvalidFile { detail } if !detail.is_empty()));
+
+ let existing: Vec<RunConfig> = r.imported.iter().map(|c| c.config.clone()).collect();
+ assert!(import_from(dir.path(), &existing).imported.is_empty());
+}
+
+#[test]
+fn macros_env_files_and_missing_manage_py() {
+ let dir = tempfile::tempdir().unwrap();
+ write(
+ dir.path(),
+ ".run/Sync.run.xml",
+ &run_file(
+ "Sync",
+ &format!(
+ r#"<configuration name="NAME" type="PythonConfigurationType" factoryName="Python">
+ {PY_COMMON}
+ <option name="WORKING_DIRECTORY" value="$MODULE_DIR$/jobs" />
+ <option name="SCRIPT_NAME" value="$MODULE_WORKING_DIR$/jobs/sync.py" />
+ <option name="PARAMETERS" value="" />
+ <extension name="net.ashald.envfile">
+ <option name="IS_ENABLED" value="true" />
+ <option name="IS_SUBST" value="false" />
+ <ENTRIES>
+ <ENTRY IS_ENABLED="true" PARSER="runconfig" IS_EXECUTABLE="false" />
+ <ENTRY IS_ENABLED="true" PARSER="env" IS_EXECUTABLE="false" PATH=".env" />
+ <ENTRY IS_ENABLED="false" PARSER="env" IS_EXECUTABLE="false" PATH=".env.off" />
+ <ENTRY IS_ENABLED="true" PARSER="yaml" IS_EXECUTABLE="false" PATH="secrets.yml" />
+ </ENTRIES>
+ </extension>
+ <method v="2" />
+ </configuration>"#
+ ),
+ ),
+ );
+ write(
+ dir.path(),
+ ".run/Repo.run.xml",
+ &run_file(
+ "Repo",
+ &format!(
+ r#"<configuration name="NAME" type="PythonConfigurationType" factoryName="Python">
+ {PY_COMMON}
+ <option name="SCRIPT_NAME" value="$MAVEN_REPOSITORY$/tool.py" />
+ <method v="2" />
+ </configuration>"#
+ ),
+ ),
+ );
+ write(
+ dir.path(),
+ ".run/Server.run.xml",
+ &run_file(
+ "Server",
+ &format!(
+ r#"<configuration name="NAME" type="Python.DjangoServer" factoryName="Django server">
+ {PY_COMMON}
+ <method v="2" />
+ </configuration>"#
+ ),
+ ),
+ );
+ let r = import_from(dir.path(), &[]);
+ let sync = get(&r, "Sync");
+ assert_eq!(cwd(sync), Some(PathBuf::from("jobs")));
+ assert_eq!(sync.args, s(&["sync.py"]));
+ assert_eq!(sync.extras.env_files, s(&[".env"]));
+ assert_eq!(ignored(&r, "Sync"), ["EnvFile secrets.yml"]);
+ assert!(!sync.extras.local);
+ assert_eq!(reason(&r, "Repo"), &SkipReason::PathVariable { variable: "$MAVEN_REPOSITORY$".into() });
+ assert_eq!(reason(&r, "Server"), &SkipReason::MissingFile { file: "manage.py".into() });
+}
+
+#[test]
+fn sources_are_offered_when_their_files_exist() {
+ let dir = tempfile::tempdir().unwrap();
+ assert!(available(dir.path()).is_empty());
+ assert!(import(dir.path(), RunImportSource::Jetbrains, &[], &env()).is_err());
+ // IDEA writes a workspace.xml everywhere: without configurations to import there's nothing to offer.
+ write(dir.path(), ".idea/workspace.xml", &workspace(""));
+ assert!(available(dir.path()).is_empty());
+ write(
+ dir.path(),
+ ".idea/workspace.xml",
+ &workspace(
+ r#"<configuration default="true" type="PythonConfigurationType" factoryName="Python" />
+ <configuration name="once" type="js.build_tools.npm" temporary="true" />"#,
+ ),
+ );
+ assert!(available(dir.path()).is_empty());
+ write(dir.path(), ".idea/workspace.xml", &workspace(r#"<configuration name="App" type="Application" />"#));
+ assert_eq!(available(dir.path()), [RunImportSource::Jetbrains]);
+ write(dir.path(), ".vscode/launch.json", "{}");
+ assert_eq!(available(dir.path()), [RunImportSource::Vscode, RunImportSource::Jetbrains]);
+ assert_eq!(
+ reason(&import_from(dir.path(), &[]), "App"),
+ &SkipReason::UnsupportedType { type_: "Application".into() }
+ );
+}
+
+#[test]
+fn imported_configurations_round_trip_through_run_toml() {
+ let dir = django_project();
+ write(
+ dir.path(),
+ ".run/Seed.run.xml",
+ &run_file(
+ "Seed",
+ r#"<configuration name="NAME" type="ShConfigurationType" folderName="Data">
+ <option name="SCRIPT_PATH" value="$PROJECT_DIR$/scripts/seed.sh" />
+ <option name="INTERPRETER_PATH" value="" />
+ <option name="EXECUTE_SCRIPT_FILE" value="true" />
+ <envs />
+ <method v="2" />
+ </configuration>"#,
+ ),
+ );
+ let r = import_from(dir.path(), &[]);
+ let configs: Vec<RunConfig> = r.imported.iter().map(|c| c.config.clone()).collect();
+ assert_eq!(configs[0].command, "./scripts/seed.sh");
+ ide_run::save_user_configs(dir.path(), &configs).unwrap();
+ assert_eq!(ide_run::load_user_configs(dir.path()).unwrap(), configs);
+}
+
+#[test]
+fn module_macros_need_a_single_module_project() {
+ let launch = |root: &Path| {
+ write(
+ root,
+ ".run/Job.run.xml",
+ &run_file(
+ "Job",
+ &format!(
+ r#"<configuration name="NAME" type="PythonConfigurationType" factoryName="Python">
+ {PY_COMMON}
+ <option name="SCRIPT_NAME" value="$MODULE_DIR$/job.py" />
+ <method v="2" />
+ </configuration>"#
+ ),
+ ),
+ )
+ };
+ let modules = |names: &[&str]| {
+ let items: String = names
+ .iter()
+ .map(|n| format!("<module fileurl=\"file://$PROJECT_DIR$/{n}.iml\" filepath=\"$PROJECT_DIR$/{n}.iml\" />"))
+ .collect();
+ format!(
+ "<project version=\"4\"><component name=\"ProjectModuleManager\"><modules>{items}</modules></component></project>"
+ )
+ };
+ let one = tempfile::tempdir().unwrap();
+ launch(one.path());
+ write(one.path(), ".idea/modules.xml", &modules(&["shop"]));
+ assert_eq!(get(&import_from(one.path(), &[]), "Job").args, s(&["job.py"]));
+
+ let two = tempfile::tempdir().unwrap();
+ launch(two.path());
+ write(two.path(), ".idea/modules.xml", &modules(&["shop", "worker"]));
+ let r = import_from(two.path(), &[]);
+ assert_eq!(reason(&r, "Job"), &SkipReason::SeveralModules { variable: "$MODULE_DIR$".into() });
+}
+
+#[test]
+fn pytest_python_targets_become_node_ids() {
+ let dir = tempfile::tempdir().unwrap();
+ write(dir.path(), "tests/__init__.py", "");
+ write(dir.path(), "tests/test_money.py", "");
+ write(dir.path(), "api/tests/test_views.py", "");
+ write(dir.path(), "pkg/sub/__init__.py", "");
+ let case = |name: &str, target: &str, params: &str, wd: &str| {
+ format!(
+ r#"<configuration name="{name}" type="tests" factoryName="py.test">
+ {PY_COMMON}
+ <option name="WORKING_DIRECTORY" value="{wd}" />
+ <option name="_new_parameters" value="&quot;{params}&quot;" />
+ <option name="_new_target" value="&quot;{target}&quot;" />
+ <option name="_new_targetType" value="&quot;PYTHON&quot;" />
+ <method v="2" />
+ </configuration>"#
+ )
+ };
+ let configs = [
+ case("Function", "tests.test_money.test_round", "", ""),
+ case("Method", "tests.test_money.TestRound.test_eur", "", ""),
+ case("Parametrized", "tests.test_money.TestRound.test_eur", "eur-2", ""),
+ case("Module", "tests.test_money", "", ""),
+ case("Package", "pkg.sub", "", ""),
+ case("From api", "tests.test_views.test_list", "", "$PROJECT_DIR$/api"),
+ case("Root from api", "tests.test_money.test_round", "", "$PROJECT_DIR$/api/tests"),
+ case("Installed", "somelib.tests.test_core", "x", ""),
+ ];
+ write(dir.path(), ".idea/workspace.xml", &workspace(&configs.join("\n")));
+ let r = import_from(dir.path(), &[]);
+ let target = |name: &str| get(&r, name).args[2..].to_vec();
+ assert_eq!(target("Function"), s(&["tests/test_money.py::test_round"]));
+ assert_eq!(target("Method"), s(&["tests/test_money.py::TestRound::test_eur"]));
+ assert_eq!(target("Parametrized"), s(&["tests/test_money.py::TestRound::test_eur[eur-2]"]));
+ assert_eq!(target("Module"), s(&["tests/test_money.py"]));
+ assert_eq!(target("Package"), s(&["pkg/sub"]));
+ // From the working directory first, then the project root (relative to the working directory).
+ assert_eq!(target("From api"), s(&["tests/test_views.py::test_list"]));
+ assert_eq!(target("Root from api"), s(&["../../tests/test_money.py::test_round"]));
+ // Not in the project: pytest looks the module up by name; the parameters can't follow it.
+ assert_eq!(target("Installed"), s(&["--pyargs", "somelib.tests.test_core"]));
+ assert_eq!(ignored(&r, "Installed"), ["_new_parameters"]);
+}
+
+#[test]
+fn flags_defaults_inherited_variables_and_nested_django_tests() {
+ let dir = tempfile::tempdir().unwrap();
+ write(dir.path(), "backend/manage.py", "");
+ write(
+ dir.path(),
+ ".idea/workspace.xml",
+ &workspace(&format!(
+ r#" <configuration name="Old script" type="ShConfigurationType">
+ <option name="SCRIPT_PATH" value="$PROJECT_DIR$/run.sh" />
+ <option name="INTERPRETER_PATH" value="" />
+ <envs><env name="PYTHONPATH" value="$PYTHONPATH$:src" /><env name="TAG" value="$NOT_SET$" /></envs>
+ <method v="2" />
+ </configuration>
+ <configuration name="Tool off" type="PythonConfigurationType" factoryName="Python">
+ {PY_COMMON}
+ <option name="RUN_TOOL" value="false" />
+ <option name="SCRIPT_NAME" value="app.py" />
+ <method v="2" />
+ </configuration>
+ <configuration name="Tool on" type="PythonConfigurationType" factoryName="Python">
+ {PY_COMMON}
+ <option name="RUN_TOOL" value="true" />
+ <option name="SCRIPT_NAME" value="app.py" />
+ <method v="2" />
+ </configuration>
+ <configuration name="Backend tests" type="DjangoTestsConfigurationType">
+ {PY_COMMON}
+ <option name="WORKING_DIRECTORY" value="" />
+ <option name="TARGET" value="orders" />
+ <method v="2" />
+ </configuration>"#
+ )),
+ );
+ let mut env = env();
+ env.insert("PYTHONPATH".into(), "/opt/lib".into());
+ let r = import(dir.path(), RunImportSource::Jetbrains, &[], &env).unwrap();
+
+ // Written before EXECUTE_SCRIPT_FILE / EXECUTE_IN_TERMINAL existed: both default to true.
+ let old = get(&r, "Old script");
+ // Run directly: `./run.sh`, not a `run.sh` looked up on the PATH.
+ assert_eq!(old.command, "./run.sh");
+ assert_eq!(old.extras.params["path"], "./run.sh");
+ assert!(old.extras.emulate_terminal);
+ // Environment values as written, as the Shell and Python types pass them: `$NAME$` isn't inlined,
+ // even for a variable runs inherit, and doesn't make the configuration this machine's.
+ assert_eq!(old.env["PYTHONPATH"], "$PYTHONPATH$:src");
+ assert_eq!(old.env["TAG"], "$NOT_SET$");
+ assert!(!old.extras.local);
+
+ assert!(ignored(&r, "Tool off").is_empty());
+ assert_eq!(ignored(&r, "Tool on"), ["RUN_TOOL"]);
+
+ // `backend/manage.py test` from the root: a Python run, still a test configuration.
+ let tests = get(&r, "Backend tests");
+ assert_eq!((tests.kind.as_str(), tests.is_test), ("python", true));
+ assert_eq!(tests.args[..3], s(&["backend/manage.py", "test", "orders"]));
+}
diff --git a/src/bindings.ts b/src/bindings.ts
index 7c5972333..b8048c354 100644
--- a/src/bindings.ts
+++ b/src/bindings.ts
@@ -5820,10 +5820,12 @@ export type RunId = number;
/** What an import found: configurations to add and entries left out, with the reason. */
export type RunImport = RunImport_Serialize | RunImport_Deserialize;
-/** A project file run configurations can be imported from. */
+/** Project files run configurations can be imported from. */
export type RunImportSource =
/** VS Code's `.vscode/launch.json`. */
-"vscode";
+"vscode" |
+/** JetBrains IDEs' `.run/*.run.xml`, `.idea/runConfigurations/*.xml` and `.idea/workspace.xml`. */
+"jetbrains";
/** What an import found: configurations to add and entries left out, with the reason. */
export type RunImport_Deserialize = {
@@ -6205,7 +6207,7 @@ export type SignatureHelp = {
export type SkipReason =
/** A configuration with this name already exists. */
{ kind: "nameTaken" } |
-/** The debugger type (`type`) has no equivalent here, e.g. `cppdbg`. */
+/** The configuration type has no equivalent here: a VS Code debugger (`cppdbg`), a JetBrains type (`Application`). */
{ kind: "unsupportedType"; type: string } |
/** A `request` other than `launch` and `attach`. */
{ kind: "unsupportedRequest"; request: string } |
@@ -6215,6 +6217,14 @@ export type SkipReason =
{ kind: "variable"; variable: string } |
/** No program, module or command. */
{ kind: "nothingToRun" } |
+/** A JetBrains path variable with no value here (`$MAVEN_REPOSITORY$`, user-defined ones). */
+{ kind: "pathVariable"; variable: string } |
+/** `$MODULE_DIR$` in a project with several modules: which module's directory is unknown. */
+{ kind: "severalModules"; variable: string } |
+/** A file the configuration needs isn't in the project (Django's `manage.py`). */
+{ kind: "missingFile"; file: string } |
+/** A project file that can't be read, or isn't XML; `name` is the file. */
+{ kind: "invalidFile"; detail: string } |
/** A compound member that is neither imported nor an existing configuration. */
{ kind: "missingMember"; member: string } |
/** Not an object with a name. */
diff --git a/src/features/run/importAction.test.tsx b/src/features/run/importAction.test.tsx
index 645e73a20..9a1cdf40d 100644
--- a/src/features/run/importAction.test.tsx
+++ b/src/features/run/importAction.test.tsx
@@ -77,4 +77,17 @@ describe("Find Action › Import Run Configurations from .vscode/launch.json", (
expect(ipc.runImportConfigs).not.toHaveBeenCalled();
expect(notes.at(-1)).toMatchObject({ level: "info", title: "This project has no .vscode/launch.json" });
});
+
+ it("imports JetBrains run configurations the same way", async () => {
+ ipc.runImportSources.mockImplementation(async () => ok(["vscode"]));
+ await act(() => executeAction("run.importJetbrains"));
+ expect(useRun.getState().editorOpen).toBe(false);
+ expect(notes.at(-1)).toMatchObject({ title: "This project has no JetBrains run configurations (.run, .idea)" });
+
+ ipc.runImportSources.mockImplementation(async () => ok(["jetbrains"]));
+ render(<EditConfigsOverlay />);
+ await act(() => executeAction("run.importJetbrains"));
+ expect(await screen.findByRole("treeitem", { name: /^Django/ })).toBeInTheDocument();
+ expect(ipc.runImportConfigs).toHaveBeenCalledWith("jetbrains", []);
+ });
});
diff --git a/src/features/run/importConfigs.test.tsx b/src/features/run/importConfigs.test.tsx
index a2fb79c0a..e6be54ca5 100644
--- a/src/features/run/importConfigs.test.tsx
+++ b/src/features/run/importConfigs.test.tsx
@@ -65,8 +65,33 @@ describe("import summary", () => {
expect(
screen.getByText("Skipped 'Current file': Uses ${file}, which is known only when VS Code starts it"),
).toBeInTheDocument();
- expect(screen.getByText("Skipped 'Chrome': The chrome debugger has no equivalent here")).toBeInTheDocument();
+ expect(screen.getByText("Skipped 'Chrome': Type 'chrome' has no equivalent here")).toBeInTheDocument();
expect(screen.getByText("Skipped 'Unnamed': Not a configuration with a name")).toBeInTheDocument();
+ cleanup();
+ const files = importSummary(
+ result({
+ imported: [],
+ skipped: [
+ { name: "Server", reason: { kind: "missingFile", file: "manage.py" } },
+ { name: ".run/Broken.run.xml", reason: { kind: "invalidFile", detail: "unclosed element" } },
+ { name: "Repo", reason: { kind: "pathVariable", variable: "$MAVEN_REPOSITORY$" } },
+ { name: "Job", reason: { kind: "severalModules", variable: "$MODULE_DIR$" } },
+ ],
+ }),
+ );
+ render(<>{files.body}</>);
+ expect(screen.getByText("Skipped 'Server': manage.py isn't in the project")).toBeInTheDocument();
+ expect(
+ screen.getByText("Skipped '.run/Broken.run.xml': The file can't be read: unclosed element"),
+ ).toBeInTheDocument();
+ expect(
+ screen.getByText("Skipped 'Repo': Uses $MAVEN_REPOSITORY$, a path variable with no value here"),
+ ).toBeInTheDocument();
+ expect(
+ screen.getByText("Skipped 'Job': Uses $MODULE_DIR$, and the project has several modules"),
+ ).toBeInTheDocument();
+ cleanup();
+ render(<>{s.body}</>);
expect(screen.getByText("Left out of 'Django': justMyCode")).toBeInTheDocument();
expect(screen.getByText("Click OK or Apply to save them.")).toBeInTheDocument();
cleanup();
@@ -88,7 +113,7 @@ describe("import summary", () => {
await setLocale("zh");
expect(importSummary(two).title).toBe("已从 .vscode/launch.json 导入 2 个运行配置");
render(<>{importSummary(result({ imported: [] })).body}</>);
- expect(screen.getByText("已跳过 'Chrome':此处没有与 chrome 调试器对应的配置类型")).toBeInTheDocument();
+ expect(screen.getByText("已跳过 'Chrome':此处没有与类型 'chrome' 对应的配置")).toBeInTheDocument();
cleanup();
});
});
@@ -153,6 +178,14 @@ describe("Run/Debug Configurations › Import from .vscode/launch.json", () => {
expect(screen.queryByRole("treeitem", { name: /^Django/ })).not.toBeInTheDocument();
});
+ it("offers one link per source with files", async () => {
+ ipc.runImportSources.mockImplementation(async () => ok(["vscode", "jetbrains"]));
+ render(<EditConfigsOverlay />);
+ expect(await screen.findByRole("button", { name: "Import from .vscode/launch.json" })).toBeInTheDocument();
+ fireEvent.click(screen.getByRole("button", { name: "Import from JetBrains run configurations" }));
+ await waitFor(() => expect(ipc.runImportConfigs).toHaveBeenCalledWith("jetbrains", [detected]));
+ });
+
it("imports again when asked while the dialog is open", async () => {
render(<EditConfigsOverlay />);
await screen.findByRole("button", { name: "Import from .vscode/launch.json" });
diff --git a/src/features/run/importConfigs.tsx b/src/features/run/importConfigs.tsx
index 2ac30f42c..50d2b494f 100644
--- a/src/features/run/importConfigs.tsx
+++ b/src/features/run/importConfigs.tsx
@@ -1,28 +1,53 @@
/**
- * "Import from .vscode/launch.json" in Run/Debug Configurations: the backend maps the file's
- * entries (`ide-run` `import`), the configurations join the dialog's draft and are saved with
- * it on OK / Apply. A notification says how many came in and why the others were left out.
+ * "Import from .vscode/launch.json" / "Import from JetBrains run configurations" in Run/Debug
+ * Configurations and Find Action: the backend maps the files' entries (`ide-run` `import`), the
+ * configurations join the dialog's draft and are saved with it on OK / Apply. A notification says
+ * how many came in and why the others were left out.
*/
import type { ReactNode } from "react";
import { tx } from "@/platform/i18n";
import { call, commands, type RunConfig, type RunImport, type RunImportSource, type SkipReason } from "@/platform/ipc";
import { notifications } from "@/workbench/contributions";
+import { loadConfigs, useRun } from "./store";
/** The dialog's link for `source`. */
export function importLabel(source: RunImportSource): string {
switch (source) {
case "vscode":
return tx("Import from .vscode/launch.json");
+ case "jetbrains":
+ return tx("Import from JetBrains run configurations");
}
}
+/** Why Find Action can't import from `source`. */
+function missingText(source: RunImportSource): string {
+ switch (source) {
+ case "vscode":
+ return tx("This project has no .vscode/launch.json");
+ case "jetbrains":
+ return tx("This project has no JetBrains run configurations (.run, .idea)");
+ }
+}
+
+/** Find Action's "Import Run Configurations from…": opens Run/Debug Configurations, which imports. */
+export async function openImport(source: RunImportSource): Promise<void> {
+ const sources = await call(commands.runImportSources()).catch((): RunImportSource[] => []);
+ if (!sources.includes(source)) {
+ notifications().notify({ group: "run", level: "info", title: missingText(source), key: "run-import" });
+ return;
+ }
+ if (!useRun.getState().loaded) await loadConfigs();
+ useRun.setState({ editorOpen: true, chooserOpen: false, editTarget: null, editImport: source });
+}
+
/** Why an entry was not imported. */
export function skipReasonText(reason: SkipReason): string {
switch (reason.kind) {
case "nameTaken":
return tx("A configuration with this name already exists");
case "unsupportedType":
- return tx`The ${reason.type} debugger has no equivalent here`;
+ return tx`Type '${reason.type}' has no equivalent here`;
case "unsupportedRequest":
return tx`Request '${reason.request}' isn't supported`;
case "unsupportedAttach":
@@ -31,6 +56,14 @@ export function skipReasonText(reason: SkipReason): string {
return tx`Uses ${reason.variable}, which is known only when VS Code starts it`;
case "nothingToRun":
return tx("No program, module or command to run");
+ case "pathVariable":
+ return tx`Uses ${reason.variable}, a path variable with no value here`;
+ case "severalModules":
+ return tx`Uses ${reason.variable}, and the project has several modules`;
+ case "missingFile":
+ return tx`${reason.file} isn't in the project`;
+ case "invalidFile":
+ return tx`The file can't be read: ${reason.detail}`;
case "missingMember":
return tx`Its configuration '${reason.member}' isn't imported`;
case "invalid":
diff --git a/src/features/run/index.ts b/src/features/run/index.ts
index 0e16b4db1..bd9312432 100644
--- a/src/features/run/index.ts
+++ b/src/features/run/index.ts
@@ -5,7 +5,7 @@
import { registerEditorContribution } from "@/editor/api";
import { executeAction, getAction, registerActions } from "@/platform/actions";
import { getContext, setContext } from "@/platform/context";
-import { call, commands, onIdeEvent, type RunConfig, type RunImportSource } from "@/platform/ipc";
+import { onIdeEvent, type RunConfig } from "@/platform/ipc";
import { useProject } from "@/platform/project";
import { onWorkflowSettingsChange } from "@/platform/workflowSettings";
import { showContextMenu, lazyComponent, type MenuItem } from "@/ui";
@@ -35,6 +35,7 @@ import { debugWithAgent, jdwpLaunch } from "./javaDebug";
import { RunDialogsOverlay } from "./dialogs";
import { registerExternalTools } from "./externalTools";
import { EditConfigsOverlay } from "./EditConfigsDialog";
+import { openImport } from "./importConfigs";
import { registerGoActions } from "./goActions";
import { invalidateGoModules } from "./goModules";
import { RunWidget } from "./RunWidget";
@@ -420,20 +421,15 @@ export function activate(): () => void {
category: "Run",
when: "projectOpen",
keywords: ["launch.json", "vscode", "visual studio code", "debug configuration"],
- run: async () => {
- const sources = await call(commands.runImportSources()).catch((): RunImportSource[] => []);
- if (!sources.includes("vscode")) {
- notifications().notify({
- group: "run",
- level: "info",
- title: "This project has no .vscode/launch.json",
- key: "run-import",
- });
- return;
- }
- await ensureConfigs();
- useRun.setState({ editorOpen: true, chooserOpen: false, editTarget: null, editImport: "vscode" });
- },
+ run: () => openImport("vscode"),
+ },
+ {
+ id: "run.importJetbrains",
+ title: "Import Run Configurations from JetBrains (.run, .idea)",
+ category: "Run",
+ when: "projectOpen",
+ keywords: ["pycharm", "webstorm", "intellij", "run.xml", "workspace.xml", "run configuration"],
+ run: () => openImport("jetbrains"),
},
{
id: "run.debugConfig",
diff --git a/src/platform/locales/text/zh.json b/src/platform/locales/text/zh.json
index cee42fdad..5e221b6e9 100644
--- a/src/platform/locales/text/zh.json
+++ b/src/platform/locales/text/zh.json
@@ -2960,7 +2960,7 @@
"Left out of '{name}': {keys}": "'{name}' 中未导入的设置:{keys}",
"Click OK or Apply to save them.": "点击“确定”或“应用”以保存。",
"A configuration with this name already exists": "已存在同名配置",
- "The {type} debugger has no equivalent here": "此处没有与 {type} 调试器对应的配置类型",
+ "Type '{type}' has no equivalent here": "此处没有与类型 '{type}' 对应的配置",
"Request '{request}' isn't supported": "不支持请求 '{request}'",
"Only attaching to a host and port is supported": "仅支持附加到主机和端口",
"Uses {variable}, which is known only when VS Code starts it": "使用了 {variable},其值只有在 VS Code 启动时才能确定",
@@ -2969,6 +2969,13 @@
"Not a configuration with a name": "不是带名称的配置",
"'{name}' is saved in run.local.toml because it uses values from this machine": "'{name}' 使用了本机的值,因此保存在 run.local.toml 中",
"This project has no .vscode/launch.json": "此项目没有 .vscode/launch.json",
+ "Import from JetBrains run configurations": "从 JetBrains 运行配置导入",
+ "Import Run Configurations from JetBrains (.run, .idea)": "从 JetBrains 导入运行配置(.run、.idea)",
+ "This project has no JetBrains run configurations (.run, .idea)": "此项目没有 JetBrains 运行配置(.run、.idea)",
+ "{file} isn't in the project": "项目中没有 {file}",
+ "Uses {variable}, a path variable with no value here": "使用了 {variable},此处没有该路径变量的值",
+ "Uses {variable}, and the project has several modules": "使用了 {variable},但项目有多个模块",
+ "The file can't be read: {detail}": "无法读取该文件:{detail}",
"Templates": "模板",
"Configuration templates": "配置模板",
"Back to configurations": "返回配置",