feat(intellij): save and edit Robot Framework run configurations

Run configurations keep their target across restarts and can be stored as project files: "Files and folders" with paths that replace those of robot.toml, or "Tests and suites" with the full names that discovery reports, in a field that expands to one entry per line. The editor is PyCharm's run configuration editor, so the interpreter, interpreter options, working directory, environment variables, .env files and Run with uv take effect, gutter runs reuse their configuration instead of creating "(1)" copies, Profile ends with a message, and a configuration with a remote interpreter is refused (#418).

Author: d-biehl

intellij-client/src/main/kotlin/dev/robotcode/robotcode4ij/RobotCodeHelpers.kt

@@ -56,9 +56,15 @@ internal fun pluginPathOf(classResource: URL?): Path? {
     return jar.parent?.parent
 }
 
+/** The module whose Python interpreter RobotCode uses: the first module that has one. */
+val Project.robotPythonModule: com.intellij.openapi.module.Module?
+    get() {
+        return this.modules.firstOrNull { PythonSdkUtil.findPythonSdk(it) != null }
+    }
+
 val Project.robotPythonSdk: com.intellij.openapi.projectRoots.Sdk?
     get() {
-        return this.modules.firstNotNullOfOrNull { PythonSdkUtil.findPythonSdk(it) }
+        return robotPythonModule?.let { PythonSdkUtil.findPythonSdk(it) }
     }
 
 /**

intellij-client/src/main/kotlin/dev/robotcode/robotcode4ij/debugging/RobotCodeDebugProgramRunner.kt

@@ -7,41 +7,33 @@ import com.intellij.execution.executors.DefaultDebugExecutor
 import com.intellij.execution.runners.AsyncProgramRunner
 import com.intellij.execution.runners.ExecutionEnvironment
 import com.intellij.execution.ui.RunContentDescriptor
-import com.intellij.openapi.fileEditor.FileDocumentManager
 import com.intellij.xdebugger.XDebugProcess
 import com.intellij.xdebugger.XDebugProcessStarter
 import com.intellij.xdebugger.XDebugSession
 import com.intellij.xdebugger.XDebuggerManager
 import dev.robotcode.robotcode4ij.execution.RobotCodeRunConfiguration
 import dev.robotcode.robotcode4ij.execution.RobotCodeRunProfileState
+import dev.robotcode.robotcode4ij.execution.startInBackground
 import org.jetbrains.concurrency.Promise
-import org.jetbrains.concurrency.resolvedPromise
 
 class RobotCodeDebugProgramRunner : AsyncProgramRunner<RunnerSettings>() {
     override fun getRunnerId(): String {
         return "dev.robotcode.robotcode4ij.execution.RobotCodeDebugProgramRunner"
     }
-    
+
     override fun canRun(executorId: String, profile: RunProfile): Boolean {
         return (executorId == DefaultDebugExecutor.EXECUTOR_ID) && profile is RobotCodeRunConfiguration
     }
-    
+
+    // the session wraps the started run; the debug process subscribes to the handshake before the session starts it
     override fun execute(environment: ExecutionEnvironment, state: RunProfileState): Promise<RunContentDescriptor?> {
-        FileDocumentManager.getInstance().saveAllDocuments()
-        
-        return resolvedPromise(doExecute(state as RobotCodeRunProfileState, environment))
-    }
-    
-    private fun doExecute(state: RobotCodeRunProfileState, environment: ExecutionEnvironment): RunContentDescriptor? {
-        val manager = XDebuggerManager.getInstance(environment.project)
-        val started = manager.newSessionBuilder(object : XDebugProcessStarter() {
-            override fun start(session: XDebugSession): XDebugProcess {
-                val result = state.execute(environment.executor, this@RobotCodeDebugProgramRunner)
-                
-                return RobotCodeDebugProcess(session, result, state)
-            }
-        }).environment(environment).startSession()
-        
-        return started.runContentDescriptor
+        val runState = state as RobotCodeRunProfileState
+        return startInBackground(runState, environment) { result ->
+            XDebuggerManager.getInstance(environment.project).newSessionBuilder(object : XDebugProcessStarter() {
+                override fun start(session: XDebugSession): XDebugProcess {
+                    return RobotCodeDebugProcess(session, result, runState)
+                }
+            }).environment(environment).startSession().runContentDescriptor
+        }
     }
 }

intellij-client/src/main/kotlin/dev/robotcode/robotcode4ij/execution/RobotCodeProgramRunner.kt

@@ -1,5 +1,7 @@
 package dev.robotcode.robotcode4ij.execution
 
+import com.intellij.execution.ExecutionException
+import com.intellij.execution.ExecutionResult
 import com.intellij.execution.configurations.RunProfile
 import com.intellij.execution.configurations.RunProfileState
 import com.intellij.execution.configurations.RunnerSettings
@@ -8,26 +10,78 @@ import com.intellij.execution.runners.AsyncProgramRunner
 import com.intellij.execution.runners.ExecutionEnvironment
 import com.intellij.execution.runners.showRunContent
 import com.intellij.execution.ui.RunContentDescriptor
+import com.intellij.openapi.application.ApplicationManager
+import com.intellij.openapi.application.ModalityState
 import com.intellij.openapi.fileEditor.FileDocumentManager
+import dev.robotcode.robotcode4ij.RobotCodeBundle
+import org.jetbrains.concurrency.AsyncPromise
 import org.jetbrains.concurrency.Promise
-import org.jetbrains.concurrency.resolvedPromise
+import org.jetbrains.concurrency.rejectedPromise
+
+/**
+ * Starts the run of [state] on a background thread, because preparing the interpreter and its environment must not run
+ * on the UI thread, and passes the result to [show] on the UI thread.
+ */
+internal fun startInBackground(
+    state: RobotCodeRunProfileState,
+    environment: ExecutionEnvironment,
+    show: (ExecutionResult) -> RunContentDescriptor?
+): Promise<RunContentDescriptor?> {
+    FileDocumentManager.getInstance().saveAllDocuments()
+    val promise = AsyncPromise<RunContentDescriptor?>()
+    val application = ApplicationManager.getApplication()
+    application.executeOnPooledThread {
+        val result = try {
+            state.execute(environment.executor)
+        } catch (e: Throwable) {
+            promise.setError(e)
+            return@executeOnPooledThread
+        }
+        if (result == null) {
+            promise.setResult(null)
+            return@executeOnPooledThread
+        }
+        application.invokeLater({
+            try {
+                promise.setResult(show(result))
+            } catch (e: Throwable) {
+                result.processHandler?.destroyProcess()
+                promise.setError(e)
+            }
+        }, ModalityState.nonModal())
+    }
+    return promise
+}
 
 class RobotCodeProgramRunner : AsyncProgramRunner<RunnerSettings>() {
     override fun getRunnerId(): String {
         return "dev.robotcode.robotcode4ij.execution.RobotCodeProgramRunner"
     }
-    
+
     override fun canRun(executorId: String, profile: RunProfile): Boolean {
         return (executorId == DefaultRunExecutor.EXECUTOR_ID) && profile is RobotCodeRunConfiguration
     }
-    
+
     override fun execute(environment: ExecutionEnvironment, state: RunProfileState): Promise<RunContentDescriptor?> {
-        FileDocumentManager.getInstance().saveAllDocuments()
-        
-        return resolvedPromise(doExecute(state as RobotCodeRunProfileState, environment))
+        return startInBackground(state as RobotCodeRunProfileState, environment) { showRunContent(it, environment) }
+    }
+}
+
+/**
+ * Takes PyCharm Professional's "Profile" for Robot Framework configurations, which its profiler runner would otherwise
+ * accept as Python run configurations, and ends it with a message.
+ */
+class RobotCodeProfileRunner : AsyncProgramRunner<RunnerSettings>() {
+    override fun getRunnerId(): String {
+        return "dev.robotcode.robotcode4ij.execution.RobotCodeProfileRunner"
     }
 
-    private fun doExecute(state: RobotCodeRunProfileState, environment: ExecutionEnvironment): RunContentDescriptor? {
-        return showRunContent(state.execute(environment.executor, this), environment)
+    // the id of PyCharm Professional's profiler executor
+    override fun canRun(executorId: String, profile: RunProfile): Boolean {
+        return executorId == "Profiler" && profile is RobotCodeRunConfiguration
+    }
+    
+    override fun execute(environment: ExecutionEnvironment, state: RunProfileState): Promise<RunContentDescriptor?> {
+        return rejectedPromise(ExecutionException(RobotCodeBundle.message("run.profile.notSupported")))
     }
 }

intellij-client/src/main/kotlin/dev/robotcode/robotcode4ij/execution/RobotCodeRunConfiguration.kt

@@ -2,50 +2,75 @@ package dev.robotcode.robotcode4ij.execution
 
 import com.intellij.execution.Executor
 import com.intellij.execution.configurations.ConfigurationFactory
-import com.intellij.execution.configurations.LocatableConfigurationBase
-import com.intellij.execution.configurations.RunConfiguration
 import com.intellij.execution.configurations.RunProfileState
 import com.intellij.execution.runners.ExecutionEnvironment
 import com.intellij.execution.testframework.sm.runner.SMRunnerConsolePropertiesProvider
 import com.intellij.execution.testframework.sm.runner.SMTRunnerConsoleProperties
 import com.intellij.openapi.options.SettingsEditor
 import com.intellij.openapi.project.Project
+import com.intellij.openapi.util.JDOMExternalizerUtil
+import com.jetbrains.python.run.AbstractPythonRunConfiguration
+import com.jetbrains.python.run.DebugAwareConfiguration
 import dev.robotcode.robotcode4ij.robotCodeEnvironment
-import dev.robotcode.robotcode4ij.testing.RobotCodeTestItem
+import dev.robotcode.robotcode4ij.robotPythonModule
 import org.jdom.Element
 
+/**
+ * A Robot Framework run configuration. It is a PyCharm Python run configuration, so it has PyCharm's interpreter,
+ * environment and working-directory options, and stores what it runs, its target, in
+ * [RobotCodeRunConfigurationOptions].
+ */
 class RobotCodeRunConfiguration(project: Project, factory: ConfigurationFactory) :
-    LocatableConfigurationBase<ConfigurationFactory>
-        (project, factory, "Robot Framework"), SMRunnerConsolePropertiesProvider {
-    
+    AbstractPythonRunConfiguration<RobotCodeRunConfiguration>(project, factory), SMRunnerConsolePropertiesProvider,
+    DebugAwareConfiguration {
+
+    init {
+        applyRobotCodeDefaults()
+    }
+
+    // runs as before: the interpreter that RobotCode uses for the language server, the project folder as working
+    // directory and no PYTHONPATH entries from the project's roots; earlier versions stored no interpreter options,
+    // which PyCharm's editor needs as a value
+    private fun applyRobotCodeDefaults() {
+        project.robotPythonModule?.let { setModule(it) }
+        isUseModuleSdk = true
+        interpreterOptions = ""
+        workingDirectory = ""
+        setAddContentRoots(false)
+        setAddSourceRoots(false)
+    }
+
+    public override fun getOptions(): RobotCodeRunConfigurationOptions {
+        return super.getOptions() as RobotCodeRunConfigurationOptions
+    }
+
     // fails with the IDE's run error before a process or a debug session starts
     override fun getState(executor: Executor, environment: ExecutionEnvironment): RunProfileState {
         project.robotCodeEnvironment.ensureUsableForRun()
         return RobotCodeRunProfileState(this, environment)
     }
-    
-    override fun getConfigurationEditor(): SettingsEditor<out RunConfiguration> {
-        // TODO: Implement configuration editor
-        return RobotCodeRunConfigurationEditor()
+
+    override fun createConfigurationEditor(): SettingsEditor<RobotCodeRunConfiguration> {
+        return RobotCodeRunConfigurationEditor(this)
     }
-    
-    var includedTestItems: List<RobotCodeTestItem> = emptyList()
-    
-    var paths: List<String> = emptyList()
-    
+
+    override fun isNewUiSupported(): Boolean = true
+
+    // Run and Debug use RobotCode's runners
+    override fun canRunWithCoverage(): Boolean = false
+
+    override fun canRunUnderDebug(): Boolean = false
+
     override fun createTestConsoleProperties(executor: Executor): SMTRunnerConsoleProperties {
         return RobotRunnerConsoleProperties(this, "Robot Framework", executor)
     }
-    
-    override fun writeExternal(element: Element) {
-        super.writeExternal(element)
-        // TODO: Implement serialization
-        // XmlSerializer.serializeInto(this, element)
-    }
-    
+
     override fun readExternal(element: Element) {
-        super.readExternal(element)
-        // TODO: Implement deserialization
-        // XmlSerializer.deserializeInto(this, element)
+        // PyCharm writes this field for every configuration; earlier versions of the plugin did not
+        val earlierVersion = JDOMExternalizerUtil.readField(element, "ADD_CONTENT_ROOTS") == null
+        super<AbstractPythonRunConfiguration>.readExternal(element)
+        if (earlierVersion) {
+            applyRobotCodeDefaults()
+        }
     }
 }