rsnip 0.6.1

A universal command-line snippet manager
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
126
127
128
129
130
131
132
133
134
135
136

use clap::Parser;
use crossterm::style::Stylize;
use rsnip::cli::args::Cli;
use rsnip::cli::commands::execute_command;
use rsnip::infrastructure::complete::generate_completion_script;
use rsnip::config::{Settings, SnippetTypeConfig};
use tracing::level_filters::LevelFilter;
use tracing_subscriber::filter::filter_fn;
use tracing_subscriber::fmt::format::FmtSpan;
use tracing_subscriber::layer::SubscriberExt;
use tracing_subscriber::util::SubscriberInitExt;
use tracing_subscriber::{fmt, Layer};

fn main() {
    let cli = Cli::parse();

    setup_logging(cli.debug);

    // Handle generate-config before any other operations
    if cli.generate_config {
        println!("{}", include_str!("default_config.toml"));
        return;
    }

    // Initialize configuration
    let config = match Settings::new() {
        Ok(config) => config,
        Err(e) => {
            eprintln!("{}", format!("Error loading configuration: {}", e).red());
            std::process::exit(1);
        }
    };

    if let Some(shell) = cli.generator {
        if let Err(e) = generate_completion_script(shell, std::io::stdout(), &config) {
            eprintln!(
                "{}",
                format!("Error generating completion script: {}", e).red()
            );
            std::process::exit(1);
        }
        return;
    }

    if cli.info {
        use clap::CommandFactory; // Trait which returns the current command
        if let Some(a) = Cli::command().get_author() {
            println!("AUTHOR: {}", a)
        }
        if let Some(v) = Cli::command().get_version() {
            println!("VERSION: {}", v);
        }
        // Print config file location
        match &config.active_config_path {
            Some(path) => println!("CONFIG: {}", path.display()),
            None => println!("CONFIG: Using default embedded configuration"),
        }
        // Print available snippet types
        println!("\nAvailable snippet types:");
        for (name, cfg) in &config.snippet_types {
            match cfg {
                SnippetTypeConfig::Concrete { description, .. }
                | SnippetTypeConfig::Combined { description, .. } => {
                    if let Some(desc) = description {
                        println!("  {}: {}", name, desc);
                    } else {
                        println!("  {}", name);
                    }
                }
            }
        }
    }

    if let Err(e) = execute_command(&cli, &config) {
        eprintln!("{}", format!("Error: {}", e).red());
        std::process::exit(1);
    }
}

fn setup_logging(verbosity: u8) {
    tracing::debug!("INIT: Attempting logger init from main.rs");

    let filter = match verbosity {
        0 => LevelFilter::WARN,
        1 => LevelFilter::INFO,
        2 => LevelFilter::DEBUG,
        3 => LevelFilter::TRACE,
        _ => {
            eprintln!("Don't be crazy, max is -d -d -d");
            LevelFilter::TRACE
        }
    };

    // Create a noisy module filter (Gotcha: empty matches all!)
    let noisy_modules = ["x"];
    let module_filter = filter_fn(move |metadata| {
        !noisy_modules
            .iter()
            .any(|name| metadata.target().starts_with(name))
    });

    // Create a subscriber with formatted output directed to stderr
    let fmt_layer = fmt::layer()
        .with_writer(std::io::stderr) // Set writer first
        .with_target(true)
        .with_thread_names(false)
        .with_span_events(FmtSpan::ENTER)
        .with_span_events(FmtSpan::CLOSE);

    // Apply filters to the layer
    let filtered_layer = fmt_layer.with_filter(filter).with_filter(module_filter);

    tracing_subscriber::registry().with(filtered_layer).init();

    // Log initial debug level
    match filter {
        LevelFilter::INFO => tracing::info!("Debug mode: info"),
        LevelFilter::DEBUG => tracing::debug!("Debug mode: debug"),
        LevelFilter::TRACE => tracing::debug!("Debug mode: trace"),
        _ => {}
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use tracing::info;

    // https://docs.rs/clap/latest/clap/_derive/_tutorial/index.html#testing
    #[test]
    fn verify_cli() {
        use clap::CommandFactory;
        Cli::command().debug_assert();
        info!("CLI verified");
    }
}