bashrs 6.66.0

Rust-to-Shell transpiler for deterministic bootstrap scripts
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

/// Summary of matrix test results
#[derive(Debug, Clone)]
pub struct MatrixSummary {
    /// Total platforms tested
    pub total: usize,

    /// Platforms that passed
    pub passed: usize,

    /// Platforms that failed
    pub failed: usize,

    /// Platforms that were skipped
    pub skipped: usize,

    /// Total duration
    pub total_duration: Duration,

    /// Parallelism used
    pub parallelism: usize,
}

impl MatrixSummary {
    /// Format as text
    pub fn format(&self) -> String {
        let mut output = String::new();

        output.push_str(&format!("  Summary: {}/{} passed", self.passed, self.total));

        if self.failed > 0 {
            output.push_str(&format!(", {} failed", self.failed));
        }

        if self.skipped > 0 {
            output.push_str(&format!(", {} skipped", self.skipped));
        }

        output.push('\n');

        let duration = if self.total_duration.as_secs() >= 60 {
            format!(
                "{}m {:02}s",
                self.total_duration.as_secs() / 60,
                self.total_duration.as_secs() % 60
            )
        } else {
            format!("{}s", self.total_duration.as_secs())
        };

        output.push_str(&format!(
            "  Total time: {} (parallel execution, {} workers)\n",
            duration, self.parallelism
        ));

        output
    }

    /// Check if all tests passed
    pub fn all_passed(&self) -> bool {
        self.failed == 0
    }

    /// Get success rate as percentage
    pub fn success_rate(&self) -> f64 {
        if self.total == 0 {
            return 0.0;
        }
        (self.passed as f64 / self.total as f64) * 100.0
    }
}

/// Truncate string with ellipsis
fn truncate(s: &str, max_len: usize) -> String {
    if s.len() <= max_len {
        s.to_string()
    } else {
        format!("{}...", &s[..max_len.saturating_sub(3)])
    }
}

/// Escape string for JSON
fn escape_json(s: &str) -> String {
    s.replace('\\', "\\\\")
        .replace('"', "\\\"")
        .replace('\n', "\\n")
        .replace('\r', "\\r")
        .replace('\t', "\\t")
}

#[cfg(test)]
#[path = "container_tests_container_00.rs"]
mod tests_extracted;