Added a global config file

Author: Julien-cpsn

src/app/business_logic/request/export.rs

@@ -294,7 +294,7 @@ impl App<'_> {
         };
 
         if request.settings.use_config_proxy.as_bool() {
-            if let Some(proxy) = &self.config.proxy {
+            if let Some(proxy) = &self.config.get_proxy() {
                 let mut proxy_output = String::from("--proxy ");
 
                 if let Some(http_proxy) = &proxy.http_proxy {
@@ -354,7 +354,7 @@ impl App<'_> {
         /* Proxy */
 
         if request.settings.use_config_proxy.as_bool() {
-            if let Some(proxy) = &self.config.proxy {
+            if let Some(proxy) = &self.config.get_proxy() {
                 let mut proxy_output = String::from("\n    'proxy' => [");
 
                 if let Some(http_proxy) = &proxy.http_proxy {
@@ -574,7 +574,7 @@ impl App<'_> {
 
         /* Proxy */
         if request.settings.use_config_proxy.as_bool() {
-            if let Some(proxy) = &self.config.proxy {
+            if let Some(proxy) = &self.config.get_proxy() {
                 output += ",\n  proxy: {";
 
                 if let Some(http_proxy) = &proxy.http_proxy {
@@ -754,7 +754,7 @@ impl App<'_> {
                 output += "    let status = response.status();\n";
                 output += "    let body = response.text().await?;\n\n";
 
-                if request.settings.use_config_proxy.as_bool() && self.config.proxy.is_some() {
+                if request.settings.use_config_proxy.as_bool() && self.config.get_proxy().is_some() {
                     output += "    // Use reqwest::ClientBuilder with reqwest::Proxy\n";
                     output += "    // https://docs.rs/reqwest/latest/reqwest/struct.Proxy.html\n\n";
                 }

src/app/business_logic/request/send.rs

@@ -73,7 +73,7 @@ impl App<'_> {
         /* PROXY */
 
         if request.settings.use_config_proxy.as_bool() {
-            match &self.config.proxy {
+            match &self.config.get_proxy() {
                 None => {}
                 Some(proxy) => {
                     match &proxy.http_proxy {

src/app/files/config.rs

@@ -54,7 +54,7 @@ pub struct Proxy {
 
 impl Config {
     pub fn is_syntax_highlighting_disabled(&self) -> bool {
-        return self.disable_syntax_highlighting.unwrap_or(false)
+        self.disable_syntax_highlighting.unwrap_or(false)
     }
 
     pub fn should_save_requests_response(&self) -> bool {
@@ -68,19 +68,19 @@ impl Config {
     }
 
     pub fn is_cors_disabled(&self) -> bool {
-        return self.disable_cors.unwrap_or(false)
+        self.disable_cors.unwrap_or(false)
     }
 
     pub fn is_image_preview_disabled(&self) -> bool {
-        return self.disable_images_preview.unwrap_or(false)
+        self.disable_images_preview.unwrap_or(false)
     }
 
     pub fn is_graphical_protocol_disabled(&self) -> bool {
-        return self.disable_graphical_protocol.unwrap_or(false)
+        self.disable_graphical_protocol.unwrap_or(false)
     }
 
     pub fn should_wrap_body(&self) -> bool {
-        return self.wrap_responses.unwrap_or(false)
+        self.wrap_responses.unwrap_or(false)
     }
 
     pub fn get_preferred_collection_file_format(&self) -> CollectionFileFormat {
@@ -89,13 +89,17 @@ impl Config {
             Some(file_format) => file_format.clone()
         }
     }
+
+    pub fn get_proxy(&self) -> &Option<Proxy> {
+        &self.proxy
+    }
 }
 
 impl App<'_> {
     pub fn parse_config_file(&mut self, path_buf: &PathBuf) {
         let mut file_content = String::new();
 
-        trace!("Trying to open or create \"atac.toml\" config file");
+        trace!("Trying to open \"atac.toml\" config file");
 
         let mut config_file = OpenOptions::new()
             .read(true)
@@ -116,4 +120,60 @@ impl App<'_> {
 
         trace!("Config file parsed!");
     }
+
+    pub fn parse_global_config_file(&mut self, path_buf: &PathBuf) {
+        let mut file_content = String::new();
+
+        trace!("Trying to open \"{}\" global config file", path_buf.display());
+
+        let mut global_config_file = OpenOptions::new()
+            .read(true)
+            .open(path_buf.clone())
+            .expect("\tCould not open global config file");
+
+        global_config_file.read_to_string(&mut file_content).expect("\tCould not read global config file");
+
+        let global_config: Config = match toml::from_str(&file_content) {
+            Ok(config) => config,
+            Err(e) => panic_error(format!("Could not parse config file\n\t{e}"))
+        };
+
+        // Replace an attribute if it is not set
+
+        if self.config.disable_syntax_highlighting.is_none() {
+            self.config.disable_syntax_highlighting = global_config.disable_syntax_highlighting;
+        }
+
+        if self.config.save_requests_response.is_none() {
+            self.config.save_requests_response = global_config.save_requests_response;
+        }
+
+        if self.config.disable_cors.is_none() {
+            self.config.disable_cors = global_config.disable_cors;
+        }
+
+        if self.config.disable_images_preview.is_none() {
+            self.config.disable_images_preview = global_config.disable_images_preview;
+        }
+
+        if self.config.disable_graphical_protocol.is_none() {
+            self.config.disable_graphical_protocol = global_config.disable_graphical_protocol;
+        }
+
+        if self.config.wrap_responses.is_none() {
+            self.config.wrap_responses = global_config.wrap_responses;
+        }
+
+        if self.config.preferred_collection_file_format.is_none() {
+            self.config.preferred_collection_file_format = global_config.preferred_collection_file_format;
+        }
+
+        if self.config.proxy.is_none() {
+            self.config.proxy = global_config.proxy;
+        }
+
+        self.config.set_should_skip_requests_response();
+
+        trace!("Global config file parsed!");
+    }
 }

src/app/startup/startup.rs

@@ -111,6 +111,15 @@ impl<'a> App<'a> {
             }
         }
 
+        // Check if the global config file exists
+        if let Some(config_directory) = &ARGS.config_directory {
+            let global_config_file_path = config_directory.join("global.toml");
+            
+            if global_config_file_path.exists() {
+                self.parse_global_config_file(&global_config_file_path);
+            }
+        }
+
         // Ensures that legacy collections and requests gets save as their new version
         if ARGS.should_save {
             for index in 0..self.collections.len() {

src/cli/args.rs

@@ -122,7 +122,9 @@ pub enum Command {
 lazy_static! {
     pub static ref ARGS: GlobalArgs = {
         let args = Args::parse();
-        
+
+        let config_directory = get_app_config_dir();
+
         let (directory, should_parse_directory) = match &args.command {
             // CLI
             Some(command) => match command.clone() {
@@ -131,14 +133,15 @@ lazy_static! {
                 // Commands that use no dir at all
                 Command::Try(_) => (None, false),
                 // Commands that use the app dir
-                _ => (Some(choose_app_directory(args.directory)), true)
+                _ => (Some(choose_app_directory(args.directory, &config_directory)), true)
             },
             // TUI
-            None => (Some(choose_app_directory(args.directory)), true) 
+            None => (Some(choose_app_directory(args.directory, &config_directory)), true)
         };
 
         GlobalArgs {
             directory,
+            config_directory,
             command: args.command,
             collection_filter: args.filter,
             should_run_tui: args.tui,
@@ -150,7 +153,27 @@ lazy_static! {
     };
 }
 
-fn choose_app_directory(path_buf: Option<PathBuf>) -> PathBuf {
+fn get_app_config_dir() -> Option<PathBuf> {
+    let project_directory = ProjectDirs::from("com", "Julien-cpsn", "ATAC");
+
+    let config_directory = match project_directory {
+        Some(project_directory) => {
+            let config_directory = project_directory.config_dir().to_path_buf();
+
+            // Create the config dir if it does not exist
+            if !config_directory.exists() {
+                fs::create_dir_all(&config_directory).expect(&format!("Could not recursively create folder \"{}\"", config_directory.display()));
+            }
+
+            Some(config_directory)
+        },
+        None => None
+    };
+
+    return config_directory;
+}
+
+fn choose_app_directory(path_buf: Option<PathBuf>, config_directory: &Option<PathBuf>) -> PathBuf {
     match path_buf {
         // If a directory was provided with the CLI argument
         Some(directory) => expand_tilde(directory),
@@ -161,16 +184,8 @@ fn choose_app_directory(path_buf: Option<PathBuf>) -> PathBuf {
             Ok(env_directory) => expand_tilde(PathBuf::from(env_directory)),
 
             // No ATAC_MAIN_DIR env variable
-            Err(_) => match ProjectDirs::from("com", "Julien-cpsn", "ATAC") {
-                Some(project_dir) => {
-                    let config_dir = project_dir.config_dir();
-                    
-                    if !config_dir.exists() {
-                        fs::create_dir_all(config_dir).expect(&format!("Could not recursively create folder \"{}\"", config_dir.display()));
-                    }
-                    
-                    config_dir.to_path_buf()
-                },
+            Err(_) => match config_directory {
+                Some(config_directory) => config_directory.clone(),
                 None => panic_error("No directory provided, provide one either with `--directory <dir>` or via the environment variable `ATAC_MAIN_DIR`")
             }
         }
@@ -180,6 +195,7 @@ fn choose_app_directory(path_buf: Option<PathBuf>) -> PathBuf {
 #[derive(Debug)]
 pub struct GlobalArgs {
     pub directory: Option<PathBuf>,
+    pub config_directory: Option<PathBuf>,
     pub command: Option<Command>,
     pub collection_filter: Option<Regex>,
     pub should_run_tui: bool,