sourceatlas 0.2.0

Analyze source code repositories and generate project statistics
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

use std::collections::HashMap;

use crate::{file_stats::FileStats, language::Language};

#[derive(Default)]
pub struct Report {
    files: Vec<FileAnalysis>,
    is_git_repo: bool,
    total_directories_scanned: usize,
    total_files_scanned: usize,
    total_files_analyzed: usize,
    total_files_skipped: usize,
    total_lines: usize,
}

impl Report {
    pub fn new() -> Self {
        Self::default()
    }

    pub fn add_file(&mut self, file: FileAnalysis) {
        self.total_files_analyzed += 1;
        self.total_lines += file.stats.total_lines;
        self.files.push(file);
    }

    pub fn record_git_repo(&mut self) {
        self.is_git_repo = true;
    }

    pub fn record_directory_found(&mut self) {
        self.total_directories_scanned += 1;
    }

    pub fn record_file_found(&mut self) {
        self.total_files_scanned += 1;
    }

    pub fn record_skipped_file(&mut self) {
        self.total_files_skipped += 1
    }

    pub fn language_totals(&self) -> HashMap<Language, LanguageTotals> {
        let mut totals = HashMap::new();
        for file_report in &self.files {
            let entry = totals
                .entry(file_report.language)
                .or_insert(LanguageTotals::default());
            entry.lines += file_report.stats.total_lines;
        }
        totals
    }

    #[cfg(test)]
    pub fn total_files_found(&self) -> usize {
        self.total_files_scanned
    }

    #[cfg(test)]
    pub fn total_files_skipped(&self) -> usize {
        self.total_files_skipped
    }

    #[cfg(test)]
    pub fn total_files_analyzed(&self) -> usize {
        self.total_files_analyzed
    }

    #[cfg(test)]
    pub fn total_directories_found(&self) -> usize {
        self.total_directories_scanned
    }

    pub fn print_full_report(&self) {
        println!("-------------");
        println!("|SourceAtlas|");
        println!("-------------");
        println!("");
        if self.is_git_repo {
            println!("Scanning Git repo")
        }
        println!("");

        println!("LANGUAGE STATS");
        let language_totals = self.language_totals();
        for (language, totals) in language_totals {
            let percentage = (totals.lines as f64 / self.total_lines as f64) * 100.0;
            println!("{}: {:.1}%", language, percentage);
        }
        println!("");

        println!("DIRECTORIES");
        println!("--------");
        println!("total directories: {}", self.total_directories_scanned);
        println!("");

        // TODO: Decided if I can remove these in the future
        println!("TOTALS");
        println!("--------");
        println!("total files found: {}", self.total_files_scanned);
        println!("total files analyzed: {}", self.total_files_analyzed);
        println!("total files skipped: {}", self.total_files_skipped);
        println!("total lines: {}", self.total_lines);
    }
}

pub struct FileAnalysis {
    language: Language,
    stats: FileStats,
}

impl FileAnalysis {
    pub fn new(language: Language, stats: FileStats) -> Self {
        Self { language, stats }
    }
}

#[derive(Default)]
pub struct LanguageTotals {
    pub lines: usize,
}