aboutsummaryrefslogtreecommitdiff
path: root/crates/ra_lsp_server/src/cargo_target_spec.rs
blob: cdf2ec10b664487f58c05c68cbc45b8c66203d84 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
use crate::{
    project_model::{self, TargetKind},
    server_world::ServerWorld,
    Result
};

use ra_ide_api::{FileId, RunnableKind};

pub(crate) fn runnable_args(
    world: &ServerWorld,
    file_id: FileId,
    kind: &RunnableKind,
) -> Result<Vec<String>> {
    let spec = CargoTargetSpec::for_file(world, file_id)?;
    let mut res = Vec::new();
    match kind {
        RunnableKind::Test { name } => {
            res.push("test".to_string());
            if let Some(spec) = spec {
                spec.push_to(&mut res);
            }
            res.push("--".to_string());
            res.push(name.to_string());
            res.push("--nocapture".to_string());
        }
        RunnableKind::TestMod { path } => {
            res.push("test".to_string());
            if let Some(spec) = spec {
                spec.push_to(&mut res);
            }
            res.push("--".to_string());
            res.push(path.to_string());
            res.push("--nocapture".to_string());
        }
        RunnableKind::Bench { name } => {
            res.push("bench".to_string());
            if let Some(spec) = spec {
                spec.push_to(&mut res);
            }
            res.push("--".to_string());
            res.push(name.to_string());
            res.push("--nocapture".to_string());
        }
        RunnableKind::Bin => {
            res.push("run".to_string());
            if let Some(spec) = spec {
                spec.push_to(&mut res);
            }
        }
    }
    Ok(res)
}

pub struct CargoTargetSpec {
    pub package: String,
    pub target: String,
    pub target_kind: TargetKind,
}

impl CargoTargetSpec {
    pub fn for_file(world: &ServerWorld, file_id: FileId) -> Result<Option<CargoTargetSpec>> {
        let &crate_id = match world.analysis().crate_for(file_id)?.first() {
            Some(crate_id) => crate_id,
            None => return Ok(None),
        };
        let file_id = world.analysis().crate_root(crate_id)?;
        let path = world.vfs.read().file2path(ra_vfs::VfsFile(file_id.0.into()));
        let res = world.workspaces.iter().find_map(|ws| match ws {
            project_model::ProjectWorkspace::Cargo { cargo, .. } => {
                let tgt = cargo.target_by_root(&path)?;
                Some(CargoTargetSpec {
                    package: tgt.package(&cargo).name(&cargo).to_string(),
                    target: tgt.name(&cargo).to_string(),
                    target_kind: tgt.kind(&cargo),
                })
            }
            project_model::ProjectWorkspace::Json { .. } => None,
        });
        Ok(res)
    }

    pub fn push_to(self, buf: &mut Vec<String>) {
        buf.push("--package".to_string());
        buf.push(self.package);
        match self.target_kind {
            TargetKind::Bin => {
                buf.push("--bin".to_string());
                buf.push(self.target);
            }
            TargetKind::Test => {
                buf.push("--test".to_string());
                buf.push(self.target);
            }
            TargetKind::Bench => {
                buf.push("--bench".to_string());
                buf.push(self.target);
            }
            TargetKind::Example => {
                buf.push("--example".to_string());
                buf.push(self.target);
            }
            TargetKind::Lib => {
                buf.push("--lib".to_string());
            }
            TargetKind::Other => (),
        }
    }
}