[Ninan] Move conf related logic to separate mod

src/conf.rs

@@ -0,0 +1,44 @@
+use std::error::Error;
+use std::fs;
+use std::path::Path;
+use serde::{Deserialize, Serialize};
+
+use regex::Regex;
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct GGConf {
+    #[serde(alias = "skipDirectories")]
+    #[serde(rename = "skipDirectories")]
+    filter_list: Vec<String>,
+    #[serde(skip)]
+    pub filter_list_regex: Vec<Regex>,
+}
+
+pub fn read_conf_file(conf_file: &str) -> Result<GGConf, Box<dyn Error>> {
+    if Path::new(conf_file).exists() {
+        let file = fs::File::open(conf_file)?;
+        let config: GGConf = serde_yaml::from_reader(file)?;
+        let updated_conf = create_filter_list(config)?;
+        return Ok(updated_conf);
+    }
+    let default = GGConf { filter_list: vec![], filter_list_regex: vec![] };
+    let updated_conf = create_filter_list(default)?;
+    Ok(updated_conf)
+}
+
+fn create_filter_list(conf: GGConf) -> Result<GGConf, Box<dyn Error>> {
+    let mut filter_list = Vec::new();
+    let mut filters = conf.filter_list.clone();
+    let defaults: Vec<String> = [".idea", ".DS_Store"].iter().map(|&s| s.into()).collect();
+    defaults.iter().for_each(|def| {
+        filters.push(def.to_owned());
+    });
+
+    filters.iter().for_each(|ignore| {
+        let re = Regex::new(format!(r".*/{}?*", ignore).as_str()).expect("failed to construct regex");
+        filter_list.push(re);
+    });
+
+    let updated_conf = GGConf { filter_list: conf.filter_list, filter_list_regex: filter_list };
+    Ok(updated_conf)
+}

src/main.rs

@@ -6,21 +6,18 @@ extern crate reqwest;
 extern crate serde_yaml;
 extern crate walkdir;
 
-use std::{fs, process};
-use std::error::Error;
-use std::path::Path;
+use std::process;
 
 use clap::{App, AppSettings, Arg, crate_version};
 use colored::*;
-use regex::Regex;
-use serde::{Deserialize, Serialize};
 
 mod input_args;
 mod status;
 mod create;
 mod fetch;
 mod git;
 mod dir;
+mod conf;
 
 fn main() {
     let app = App::new("Git Governance")
@@ -40,55 +37,19 @@ fn main() {
 
     let args = input_args::InputArgs::parse_inputs(global_matches.clone());
 
-    let conf = read_conf_file(global_matches.value_of("conf").unwrap_or(".ggConf.yaml")).unwrap_or_else(|err| {
+    let conf = conf::read_conf_file(global_matches.value_of("conf").unwrap_or(".ggConf.yaml")).unwrap_or_else(|err| {
         println!("{} {}", "error while reading conf file:".red(), err.to_string().red());
         process::exit(1)
     });
 
     match args.input_command() {
         input_args::InputCommand::Status => {
-            let filter_list = create_filter_list(conf).expect("failed to create filter_list");
-            status::status(args, filter_list)
+            status::status(args, conf.filter_list_regex)
         }
         input_args::InputCommand::Create => create::create(args),
         input_args::InputCommand::Fetch => {
-            let filter_list = create_filter_list(conf).expect("failed to create filter_list");
-            fetch::fetch(args, filter_list)
+            fetch::fetch(args, conf.filter_list_regex)
         }
         input_args::InputCommand::Error => {}
     }
 }
-
-#[derive(Debug, PartialEq, Serialize, Deserialize)]
-pub struct GGConf {
-    #[serde(alias = "skipDirectories")]
-    #[serde(rename = "skipDirectories")]
-    filter_list: Vec<String>,
-}
-
-fn read_conf_file(conf_file: &str) -> Result<GGConf, Box<dyn Error>> {
-    if Path::new(conf_file).exists() {
-        let file = fs::File::open(conf_file)?;
-        let config: GGConf = serde_yaml::from_reader(file)?;
-        return Ok(config);
-    }
-    let default = GGConf { filter_list: vec![] };
-    Ok(default)
-}
-
-fn create_filter_list(conf: GGConf) -> Result<Vec<Regex>, Box<dyn Error>> {
-    let mut filter_list = Vec::new();
-    let mut filters = conf.filter_list.clone();
-    let defaults: Vec<String> = [".idea", ".DS_Store"].iter().map(|&s| s.into()).collect();
-    defaults.iter().for_each(|def| {
-        filters.push(def.to_owned());
-    });
-
-    filters.iter().for_each(|ignore| {
-        let re = Regex::new(format!(r".*/{}?*", ignore).as_str()).expect("failed to construct regex");
-        filter_list.push(re);
-    });
-
-
-    Ok(filter_list)
-}