kimun 0.26.0

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

/// Author summary analysis — who owns what across the codebase.
///
/// Walks source files, runs git blame on each, and aggregates per-author:
/// files owned (primary contributor), total lines, languages, last active date.
pub mod analyzer;
mod report;

use std::error::Error;

use crate::cli::OutputMode;
use crate::git::GitRepo;
use crate::util::parse_since;
use crate::walk::{self, WalkConfig};
use analyzer::compute_authors;
use report::{print_json, print_report, print_short, print_terse};

/// Run author summary analysis and print results.
pub fn run(
    cfg: &WalkConfig<'_>,
    output: OutputMode,
    since: Option<&str>,
) -> Result<(), Box<dyn Error>> {
    let git = GitRepo::open(cfg.path)
        .map_err(|e| format!("not a git repository (or any parent): {e}"))?;

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

    let (walk_root, prefix) = git.walk_prefix(cfg.path)?;

    // Collect all (language, blames) pairs across source files.
    let mut file_blames: Vec<(String, Vec<crate::git::BlameInfo>)> = Vec::new();

    for (file_path, spec) in walk::source_files(&walk_root, cfg.exclude_tests(), cfg.filter) {
        let rel = GitRepo::to_git_path(&walk_root, &prefix, &file_path);
        let mut blames = match git.blame_file(&rel) {
            Ok(b) => b,
            Err(e) => {
                eprintln!("warning: blame {}: {e}", rel.display());
                continue;
            }
        };

        // Filter to lines last touched since the cutoff.
        if let Some(ts) = since_ts {
            blames.retain(|b| b.last_commit_time >= ts);
            if blames.is_empty() {
                continue;
            }
        }

        file_blames.push((spec.name.to_string(), blames));
    }

    if file_blames.is_empty() {
        if output == OutputMode::Json {
            println!("[]");
        } else {
            println!("No authors found.");
        }
        return Ok(());
    }

    let refs: Vec<(&str, &[crate::git::BlameInfo])> = file_blames
        .iter()
        .map(|(lang, blames)| (lang.as_str(), blames.as_slice()))
        .collect();

    let authors = compute_authors(&refs);

    match output {
        OutputMode::Json => print_json(&authors),
        OutputMode::Short => print_short(&authors),
        OutputMode::Terse => print_terse(&authors),
        OutputMode::Github | OutputMode::Codeclimate => {
            return Err(crate::cli::ERR_CI_FORMAT_ONLY.into());
        }
        OutputMode::Table => print_report(&authors),
    }

    Ok(())
}

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