techscan 1.0.2

A tool for analyzing and visualizing technology stacks in codes.
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
80

mod cli;
mod config;
mod entity;
mod service;

use crate::cli::{Cli, Commands};
use crate::config::REPORTER_FORMAT_TABLE;
use crate::entity::LanguageScannerOptions;
use crate::service::{ConfigBuilder, LanguageReporter, LanguageScanner};

fn main() {
    let cli = Cli::new().unwrap_or_else(|e| {
        eprintln!("Failed initializing CLI: {}", e);
        std::process::exit(1);
    });

    match &cli.command {
        Commands::Language {
            dir,
            exclude,
            reporter,
            config,
        } => {
            handle_language_command(dir, exclude, reporter, config);
        }
    }
}

fn handle_language_command(
    dir: &str,
    exclude: &Option<Vec<String>>,
    reporter: &Option<String>,
    config: &Option<String>,
) {
    let config_builder = ConfigBuilder::from_cli_args(exclude, reporter)
        .merge_file_config(config)
        .unwrap_or_else(|error_msg| {
            eprintln!("Error: {}", error_msg);
            std::process::exit(1);
        });

    let final_config = config_builder.build();

    let reporter_format = final_config
        .reporter
        .as_deref()
        .unwrap_or(REPORTER_FORMAT_TABLE);

    LanguageReporter::validate_format(reporter_format).unwrap_or_else(|e| {
        eprintln!("Error: {}", e);
        std::process::exit(1);
    });

    let opts = LanguageScannerOptions {
        exclude: final_config.exclude.unwrap_or_default(),
    };

    let scanner = LanguageScanner::new(dir, Some(opts)).unwrap_or_else(|e| {
        eprintln!("Error initializing scanner: {}", e);
        std::process::exit(1);
    });

    println!("Processing directory: {}", dir);

    let files = scanner.scan().unwrap_or_else(|e| {
        eprintln!("Error scanning directory: {}", e);
        std::process::exit(1);
    });

    let report = scanner.analyze(files);

    let reporter = LanguageReporter::new();

    reporter
        .output(&report, reporter_format)
        .unwrap_or_else(|e| {
            eprintln!("Error outputting report: {}", e);
            std::process::exit(1);
        });
}