atac 0.11.3

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

use std::fs;
use std::fs::OpenOptions;
use crate::app::app::App;
use crate::app::startup::args::{ARGS, Command};

impl App<'_> {
    /// Method called before running the app
    pub fn startup(&mut self) -> &mut Self {
        self.parse_app_directory();

        if let Some(command) = &ARGS.command {
            match command {
                Command::Import(import_args) => {
                    self.import_postman_collection(&import_args.path, import_args.max_depth.unwrap_or(99));
                }
            }
        }
        
        self
    }

    pub fn parse_app_directory(&mut self) {
        // Create the app directory if it does not exist
        fs::create_dir_all(&ARGS.directory).expect(&format!("Could not create directory \"{}\"", ARGS.directory.display()));
        
        let paths = ARGS.directory.read_dir().expect(&format!("Directory \"{}\" not found", ARGS.directory.display()));

        let mut was_config_file_parsed = false;

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

            if path.is_dir() {
                continue;
            }

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

            println!("Parsing: {}", path.display());

            if file_name.ends_with(".json") {
                self.set_collections_from_file(path);
            }
            else if file_name.starts_with(".env.") {
                self.add_environment_from_file(path)
            }
            else if file_name == "atac.toml" {
                self.parse_config_file(path);
                was_config_file_parsed = true;
            }
            else if file_name == "atac.log" {
                println!("Nothing to parse here")
            }
            else {
                panic!("unhandled file type");
            }

            println!();
        }

        self.log_file = Some(
            OpenOptions::new()
                .write(true)
                .create(true)
                .truncate(true)
                .open(ARGS.directory.join("atac.log"))
                .expect("Could not open log file")
        );
        
        if !was_config_file_parsed {
            self.parse_config_file(ARGS.directory.join("atac.toml"));
        }
    }
}