cha-cli 0.6.5

Cha — pluggable code smell detection CLI (察)
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

use std::collections::HashMap;
use std::path::PathBuf;
use std::process::Command;

use cha_core::SourceFile;

use crate::Format;

/// Hotspot = git change frequency × code complexity.
///
/// ## References
///
/// [1] A. Tornhill, "Your Code as a Crime Scene," Pragmatic Bookshelf, 2015.
///     doi: 10.1007/978-1-4842-1628-2.

#[derive(serde::Serialize)]
struct Hotspot {
    path: String,
    commits: usize,
    complexity: usize,
    score: f64,
}

pub fn cmd_hotspot(count: usize, top: usize, format: &Format) {
    let freq = git_change_frequency(count);
    if freq.is_empty() {
        println!("No git history found.");
        return;
    }

    let mut hotspots: Vec<Hotspot> = freq
        .into_iter()
        .filter_map(|(path, commits)| {
            let complexity = file_complexity(&path)?;
            let score = commits as f64 * complexity as f64;
            Some(Hotspot {
                path,
                commits,
                complexity,
                score,
            })
        })
        .collect();

    hotspots.sort_by(|a, b| {
        b.score
            .partial_cmp(&a.score)
            .unwrap_or(std::cmp::Ordering::Equal)
    });
    hotspots.truncate(top);

    match format {
        Format::Json => println!(
            "{}",
            serde_json::to_string_pretty(&hotspots).unwrap_or_default()
        ),
        _ => print_terminal(&hotspots),
    }
}

fn git_change_frequency(n: usize) -> HashMap<String, usize> {
    let output = Command::new("git")
        .args(["log", "--format=", "--name-only", "-n", &n.to_string()])
        .output()
        .ok();
    let Some(output) = output else {
        return HashMap::new();
    };
    let mut freq = HashMap::new();
    for line in String::from_utf8_lossy(&output.stdout).lines() {
        let line = line.trim();
        if line.is_empty() {
            continue;
        }
        *freq.entry(line.to_string()).or_default() += 1;
    }
    freq
}

fn file_complexity(path: &str) -> Option<usize> {
    let content = std::fs::read_to_string(path).ok()?;
    let file = SourceFile::new(PathBuf::from(path), content);
    let model = cha_parser::parse_file(&file)?;
    let total: usize = model.functions.iter().map(|f| f.complexity).sum();
    Some(total.max(1))
}

fn print_terminal(hotspots: &[Hotspot]) {
    if hotspots.is_empty() {
        return;
    }
    let max_score = hotspots.first().map(|h| h.score).unwrap_or(1.0).max(1.0);
    let width = 30;

    println!("Hotspots (commits × complexity):\n");
    for h in hotspots {
        let bar_len = (h.score / max_score * width as f64) as usize;
        let bar: String = "█".repeat(bar_len);
        println!(
            "  {:>5.0} │{} {} ({}c × {}cx)",
            h.score, bar, h.path, h.commits, h.complexity
        );
    }
    println!();
}