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.
TypeScript code-editorcross-platformdapdatabase-clientdebuggerdesktop-appdeveloper-toolsgithttp-clientideintellijlsprusttauriterminal
feat(run): import JetBrains Go Application and Go Test configurations (#2309)
ppxb16ebb6fde842
diff --git a/crates/ide-run/src/import/jetbrains.rs b/crates/ide-run/src/import/jetbrains.rsindex 327ce6399..ea94f7dbb 100644--- a/crates/ide-run/src/import/jetbrains.rs+++ b/crates/ide-run/src/import/jetbrains.rs@@ -4,8 +4,8 @@//! than one place is taken from the first, in that order.//!//! Python, Django server, Django tests, pytest, npm, Jest, Vitest, Node.js, Shell Script,-//! Application, Spring Boot and compound configurations become the matching kinds; other types-//! are skipped with their type.+//! Application, Spring Boot, Go Application / Go Test 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.@@ -165,6 +165,8 @@ const SHELL: &str = "ShConfigurationType";const COMPOUND: &str = "CompoundRunConfigurationType";const APPLICATION: &str = "Application";const SPRING_BOOT: &str = "SpringBootApplicationConfigurationType";+const GO_APPLICATION: &str = "GoApplicationRunConfiguration";+const GO_TEST: &str = "GoTestRunConfiguration";type Res<T> = Result<T, SkipReason>;@@ -343,6 +345,8 @@ impl Cx<'_> {SHELL => self.shell(name, c)?,APPLICATION => self.java_app(name, c, false, &mut ignored)?,SPRING_BOOT => self.java_app(name, c, true, &mut ignored)?,+ GO_APPLICATION => self.go_config(name, c, false, &mut ignored)?,+ GO_TEST => self.go_config(name, c, true, &mut ignored)?,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)@@ -353,6 +357,84 @@ impl Cx<'_> {Ok(Found { config, members, ignored })}+ /// A Go Application (`GoApplicationRunConfiguration`) or Go Test configuration. Both share+ /// the kind (package / file / directory), the target node, `go_parameters` (go tool+ /// arguments) and envs; a test adds a `pattern` and program arguments go after `-args`.+ fn go_config(&self, name: &str, c: &El, test: bool, _ignored: &mut Vec<String>) -> Res<RunConfig> {+ let (dir, cwd) = self.cwd(c.value("working_directory"))?;+ let scope = match c.value("kind").unwrap_or("PACKAGE") {+ "FILE" => "file",+ "DIRECTORY" => "directory",+ _ => "package",+ };+ let path_target = |value: Option<&str>| -> Res<Option<String>> {+ Ok(self.path(value)?.map(|p| path_from(self.root, p, &dir)).filter(|p| !p.is_empty()))+ };+ let target = match scope {+ "file" => path_target(c.value("filePath"))?+ .or(self.text(c.value("package"))?)+ .filter(|t| !t.is_empty())+ .unwrap_or_else(|| ".".to_owned()),+ "directory" => path_target(c.value("directory"))?.unwrap_or_else(|| ".".to_owned()),+ _ => self.text(c.value("package"))?.filter(|t| !t.is_empty()).unwrap_or_else(|| ".".to_owned()),+ };+ let raw_tool = self.text(c.value("go_parameters"))?.unwrap_or_default();+ let tool_args = parse_params(&raw_tool, Quotes::Double);+ let raw_program = self.text(c.value("parameters"))?.unwrap_or_default();+ let program_args = parse_params(&raw_program, Quotes::Double);+ let pattern = self.text(c.value("pattern"))?.unwrap_or_default();+ let output_dir =+ self.path(c.value("output_directory"))?.map(|p| path_from(self.root, p, self.root)).unwrap_or_default();+ // The form's module is the working directory relative to the project root.+ let module = cwd.as_ref().map(|d| d.to_string_lossy().replace('\\', "/")).unwrap_or_default();+ let run_after_build = c.option("run") != Some("false");+ let targets: Vec<String> = if scope == "file" {+ target.split('|').map(|t| t.trim().to_owned()).filter(|t| !t.is_empty()).collect()+ } else {+ vec![target.clone()]+ };+ let mut args = vec![if test { "test".to_owned() } else { "build".to_owned() }];+ args.extend(tool_args.clone());+ if test {+ if !pattern.is_empty() {+ args.extend(["-run".to_owned(), pattern.clone()]);+ }+ args.extend(targets);+ if !program_args.is_empty() {+ args.push("-args".to_owned());+ args.extend(program_args.clone());+ }+ } else {+ args.extend(targets);+ }+ let mut rc = config(name, "go", "go".into(), args, Some("delve"));+ rc.cwd = cwd.map(Into::into);+ rc.is_test = test;+ let mut params = BTreeMap::from([+ ("goKind".to_owned(), if test { "test" } else { "build" }.to_owned()),+ ("scope".to_owned(), scope.to_owned()),+ ("target".to_owned(), target),+ ("toolArgs".to_owned(), raw_tool),+ ("programArgs".to_owned(), raw_program),+ ("module".to_owned(), module),+ ]);+ if test {+ if !pattern.is_empty() {+ params.insert("pattern".to_owned(), pattern);+ }+ } else {+ params.insert("outputDir".to_owned(), output_dir);+ params.insert("runAfterBuild".to_owned(), run_after_build.to_string());+ }+ if !program_args.is_empty() {+ params.insert("programArgv".to_owned(), serde_json::to_string(&program_args).unwrap_or_default());+ }+ params.retain(|_, value| !value.is_empty());+ rc.extras.params = params;+ self.envs(c, &mut rc);+ Ok(rc)+ }+// ------------------------------------------------------------- Python/// The interpreter (`SDK_HOME` when the configuration doesn't use the module's), itsdiff --git a/crates/ide-run/tests/import_jetbrains.rs b/crates/ide-run/tests/import_jetbrains.rsindex 97473927b..b5fc65724 100644--- a/crates/ide-run/tests/import_jetbrains.rs+++ b/crates/ide-run/tests/import_jetbrains.rs@@ -1007,3 +1007,74 @@ fn file_urls_expand_module_and_home_macros() {assert_eq!(cwd(home), Some(PathBuf::from("jobs dir")));assert!(home.extras.local);}++#[test]+fn imports_go_application_and_test_configurations() {+ let dir = tempfile::tempdir().unwrap();+ write(+ dir.path(),+ ".run/build-linux-amd64.run.xml",+ &run_file(+ "build-linux-amd64",+ r#"<configuration default="false" name="NAME" type="GoApplicationRunConfiguration" factoryName="Go Application" folderName="go-build">+ <module name="goproject" />+ <working_directory value="$PROJECT_DIR$" />+ <go_parameters value="-ldflags "-s -w" -o bin/goproject.linux-amd64" />+ <envs>+ <env name="CGO_ENABLED" value="0" />+ <env name="GOARCH" value="amd64" />+ <env name="GOOS" value="linux" />+ </envs>+ <kind value="PACKAGE" />+ <package value="goproject" />+ <directory value="$PROJECT_DIR$" />+ <filePath value="$PROJECT_DIR$/main.go" />+ <output_directory value="$PROJECT_DIR$/bin" />+ <option name="run" value="false" />+ <method v="2" />+ </configuration>"#,+ ),+ );+ write(+ dir.path(),+ ".run/Test.run.xml",+ &run_file(+ "Run tests",+ r#"<configuration default="false" name="NAME" type="GoTestRunConfiguration" factoryName="Go Test">+ <module name="goproject" />+ <working_directory value="$PROJECT_DIR$/pkg" />+ <go_parameters value="-tags integration" />+ <kind value="PACKAGE" />+ <package value="example.com/pkg" />+ <pattern value="TestLogin" />+ <parameters value="-v -count=1" />+ <method v="2" />+ </configuration>"#,+ ),+ );+ let r = import_from(dir.path(), &[]);++ let app = get(&r, "build-linux-amd64");+ assert_eq!(app.kind, "go");+ assert_eq!(app.command, "go");+ assert_eq!(app.args, s(&["build", "-ldflags", "-s -w", "-o", "bin/goproject.linux-amd64", "goproject"]));+ assert_eq!(app.env["GOOS"], "linux");+ assert_eq!(app.extras.params["goKind"], "build");+ assert_eq!(app.extras.params["scope"], "package");+ assert_eq!(app.extras.params["target"], "goproject");+ assert_eq!(app.extras.params["outputDir"], "bin");+ assert_eq!(app.extras.params["runAfterBuild"], "false");+ assert_eq!(app.extras.folder.as_deref(), Some("go-build"));++ let test = get(&r, "Run tests");+ assert!(test.is_test);+ assert_eq!(test.kind, "go");+ assert_eq!(+ test.args,+ s(&["test", "-tags", "integration", "-run", "TestLogin", "example.com/pkg", "-args", "-v", "-count=1"])+ );+ assert_eq!(cwd(test), Some(PathBuf::from("pkg")));+ assert_eq!(test.extras.params["goKind"], "test");+ assert_eq!(test.extras.params["pattern"], "TestLogin");+ assert_eq!(test.extras.params["module"], "pkg");+}