rta-core 0.1.0

Core analyzers and report model for the Rust Technical Audit Toolkit
Documentation 
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

use std::collections::BTreeMap;

use crate::{
    analyzers::Analyzer,
    collector::RepositorySnapshot,
    model::{LanguageStat, Overview},
};

pub struct OverviewAnalyzer;

impl Analyzer<Overview> for OverviewAnalyzer {
    fn analyze(&self, snapshot: &RepositorySnapshot) -> Overview {
        let mut language_map: BTreeMap<String, (usize, usize)> = BTreeMap::new();
        for file in &snapshot.files {
            let language = language_for(file.extension.as_deref());
            let entry = language_map.entry(language.to_string()).or_default();
            entry.0 += 1;
            entry.1 += file.lines;
        }

        let languages = language_map
            .into_iter()
            .map(|(language, (files, lines))| LanguageStat {
                language,
                files,
                lines,
            })
            .collect::<Vec<_>>();
        let workspace_members = snapshot
            .manifests
            .iter()
            .flat_map(|manifest| manifest.workspace_members.clone())
            .collect::<Vec<_>>();
        let package_count = snapshot
            .manifests
            .iter()
            .filter(|manifest| manifest.package_name.is_some())
            .count();
        let total_bytes = snapshot.files.iter().map(|file| file.bytes).sum();
        let crate_count = package_count.max(workspace_members.len());
        let cargo_configs = snapshot
            .manifests
            .iter()
            .map(|manifest| manifest.relative_path.clone())
            .collect::<Vec<_>>();
        let summary = if workspace_members.is_empty() {
            format!("Single-package Rust repository with {package_count} Cargo manifest(s).")
        } else {
            format!(
                "Cargo workspace with {} declared member(s) and {package_count} package manifest(s).",
                workspace_members.len()
            )
        };

        Overview {
            crate_count,
            package_count,
            workspace_members,
            total_files: snapshot.files.len(),
            total_bytes,
            languages,
            cargo_configs,
            summary,
        }
    }
}

fn language_for(extension: Option<&str>) -> &'static str {
    match extension {
        Some("rs") => "Rust",
        Some("toml") => "TOML",
        Some("md") => "Markdown",
        Some("yml") | Some("yaml") => "YAML",
        Some("json") => "JSON",
        Some("sh") => "Shell",
        Some("js") | Some("ts") => "JavaScript/TypeScript",
        _ => "Other",
    }
}