atac 0.20.0

Arguably a Terminal API Client. Feature-full, free, open-source, offline and account-less.
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

use std::fs::{File, OpenOptions};
use clap_verbosity_flag::log::LevelFilter;
use tracing::{trace};
use tracing_log::{AsTrace};
use tracing_subscriber::layer::{SubscriberExt};
use tracing_subscriber::util::SubscriberInitExt;
use crate::app::app::App;
use crate::app::log::LogCounterLayer;
use crate::cli::args::{ARGS, Command};
use crate::panic_error;
use crate::app::startup::startup::AppMode::{CLI, TUI};
use crate::models::collection::CollectionFileFormat;

pub enum AppMode {
    TUI,
    CLI(Command),
}

impl<'a> App<'a> {
    /// Method called before running the app, returns the app if the TUI should be started
    pub fn startup(&mut self) -> AppMode {
        // Logging is initialized before anything else
        match ARGS.command.is_some() {
            // CLI
            true => tracing_subscriber::fmt()
                .pretty()
                .with_max_level(ARGS.verbosity.log_level_filter().as_trace())
                .with_file(false)
                .with_line_number(false)
                .with_ansi(ARGS.ansi_log)
                .init(),
            // TUI
            false => {
                let verbosity = match ARGS.verbosity.log_level_filter() {
                    LevelFilter::Error => LevelFilter::Debug, // Ensure that at least the debug level is always active
                    level => level
                };
                
                // Using a separate file allows to redirect the output and avoid printing to screen
                let log_file = self.create_log_file();

                tracing_subscriber::fmt()
                    .with_max_level(verbosity.as_trace())
                    .with_writer(log_file)
                    .with_file(false)
                    .with_line_number(false)
                    .with_ansi(ARGS.ansi_log)
                    .finish()
                    .with(LogCounterLayer)
                    .init();
            }
        };

        if ARGS.should_parse_directory {
            self.parse_app_directory();
        }

        if let Some(command) = &ARGS.command {
            CLI(command.clone())
        }
        else {
            self.parse_key_bindings_file();
            self.parse_theme_file();
            
            TUI
        }
    }

    fn parse_app_directory(&mut self) {
        let paths = match ARGS.directory.as_ref().unwrap().read_dir() {
            Ok(paths) => paths,
            Err(e) => panic_error(format!("Directory \"{}\" not found\n\t{e}", ARGS.directory.as_ref().unwrap().display()))
        };

        for path in paths {
            let path = path.unwrap().path();

            if path.is_dir() {
                continue;
            }

            let file_name = path.file_name().unwrap().to_str().unwrap();

            trace!("Checking file \"{}\"", path.display());

            if file_name.ends_with(".json") {
                self.set_collections_from_file(path, CollectionFileFormat::Json);
            }
            else if file_name.ends_with(".yaml") {
                self.set_collections_from_file(path, CollectionFileFormat::Yaml);
            }
            else if file_name.starts_with(".env.") {
                self.add_environment_from_file(path)
            }
            else if file_name == "atac.toml" {
                self.parse_config_file(path);
            }
            else if file_name == "atac.log" {
                trace!("Log file is not parsable")
            }
        }
        
        self.collections.sort_by(|a,b| a.last_position.unwrap_or(usize::MAX).cmp(&b.last_position.unwrap_or(usize::MAX)));
    }

    fn create_log_file(&mut self) -> File {
        let path = ARGS.directory.as_ref().unwrap().join("atac.log");

        let log_file = match OpenOptions::new().write(true).create(true).truncate(true).open(path) {
            Ok(log_file) => log_file,
            Err(e) => panic_error(format!("Could not open log file\n\t{e}"))
        };

        return log_file;
    }
}