cu29 1.0.0-rc2

Copper Runtime prelude crate. Copper is a Rust engine for robotics.
Documentation 
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

use serde::Serialize;
use std::fs;
use std::path::Path;

pub use inventory;

#[derive(Debug, Clone, Copy, Serialize)]
pub struct SafetyCheckRef {
    pub check_id: &'static str,
    pub requirement_id: &'static str,
    pub description: &'static str,
    pub kind: &'static str,
}

#[derive(Debug, Clone, Copy, Serialize)]
pub struct SafetyCaseRef {
    pub package: &'static str,
    pub case_id: &'static str,
    pub function: &'static str,
    pub module_path: &'static str,
    pub file: &'static str,
    pub checks: &'static [SafetyCheckRef],
}

inventory::collect!(SafetyCaseRef);

#[derive(Debug, Clone, Serialize)]
pub struct PackageSafetyIndex {
    pub package: String,
    pub cases: Vec<CollectedSafetyCase>,
}

#[derive(Debug, Clone, Serialize)]
pub struct CollectedSafetyCase {
    pub package: String,
    pub case_id: String,
    pub function: String,
    pub test_name: String,
    pub file: String,
    pub checks: Vec<CollectedSafetyCheck>,
}

#[derive(Debug, Clone, Serialize)]
pub struct CollectedSafetyCheck {
    pub check_id: String,
    pub requirement_id: String,
    pub description: String,
    pub kind: String,
}

pub fn collect_package_index(package: &str) -> PackageSafetyIndex {
    let mut cases: Vec<_> = inventory::iter::<SafetyCaseRef>
        .into_iter()
        .filter(|case_ref| case_ref.package == package)
        .map(|case_ref| CollectedSafetyCase {
            package: case_ref.package.to_string(),
            case_id: case_ref.case_id.to_string(),
            function: case_ref.function.to_string(),
            test_name: libtest_name(case_ref.module_path, case_ref.function),
            file: case_ref.file.to_string(),
            checks: case_ref
                .checks
                .iter()
                .map(|check| CollectedSafetyCheck {
                    check_id: check.check_id.to_string(),
                    requirement_id: check.requirement_id.to_string(),
                    description: check.description.to_string(),
                    kind: check.kind.to_string(),
                })
                .collect(),
        })
        .collect();

    cases.sort_by(|left, right| left.case_id.cmp(&right.case_id));
    for case in &mut cases {
        case.checks
            .sort_by(|left, right| left.check_id.cmp(&right.check_id));
    }

    PackageSafetyIndex {
        package: package.to_string(),
        cases,
    }
}

pub fn write_package_index_json(
    path: impl AsRef<Path>,
    index: &PackageSafetyIndex,
) -> std::io::Result<()> {
    let path = path.as_ref();
    if let Some(parent) = path.parent() {
        fs::create_dir_all(parent)?;
    }
    let json = serde_json::to_vec_pretty(index).expect("safety index should serialize");
    fs::write(path, json)
}

fn libtest_name(module_path: &str, function: &str) -> String {
    let mut segments = module_path.split("::");
    let _crate_name = segments.next();
    let rest: Vec<_> = segments.collect();
    if rest.is_empty() {
        function.to_string()
    } else {
        format!("{}::{}", rest.join("::"), function)
    }
}