cargo-crap4rust 0.8.1

Cargo subcommand for computing CRAP scores across Rust crates
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

// Copyright 2026 Umberto Gotti <umberto.gotti@umbertogotti.dev>
// Licensed under the MIT License
// SPDX-License-Identifier: MIT

use std::collections::HashMap;

use crate::analysis::source_function::SourceFunction;
use crate::coverage_io::coverage_record::CoverageRecord;

pub struct CoverageIndex {
    inner: HashMap<(String, usize), CoverageRecord>,
}

impl CoverageIndex {
    pub fn from_records(records: Vec<CoverageRecord>) -> Self {
        let mut inner: HashMap<(String, usize), CoverageRecord> = HashMap::new();
        for record in records {
            let key = (record.path_key.clone(), record.line);
            match inner.remove(&key) {
                None => {
                    inner.insert(key, record);
                }
                Some(existing) => {
                    inner.insert(key, Self::merge_duplicate(existing, record));
                }
            }
        }
        Self { inner }
    }

    fn merge_duplicate(existing: CoverageRecord, incoming: CoverageRecord) -> CoverageRecord {
        if incoming.covered_regions == 0 && existing.covered_regions > 0 {
            return existing;
        }
        if existing.covered_regions == 0 && incoming.covered_regions > 0 {
            return incoming;
        }
        CoverageRecord {
            path_key: existing.path_key,
            line: existing.line,
            covered_regions: existing.covered_regions + incoming.covered_regions,
            total_regions: existing.total_regions + incoming.total_regions,
        }
    }

    pub fn match_function(&self, function: &SourceFunction) -> Option<f64> {
        Self::match_function_coverage(function, &self.inner).map(|record| record.coverage_ratio())
    }

    pub fn get(&self, path_key: &str, line: usize) -> Option<&CoverageRecord> {
        self.inner.get(&(path_key.to_string(), line))
    }

    pub fn match_function_coverage(
        function: &SourceFunction,
        coverage_index: &HashMap<(String, usize), CoverageRecord>,
    ) -> Option<CoverageRecord> {
        let matching: Vec<&CoverageRecord> = coverage_index
            .iter()
            .filter(|((path_key, line), _)| {
                path_key == &function.path_key
                    && *line >= function.line
                    && *line <= function.end_line
            })
            .map(|(_, record)| record)
            .collect();

        if matching.is_empty() {
            return None;
        }

        let covered_regions = matching.iter().map(|r| r.covered_regions).sum();
        let total_regions = matching.iter().map(|r| r.total_regions).sum();

        Some(CoverageRecord {
            path_key: function.path_key.clone(),
            line: function.line,
            covered_regions,
            total_regions,
        })
    }
}