nolo 0.1.0

A CLI tool for discovering and analyzing `TODO` comments across codebases.
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
120
121
122
123
124
125

mod analytics;
mod cli;
pub mod comment;
mod config;
mod discover;
mod error;
mod log;
mod report;

use clap::Parser;

use crate::cli::{CliArgs, CommandType};
use crate::config::Config;
use crate::discover::discover;
use tracing::{debug, trace};

fn main() {
    let args = CliArgs::parse();
    log::init().expect("Failed to initialize logging");

    let config = match Config::load(args.config.as_deref()) {
        Ok(config) => config,
        Err(e) => {
            eprintln!("Error loading configuration: {}", e);
            std::process::exit(1);
        }
    };

    let (command_type, scan_path) = args.get_command_and_path(&config);

    match command_type {
        CommandType::Scan => {
            trace!("Starting nolo TODO comment scan");
            run_scan(&scan_path, &config);
        }
        CommandType::Report => {
            trace!("Starting nolo TODO analytics report");
            let format = args.get_report_format(&config);
            let display_limit = args.get_display_limit(&config);
            run_report(&scan_path, format, display_limit, &config);
        }
    }
}

fn run_scan(scan_path: &std::path::Path, config: &Config) {
    let paths = match discover(scan_path) {
        Ok(paths) => paths,
        Err(e) => {
            eprintln!("Error: {}", e);
            std::process::exit(1);
        }
    };

    let keywords = config.get_keywords();

    for path in paths {
        debug!("Reading content from: {:?}", path);

        let todo_comments =
            comment::extract_todo_comments_with_language_detection(path.clone(), &keywords);
        if !todo_comments.is_empty() {
            debug!("Found {} TODO comments in {:?}", todo_comments.len(), path);
            for todo in todo_comments {
                let relative_path = report::get_relative_path(&path, scan_path);
                println!("{}:{}: {}", relative_path, todo.line, todo.text);
            }
        }
    }
}

fn run_report(
    scan_path: &std::path::Path,
    format: crate::cli::ReportFormat,
    display_limit: Option<usize>,
    config: &Config,
) {
    let mut file_todos = Vec::new();
    let mut total_files = 0;

    let paths = match discover(scan_path) {
        Ok(paths) => paths,
        Err(e) => {
            eprintln!("Error: {}", e);
            std::process::exit(1);
        }
    };

    let keywords = config.get_keywords();

    for path in paths {
        debug!("Reading content from: {:?}", path);
        total_files += 1;

        let todo_comments =
            comment::extract_todo_comments_with_language_detection(path.clone(), &keywords);
        file_todos.push((path, todo_comments));
    }

    let analytics = analytics::analyze_todos(
        file_todos,
        total_files,
        scan_path.to_path_buf(),
        display_limit,
        &keywords,
    );

    match format {
        crate::cli::ReportFormat::Table => {
            report::print_table_report(&analytics);
        }
        crate::cli::ReportFormat::Json => {
            print_json_report(&analytics);
        }
    }
}

fn print_json_report(analytics: &analytics::TodoAnalytics) {
    match serde_json::to_string_pretty(analytics) {
        Ok(json) => println!("{}", json),
        Err(e) => {
            eprintln!("Error serializing to JSON: {}", e);
            std::process::exit(1);
        }
    }
}