ferrous-forge 1.9.6

System-wide Rust development standards enforcer
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
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

//! Test coverage utility functions

use super::types::FileCoverage;
use crate::{Error, Result};
use serde::Deserialize;
use std::collections::HashMap;

/// Tarpaulin JSON output structure
#[derive(Deserialize)]
pub struct TarpaulinOutput {
    /// Line coverage percentage
    #[serde(rename = "coverage")]
    pub line_coverage: f64,
    /// Number of lines covered
    #[serde(rename = "linesCovered")]
    pub lines_covered: u32,
    /// Total number of lines
    #[serde(rename = "linesTotal")]
    pub lines_total: u32,
    /// Number of branches covered
    #[serde(rename = "branchesCovered")]
    pub branches_covered: Option<u32>,
    /// Total number of branches
    #[serde(rename = "branchesTotal")]
    pub branches_total: Option<u32>,
    /// Per-file coverage data
    #[serde(rename = "files")]
    pub files: HashMap<String, TarpaulinFile>,
}

/// Tarpaulin file coverage data
#[derive(Deserialize)]
pub struct TarpaulinFile {
    /// Line coverage percentage
    #[serde(rename = "coverage")]
    pub line_coverage: f64,
    /// Number of lines covered
    #[serde(rename = "linesCovered")]
    pub lines_covered: u32,
    /// Total number of lines
    #[serde(rename = "linesTotal")]
    pub lines_total: u32,
}

/// Function coverage statistics
pub struct FunctionStats {
    /// Function coverage percentage
    pub coverage: f64,
    /// Number of functions tested
    pub tested: u32,
    /// Total number of functions
    pub total: u32,
}

/// Parse tarpaulin JSON output
///
/// # Errors
///
/// Returns an error if the output string is not valid JSON or does not
/// match the expected tarpaulin format.
pub fn parse_tarpaulin_json(output: &str) -> Result<TarpaulinOutput> {
    serde_json::from_str(output)
        .map_err(|e| Error::process(format!("Failed to parse tarpaulin output: {}", e)))
}

/// Process file coverage data
pub fn process_file_coverage(
    files: &HashMap<String, TarpaulinFile>,
) -> (HashMap<String, FileCoverage>, FunctionStats) {
    let mut file_coverage = HashMap::new();
    let mut total_functions_tested = 0;
    let mut total_functions = 0;

    for (file_path, file_data) in files {
        let (estimated_functions, estimated_functions_tested) =
            estimate_function_coverage(file_data);

        total_functions += estimated_functions;
        total_functions_tested += estimated_functions_tested;

        let coverage = create_file_coverage(
            file_path,
            file_data,
            estimated_functions,
            estimated_functions_tested,
        );
        file_coverage.insert(file_path.clone(), coverage);
    }

    let function_coverage =
        calculate_function_coverage_percentage(total_functions_tested, total_functions);

    (
        file_coverage,
        FunctionStats {
            coverage: function_coverage,
            tested: total_functions_tested,
            total: total_functions,
        },
    )
}

/// Estimate function coverage from line coverage data
fn estimate_function_coverage(file_data: &TarpaulinFile) -> (u32, u32) {
    let estimated_functions = (file_data.lines_total / 10).max(1);
    let estimated_functions_tested =
        ((file_data.line_coverage / 100.0) * estimated_functions as f64) as u32;
    (estimated_functions, estimated_functions_tested)
}

/// Create file coverage object
fn create_file_coverage(
    file_path: &str,
    file_data: &TarpaulinFile,
    estimated_functions: u32,
    estimated_functions_tested: u32,
) -> FileCoverage {
    FileCoverage {
        file_path: file_path.to_string(),
        line_coverage: file_data.line_coverage,
        function_coverage: calculate_function_coverage_percentage(
            estimated_functions_tested,
            estimated_functions,
        ),
        lines_tested: file_data.lines_covered,
        total_lines: file_data.lines_total,
        functions_tested: estimated_functions_tested,
        total_functions: estimated_functions,
    }
}

/// Calculate function coverage percentage
pub fn calculate_function_coverage_percentage(tested: u32, total: u32) -> f64 {
    if total == 0 {
        0.0
    } else {
        (tested as f64 / total as f64) * 100.0
    }
}

/// Calculate branch coverage
pub fn calculate_branch_coverage(data: &TarpaulinOutput) -> f64 {
    match (data.branches_covered, data.branches_total) {
        (Some(covered), Some(total)) if total > 0 => (covered as f64 / total as f64) * 100.0,
        _ => 0.0,
    }
}