rust-diff-analyzer 1.6.0

Semantic analyzer for Rust PR diffs that distinguishes production code from test code
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

// SPDX-FileCopyrightText: 2025 RAprogramm <andrey.rozanov.vl@gmail.com>
// SPDX-License-Identifier: MIT

use crate::{
    config::Config,
    types::{SemanticUnit, SemanticUnitKind},
};

/// Calculates the weight score for a semantic unit
///
/// # Arguments
///
/// * `unit` - Semantic unit to calculate weight for
/// * `config` - Configuration with weight settings
///
/// # Returns
///
/// Weight score for the unit
///
/// # Examples
///
/// ```
/// use rust_diff_analyzer::{
///     classifier::rules::calculate_weight,
///     config::Config,
///     types::{LineSpan, SemanticUnit, SemanticUnitKind, Visibility},
/// };
///
/// let unit = SemanticUnit::new(
///     SemanticUnitKind::Function,
///     "public_fn".to_string(),
///     Visibility::Public,
///     LineSpan::new(1, 10),
///     vec![],
/// );
///
/// let config = Config::default();
/// let weight = calculate_weight(&unit, &config);
/// assert_eq!(weight, 3); // default public function weight
/// ```
pub fn calculate_weight(unit: &SemanticUnit, config: &Config) -> usize {
    let weights = &config.weights;

    match unit.kind {
        SemanticUnitKind::Function => {
            if unit.visibility.is_public() {
                weights.public_function
            } else {
                weights.private_function
            }
        }
        SemanticUnitKind::Struct | SemanticUnitKind::Enum => {
            if unit.visibility.is_public() {
                weights.public_struct
            } else {
                weights.private_struct
            }
        }
        SemanticUnitKind::Impl => weights.impl_block,
        SemanticUnitKind::Trait => weights.trait_definition,
        SemanticUnitKind::Const | SemanticUnitKind::Static => weights.const_static,
        SemanticUnitKind::TypeAlias => weights.const_static,
        SemanticUnitKind::Macro => weights.private_function,
        SemanticUnitKind::Module => weights.const_static,
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::types::{LineSpan, Visibility};

    #[test]
    fn test_weight_calculation() {
        let config = Config::default();

        let pub_fn = SemanticUnit::new(
            SemanticUnitKind::Function,
            "public".to_string(),
            Visibility::Public,
            LineSpan::new(1, 10),
            vec![],
        );
        assert_eq!(calculate_weight(&pub_fn, &config), 3);

        let priv_fn = SemanticUnit::new(
            SemanticUnitKind::Function,
            "private".to_string(),
            Visibility::Private,
            LineSpan::new(1, 10),
            vec![],
        );
        assert_eq!(calculate_weight(&priv_fn, &config), 1);

        let trait_def = SemanticUnit::new(
            SemanticUnitKind::Trait,
            "MyTrait".to_string(),
            Visibility::Public,
            LineSpan::new(1, 10),
            vec![],
        );
        assert_eq!(calculate_weight(&trait_def, &config), 4);
    }
}