probe-run 0.3.0

Runs embedded programs just like native ones
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
109
110

use std::path::{self, Component, Path as StdPath, PathBuf};

use colored::Colorize as _;

#[derive(Debug, PartialEq)]
pub(crate) struct Path<'p> {
    registry_prefix: PathBuf,
    crate_name_version: &'p str,
    path: &'p StdPath,
}

impl<'p> Path<'p> {
    pub(crate) fn from_std_path(path: &'p StdPath) -> Option<Self> {
        if !path.is_absolute() {
            return None;
        }

        let mut components = path.components();

        let mut registry_prefix = PathBuf::new();
        for component in &mut components {
            registry_prefix.push(component.as_os_str());

            if let Component::Normal(component) = component {
                if component == "registry" {
                    break;
                }
            }
        }

        let src = super::get_component_normal(components.next()?)?;
        if src != "src" {
            return None;
        }
        registry_prefix.push(src);

        let github = super::get_component_normal(components.next()?)?.to_str()?;
        if !github.starts_with("github.com-") {
            return None;
        }
        registry_prefix.push(github);

        let crate_name_version = super::get_component_normal(components.next()?)?.to_str()?;

        Some(Path {
            registry_prefix,
            crate_name_version,
            path: components.as_path(),
        })
    }

    pub(crate) fn format_short(&self) -> String {
        format!(
            "[{}]{}{}",
            self.crate_name_version,
            path::MAIN_SEPARATOR,
            self.path.display()
        )
    }

    pub(crate) fn format_highlight(&self) -> String {
        format!(
            "{}{sep}{}{sep}{}",
            self.registry_prefix.display().to_string().dimmed(),
            self.crate_name_version.bold(),
            self.path.display(),
            sep = path::MAIN_SEPARATOR,
        )
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn end_to_end() {
        let home = dirs::home_dir().unwrap();
        let home = home.to_str().unwrap();

        let input = PathBuf::from(home)
            .join(".cargo")
            .join("registry")
            .join("src")
            .join("github.com-1ecc6299db9ec823")
            .join("cortex-m-rt-0.6.13")
            .join("src")
            .join("lib.rs");
        let path = Path::from_std_path(&input).unwrap();

        let expected = Path {
            registry_prefix: PathBuf::from(home)
                .join(".cargo")
                .join("registry")
                .join("src")
                .join("github.com-1ecc6299db9ec823"),
            crate_name_version: "cortex-m-rt-0.6.13",
            path: &PathBuf::from("src").join("lib.rs"),
        };

        assert_eq!(expected, path);

        let expected = PathBuf::from("[cortex-m-rt-0.6.13]")
            .join("src")
            .join("lib.rs");
        let formatted_str = path.format_short();

        assert_eq!(expected.to_string_lossy(), formatted_str);
    }
}