fta 3.0.0

Fast TypeScript Analyzer
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
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

use clap::Parser;
use fta::analyze;
use fta::config::read_config;
use std::time::Instant;

#[cfg(feature = "use_output")]
use fta::output::generate_output;

#[derive(Parser, Debug)]
#[command(author, version, about, long_about = None)]
struct Cli {
    #[arg(required = true, help = "Path to the project to analyze")]
    project: String,

    #[arg(long, short, help = "Path to config file")]
    config_path: Option<String>,

    #[arg(
        long,
        short,
        default_value = "table",
        value_parser(["table", "csv", "json"]),
        help = "Output format (default: table)",
        conflicts_with = "json"
    )]
    format: String,

    #[arg(long, help = "Output as JSON.", conflicts_with = "format")]
    json: bool,

    #[arg(
        long,
        short,
        help = "Maximum number of files to include in the table output (only applies when using table output) (default: 5000)"
    )]
    output_limit: Option<usize>,

    #[arg(
        long,
        short,
        help = "Maximum FTA score which will cause FTA to throw (default: 1000)"
    )]
    score_cap: Option<usize>,

    #[arg(
        long,
        short,
        help = "Whether to include code comments when analysing (default: false)"
    )]
    include_comments: Option<bool>,

    #[arg(
        long,
        short,
        help = "Minimum number of lines of code for files to be included in output (default: 6)"
    )]
    exclude_under: Option<usize>,
}

pub fn main() {
    // Start tracking execution time
    let start = Instant::now();

    let cli = Cli::parse();

    // Resolve the fta.json path, which can optionally be used-supplied
    let (config_path, path_specified_by_user) = match cli.config_path {
        Some(config_path_arg) => (config_path_arg, true),
        None => (format!("{}/fta.json", cli.project), false),
    };

    // Resolve the input config. Optionally adds fta.json values to the default config.
    let mut config = match read_config(config_path, path_specified_by_user) {
        Ok(config) => config,
        Err(err) => {
            eprintln!("{}", err);
            std::process::exit(1);
        }
    };

    // Override config with CLI args where allowed + values are provided
    if let Some(value) = cli.output_limit {
        config.output_limit = value;
    }
    if let Some(value) = cli.score_cap {
        config.score_cap = value;
    }
    if let Some(value) = cli.include_comments {
        config.include_comments = value;
    }
    if let Some(value) = cli.exclude_under {
        config.exclude_under = value;
    }

    // Execute the analysis
    let mut findings = analyze(&cli.project, &config);

    // Sort the result for display
    findings.sort_unstable_by(|a, b| b.fta_score.partial_cmp(&a.fta_score).unwrap());

    // Execution finished, capture elapsed time
    let elapsed = start.elapsed().as_secs_f64();
    #[cfg(feature = "use_output")]
    {
        // Format and display the results
        let output = generate_output(
            &findings,
            if cli.json {
                "json".to_string()
            } else {
                cli.format
            },
            &elapsed,
            config.output_limit,
        );

        println!("{}", output);
    }
}