kimun 0.13.3

Code metrics tool — health score, complexity, duplication, hotspots, ownership
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

//! Temporal coupling analysis — finds files that change together in git.
//!
//! Identifies implicit dependencies between files by analyzing commit
//! co-occurrence. High coupling between unrelated files may indicate
//! hidden dependencies that should be made explicit or decoupled.

pub mod analyzer;
mod report;

use std::collections::HashMap;
use std::error::Error;
use std::path::{Path, PathBuf};

use crate::git::GitRepo;
use crate::util::parse_since;
use crate::walk;
use analyzer::compute_coupling;
use report::{print_json, print_report};

/// Check whether a git-relative path is inside a test directory or is a test file.
fn is_test_path(path: &Path) -> bool {
    for component in path.components() {
        if let Some(name) = component.as_os_str().to_str()
            && walk::TEST_DIRS.contains(&name)
        {
            return true;
        }
    }
    walk::is_test_file(path)
}

#[allow(clippy::too_many_arguments)]
pub fn run(
    path: &Path,
    json: bool,
    include_tests: bool,
    top: usize,
    sort_by: &str,
    since: Option<&str>,
    min_degree: usize,
    min_strength: Option<f64>,
) -> Result<(), Box<dyn Error>> {
    if min_degree == 0 {
        return Err("--min-degree must be at least 1".into());
    }

    let git_repo =
        GitRepo::open(path).map_err(|e| format!("not a git repository (or any parent): {e}"))?;

    let since_ts = since.map(parse_since).transpose()?;

    // Build freq_map: path → commits, filtering by min_degree and optionally test files
    let freqs = git_repo.file_frequencies(since_ts)?;
    if freqs.is_empty() {
        if since.is_some() {
            eprintln!("No commits found in the specified time range.");
        } else {
            eprintln!("No commits found in the repository.");
        }
        return Ok(());
    }
    let exclude_tests = !include_tests;
    let freq_map: HashMap<PathBuf, usize> = freqs
        .into_iter()
        .filter(|f| f.commits >= min_degree)
        .filter(|f| !exclude_tests || !is_test_path(&f.path))
        .map(|f| (f.path, f.commits))
        .collect();

    if freq_map.is_empty() {
        eprintln!("No files with >= {min_degree} commits found. Try a lower --min-degree value.");
        return Ok(());
    }

    // Get co-changing commit groups
    let co_changes = git_repo.co_changing_commits(since_ts)?;
    if co_changes.is_empty() {
        eprintln!("No commits with multiple files found.");
        return Ok(());
    }

    let mut results = compute_coupling(&co_changes, &freq_map, min_degree);

    // Filter by min_strength if specified
    if let Some(min_s) = min_strength {
        results.retain(|r| r.strength >= min_s);
    }

    let total = results.len();

    // Sort by chosen metric
    match sort_by {
        "shared" => results.sort_by(|a, b| b.shared_commits.cmp(&a.shared_commits)),
        _ => results.sort_by(|a, b| {
            b.strength
                .partial_cmp(&a.strength)
                .unwrap_or(std::cmp::Ordering::Equal)
        }),
    }

    results.truncate(top);

    if json {
        print_json(&results)?;
    } else {
        print_report(&results, total);
    }

    Ok(())
}

#[cfg(test)]
#[path = "mod_test.rs"]
mod tests;