locc 1.1.0

CLI for counting lines of code per language
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
115
116
117
118
119
120
121
122
123

pub const BAR_CHAR: &str = "█";
pub const LIST_CHAR: &str = "█";
pub const SEP_CHAR: &str = "━";
pub const BAR_WIDTH: usize = 50;

pub struct Mode {
    pub show_bar: bool,
    pub show_header: bool,
    pub show_lines: bool,
    pub show_pct: bool,
}

fn ansi_fg(r: u8, g: u8, b: u8) -> String {
    format!("\x1b[38;2;{};{};{}m", r, g, b)
}

const RESET: &str = "\x1b[0m";

fn colored(text: &str, r: u8, g: u8, b: u8) -> String {
    format!("{}{}{}", ansi_fg(r, g, b), text, RESET)
}

pub fn display(entries: &[(&str, usize, (u8, u8, u8))], total: usize, mode: &Mode) {
    if mode.show_bar {
        print_bar(entries, total);
    }

    if !mode.show_lines && !mode.show_pct {
        return;
    }

    let max_name = entries
        .iter()
        .map(|(n, _, _)| n.len())
        .max()
        .unwrap_or(0)
        .max("Language".len());
    let line_width = if mode.show_lines {
        entries
            .iter()
            .map(|(_, l, _)| l)
            .max()
            .unwrap_or(&0)
            .to_string()
            .len()
            .max("Lines".len())
    } else {
        0
    };
    let pct_width = if mode.show_pct {
        entries
            .iter()
            .map(|(_, l, _)| format!("{:.1}%", *l as f64 / total as f64).len())
            .max()
            .unwrap_or(0)
            .max("Percentage".len())
    } else {
        0
    };

    if mode.show_header {
        print_header(max_name, line_width, pct_width, mode);
    }

    for &(name, lines, (r, g, b)) in entries {
        let pct = lines as f64 / total as f64 * 100.0;
        print_row(
            name, lines, pct, max_name, line_width, pct_width, mode, r, g, b,
        );
    }
}

fn print_header(name_w: usize, line_w: usize, pct_w: usize, mode: &Mode) {
    let mut cols = vec![format!("{:name_w$}", "Language", name_w = name_w)];
    if mode.show_lines {
        cols.push(format!("{:line_w$}", "Lines", line_w = line_w));
    }
    if mode.show_pct {
        cols.push(format!("{:pct_w$}", "Percentage", pct_w = pct_w));
    }
    if mode.show_bar {
        println!("   {}", cols.join("  "));
    } else {
        println!("{}", cols.join("  "));
    }
}

fn print_row(
    name: &str,
    lines: usize,
    pct: f64,
    name_w: usize,
    line_w: usize,
    pct_w: usize,
    mode: &Mode,
    r: u8,
    g: u8,
    b: u8,
) {
    let mut cols = vec![format!("{:name_w$}", name, name_w = name_w)];
    if mode.show_lines {
        cols.push(format!("{:<line_w$}", lines, line_w = line_w));
    }
    if mode.show_pct {
        cols.push(format!("{:pct_w$}", format!("{:.1}%", pct), pct_w = pct_w));
    }
    if mode.show_bar {
        println!("{}  {}", colored(LIST_CHAR, r, g, b), cols.join("  "));
    } else {
        println!("{}", cols.join("  "));
    }
}

fn print_bar(entries: &[(&str, usize, (u8, u8, u8))], total: usize) {
    for &(_, lines, (r, g, b)) in entries {
        let count = (lines as f64 / total as f64 * BAR_WIDTH as f64).round() as usize;
        for _ in 0..count {
            print!("{}", colored(BAR_CHAR, r, g, b));
        }
    }
    println!();
    println!("{}", SEP_CHAR.repeat(BAR_WIDTH));
}