From f65bd7231a2a99305002c1d8dc5b42b90ed9779f Mon Sep 17 00:00:00 2001
From: Mario Krehl <mario-krehl@gmx.de>
Date: Sat, 9 Dec 2017 22:12:42 +0100
Subject: End of refactor of config handling

---
 src/config.rs | 54 ++++++++++++++++++++++++++++++++++++++----------------
 src/error.rs  |  4 ----
 src/main.rs   | 25 +++++++------------------
 3 files changed, 45 insertions(+), 38 deletions(-)

diff --git a/src/config.rs b/src/config.rs
index 635be32..c2199c4 100644
--- a/src/config.rs
+++ b/src/config.rs
@@ -21,19 +21,6 @@ pub struct LogItemDeser {
     alias : String,
 }
 
-impl LogItemDeser {
-    pub fn file(&self) -> String {
-        self.file.clone()
-    }
-    pub fn regex(&self) -> Result<Regex> {
-        debug!("trying to parse regex `{}`", self.regex);
-        Regex::new(self.regex.as_str()).chain_err(|| format!("failed to parse regex `{}`", self.regex))
-    }
-    pub fn alias(&self) -> String {
-        self.alias.clone()
-    }
-}
-
 /// Used for deserialization only
 #[derive(Debug, Deserialize)]
 pub struct ConfigDeser {
@@ -59,8 +46,8 @@ impl ConfigDeser {
         }
     }
 
-    pub fn get_items(&self) -> Vec<LogItemDeser> {
-        self.item.clone()
+    fn get_items(&self) -> &Vec<LogItemDeser> {
+        &self.item
     }
 }
 
@@ -75,10 +62,13 @@ pub struct LogItem {
 }
 
 impl LogItem {
+
     fn from_log_item_deser(lid : LogItemDeser) -> Result<LogItem> {
         debug!("trying to parse regex `{}`", lid.regex);
         let l_regex = Regex::new(lid.regex.as_str())
             .chain_err(|| format!("regex not parseable: '{}'", lid.regex))?;
+        // first capture is the whole match and nameless
+        // second capture is always the timestamp
         let cnames : Vec<String> = l_regex
             .capture_names()
             .skip(2)
@@ -97,6 +87,18 @@ impl LogItem {
 
         Ok(LogItem { file : lid.file, regex : l_regex, aliases : als })
     }
+
+    pub fn file(&self) -> &String {
+        &self.file
+    }
+
+    pub fn regex(&self) -> &Regex {
+        &self.regex
+    }
+
+    pub fn aliases(&self) -> &Vec<String> {
+        &self.aliases
+    }
 }
 
 pub struct Config {
@@ -105,8 +107,28 @@ pub struct Config {
 }
 
 impl Config {
+
     pub fn load(filename : String) -> Result<Self> {
-        Err(ErrorKind::ConfigParseError(String::from("meh")).into())
+        let conf_deser = ConfigDeser::load(filename)?;
+        let mut l_items : Vec<LogItem> = Vec::new();
+        for lid in conf_deser.get_items() {
+            l_items.push(LogItem::from_log_item_deser((*lid).clone())?);
+        }
+        let mut all_als : Vec<String> = Vec::new();
+        for li in &l_items {
+            for als in li.aliases() {
+                all_als.push((*als).clone());
+            }
+        }
+        Ok(Config { items: l_items, all_aliases : all_als })
+    }
+
+    pub fn items(&self) -> &Vec<LogItem> {
+        &self.items
+    }
+
+    pub fn all_aliases(&self) -> &Vec<String> {
+        &self.all_aliases
     }
 }
 
diff --git a/src/error.rs b/src/error.rs
index af5af98..6258c10 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -5,10 +5,6 @@ error_chain! {
             description("configuration file could not be parsed"),
             display("configuration file could not be parsed: '{}'", filename),
         }
-        RegexParseError(regex: String) {
-            description("regex could not be parsed"),
-            display("regex not parsable: '{}'", regex),
-        }
     }
 }
 
diff --git a/src/main.rs b/src/main.rs
index 1d4abe2..38ad392 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -18,7 +18,7 @@ use simplelog::{SimpleLogger, LogLevelFilter, Config as LogConfig};
 
 mod error;
 mod config;
-use config::ConfigDeser;
+use config::Config;
 
 fn main() {
     let matches = App::new("aklog-server")
@@ -49,39 +49,28 @@ fn main() {
     debug!("Initialized logger");
 
     let config_file = matches.value_of("config").unwrap();
-    let config = match ConfigDeser::load(String::from(config_file)) {
+    let config = match Config::load(String::from(config_file)) {
         Ok(c) => c,
         Err(e) => {
             error!("{}", e);
             exit(1);
         },
     };
-    let items = config.get_items();
-    let aliases : Vec<_> = items.clone().into_iter()
-        .map(|it| it.alias())
-        .collect();
+    let items = config.items();
 
     let first_item = items.first().unwrap();
 
-    let mut file = File::open(first_item.file()).unwrap();
+    let file = File::open(first_item.file()).unwrap();
     use std::io::BufReader;
     use std::io::BufRead;
-    let mut bufreader = BufReader::new(file);
-    let mut line = String::new();
-    let cregex = match first_item.regex() {
-        Ok(r) => {
-            info!("regex parsed successfully");
-            r
-        },
-        Err(_) => exit(2),
-    };
-    let mut capturename_iter = cregex.capture_names().skip(1);
+    let bufreader = BufReader::new(file);
+    let mut capturename_iter = first_item.regex().capture_names().skip(1);
     while let Some(Some(name)) = capturename_iter.next() {
         println!("Named Capture: {}", name);
     }
     let mut line_iter = bufreader.lines();
     while let Some(Ok(line)) = line_iter.next() {
-        if cregex.is_match(line.as_str()) {
+        if first_item.regex().is_match(line.as_str()) {
             println!("{}", line);
         }
         else {
-- 
cgit v1.2.3