kimun 0.20.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
86
87
88
89
90
91
92
93
94
95
96
97
98
99

/// Report formatters for author summary analysis.
use chrono::{DateTime, Utc};
use serde::Serialize;

use super::analyzer::AuthorSummary;
use crate::report_helpers;

const COL_OWNED: usize = 7;
const COL_LINES: usize = 10;
const COL_DATE: usize = 11;

/// Format a Unix timestamp as `YYYY-MM-DD`.
fn format_date(ts: i64) -> String {
    DateTime::<Utc>::from_timestamp(ts, 0)
        .map(|dt| dt.format("%Y-%m-%d").to_string())
        .unwrap_or_else(|| "unknown".to_string())
}

/// Print a table of per-author summaries sorted by lines descending.
pub fn print_report(authors: &[AuthorSummary]) {
    if authors.is_empty() {
        println!("No authors found.");
        return;
    }

    let col_author = authors
        .iter()
        .map(|a| report_helpers::display_width(a.name.as_str()))
        .max()
        .unwrap_or(0)
        .max(report_helpers::display_width("Author"));

    let col_langs = authors
        .iter()
        .map(|a| a.languages.join(", ").len())
        .max()
        .unwrap_or(0)
        .max("Languages".len());

    let sep_width = 1 + col_author + 1 + COL_OWNED + 1 + COL_LINES + 2 + col_langs + 1 + COL_DATE;
    let separator = report_helpers::separator(sep_width);

    println!("{separator}");
    println!(
        " {} {:>COL_OWNED$} {:>COL_LINES$}  {:<col_langs$} {:>COL_DATE$}",
        report_helpers::pad_to("Author", col_author),
        "Owned",
        "Lines",
        "Languages",
        "Last Active",
    );
    println!("{separator}");

    for a in authors {
        let langs = a.languages.join(", ");
        println!(
            " {} {:>COL_OWNED$} {:>COL_LINES$}  {:<col_langs$} {:>COL_DATE$}",
            report_helpers::pad_to(&a.name, col_author),
            a.owned_files,
            a.lines,
            langs,
            format_date(a.last_active),
        );
    }

    println!("{separator}");
}

/// JSON-serializable representation of a single author summary.
#[derive(Serialize)]
struct JsonEntry<'a> {
    name: &'a str,
    email: &'a str,
    owned_files: usize,
    lines: usize,
    languages: &'a [String],
    last_active: String,
}

/// Serialize author summaries as pretty-printed JSON to stdout.
pub fn print_json(authors: &[AuthorSummary]) {
    let entries: Vec<JsonEntry<'_>> = authors
        .iter()
        .map(|a| JsonEntry {
            name: &a.name,
            email: &a.email,
            owned_files: a.owned_files,
            lines: a.lines,
            languages: &a.languages,
            last_active: format_date(a.last_active),
        })
        .collect();

    report_helpers::print_json_stdout(&entries).unwrap();
}

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