package openidea:plugin@1.9.0; /// Launches this plugin's configurations in the invoking window's Run tool window. interface run { use types.{error}; /// Starts an owned configuration, appending args. Debug requires a debugger. /// Only from a window command/event. The returned id receives run-exited. start: func(config: string, args: list, debug: bool) -> result; } /// Optional dynamic configurations, refreshed alongside run detectors. interface run-configurations { /// A configuration running an approved process in the project sandbox. record run-configuration { id: string, name: string, program: string, args: list, cwd: option, test: bool, framework: option, } /// Returns the complete set for this project root. configurations: func(project-root: string) -> list; } /// Optional dynamic configurations with an environment and a debugger (API 1.9). /// When a plugin exports both, the IDE uses this one instead of `run-configurations`. interface launch-configurations { use types.{extension}; /// A process the run starts, to attach the debugger to. record attach-child { /// Its debugger, as in Attach to Process: `dotnet`, `node`, `python`, `go` or `native`. kind: string, /// Only a process whose command line contains this text. command-contains: option, } /// How Debug starts the configuration. variant debugger { /// Starts `program` under the debugger of this language id (its `[debugger]`), e.g. `python`. launch(string), /// Runs the configuration as Run does, then attaches to the first matching process the /// run starts (it waits for one up to 60 seconds). attach-child(attach-child), /// Later kinds; this IDE treats the configuration as having no debugger. other(extension), } /// `run-configuration` with an environment and a debugger. record launch-configuration { id: string, name: string, program: string, args: list, cwd: option, test: bool, framework: option, /// Variables added to the run's environment (at most 64). A name the IDE's own /// environment already has, such as `PATH`, is refused like in `process`. env: list>, /// None: Debug infers the debugger from a source file in `args`, as before. debugger: option, } /// Returns the complete set for this project root. configurations: func(project-root: string) -> list; } /// Optional parser for test configurations whose framework is plugin. interface test-results { use types.{location, extension}; /// A suite or test; parents must precede children and ids remain stable for a run. record test-start { id: string, parent: option, name: string, location: option } /// A successful test and optional elapsed milliseconds. record test-passed { id: string, duration-ms: option } /// A failed test, comparison and optional declaration location. record test-failed { id: string, duration-ms: option, message: string, expected: option, actual: option, location: option, } /// A skipped test and its explanation. record test-skipped { id: string, reason: option } /// Output attached to a test or suite. record test-output { id: string, text: string } /// Incremental updates to the IDE's test tree. Unknown extensions are ignored. variant test-event { suite-started(test-start), test-started(test-start), passed(test-passed), failed(test-failed), skipped(test-skipped), output(test-output), other(extension), } /// Parses one bounded output batch; failures fall back to built-in parsers. parse: func(config: string, chunk: string) -> list; /// Selects test-tree name paths (parents then test), using the same config id as parse. /// Returns the full replacement argument list, or none when filtering is unsupported. select-tests: func(config: string, tests: list>) -> option>; }