运行目标

[[contributes.runDetectors]]
id = "forge-test"
name = "forge test"
files = ["foundry.toml"]     # 根目录包含其中任一文件时提供
command = "forge"            # 单个程序；对应 process:forge 权限
args = ["test"]
test = true                  # 结果进入测试树
# framework = "plugin"       # API 1.4：用 test-results 导出解析输出

engines.openidea = "^1.4"

[capabilities]
required = ["process:openidea-example-tests"]

[[contributes.runConfigurations]]
files = ["example.tests"]   # 1–16 个标记文件；只有存在其中之一时才会调用导出

use openidea_plugin::{PluginRunConfiguration, RunConfigurations, register_plugin};

impl RunConfigurations for TestRunner {
    fn configurations(&mut self, _root: &str) -> Vec<PluginRunConfiguration> {
        vec![PluginRunConfiguration {
            id: "tests".into(),
            name: "Example tests".into(),
            program: "openidea-example-tests".into(),   // 已声明并授权的 process: 名称
            test: true,
            framework: Some("plugin".into()),
            ..Default::default()
        }]
    }
}

register_plugin!(TestRunner, run_configurations);

use openidea_plugin::{PluginTestEvent, TestFailed, TestPassed, TestResults, TestStart};

impl TestResults for TestRunner {
    fn parse(&mut self, _config: &str, chunk: &str) -> Vec<PluginTestEvent> {
        self.pending.push_str(chunk);           // 分块不一定是完整的行
        let mut events = vec![];
        while let Some(end) = self.pending.find('\n') {
            let line: String = self.pending.drain(..=end).collect();
            let Some((kind, name)) = line.trim().split_once(' ') else { continue };
            let id = name.to_owned();
            match kind {
                "start" => events.push(PluginTestEvent::TestStarted(TestStart { id, parent: None, name: name.into(), location: None })),
                "pass" => events.push(PluginTestEvent::Passed(TestPassed { id, duration_ms: None })),
                "fail" => events.push(PluginTestEvent::Failed(TestFailed {
                    id, duration_ms: None, message: "failed".into(), expected: None, actual: None, location: None,
                })),
                _ => {}
            }
        }
        events
    }

    fn select_tests(&mut self, config: &str, tests: &[Vec<String>]) -> Option<Vec<String>> {
        // 只运行这些测试的完整替换参数列表；不支持时返回 None。
        (config == "tests" && tests.iter().all(|p| p.len() == 1)).then(|| tests.iter().map(|p| p[0].clone()).collect())
    }
}

fn run_command(&mut self, _id: &str, _ctx: &Invocation, arg: Option<&str>) -> Result<Option<String>, Error> {
    let args = arg.into_iter().map(str::to_owned).collect::<Vec<_>>();
    host::start_run("tests", &args, false).map(Some)
}

use openidea_plugin::{PluginRunTarget, host};

let project = ctx.project().ok_or("Open a project first")?;
host::register_run_target(&project, &PluginRunTarget {
    id: "ddev".into(),
    name: "DDEV".into(),
    program: "ddev".into(),                                   // 需要 process:ddev
    args: vec!["exec".into()],
    workdir_args: vec!["--dir={cwd}".into(), "--".into()],
    container_root: Some("/var/www/html".into()),
    commands: vec![("composer".into(), vec!["composer".into()])],
})?;

use openidea_plugin::PluginCommandOverride;

PluginCommandOverride { name: "composer".into(), args: vec!["composer".into()], workdir_args: Some(vec![]) }

use openidea_plugin::{RunTargetLaunch, RunTargetValidation, register_plugin};

impl RunTargetValidation for MyPlugin {
    fn validate(&mut self, project: &str, _target_id: &str, _launch: &RunTargetLaunch) -> Result<(), String> {
        if runtime_is_running(project) { Ok(()) } else { Err("Project runtime is stopped".into()) }
    }
}
register_plugin!(MyPlugin, run_target_validation);

use openidea_plugin::host::{self, Command};

let project = ctx.project().ok_or("Open a project first")?;
let out = host::run_command(&Command::new("forge").arg("build").env("FOUNDRY_PROFILE", "ci"), Some(&project), None)?;