style: code style

src/main.rs

@@ -4,6 +4,7 @@ use std::env;
 use std::path::Path;
 use std::fs::File;
 use std::io::{ self, BufRead };
+use std::collections::HashSet;
 use glob::glob;
 use colored::Colorize;
 use clap::{ Arg, App, SubCommand };
@@ -115,15 +116,16 @@ fn main() -> std::io::Result<()> {
             }
         }
         
-        { 
+        {
             let path = entry.unwrap();
             let path = Path::new(&path).strip_prefix(env::current_dir().unwrap().to_str().unwrap()).unwrap();
             // println!("{}", path.to_str().unwrap());
             if !path.starts_with("target/") {
                 let path = path.to_str().unwrap();
-            
-                if matches.occurrences_of("verbose") == 0 || matches.occurrences_of("verbose") == 2 {
-                    match regex_parser(path, regex.clone(), 2){
+
+                let verbose_count = matches.occurrences_of("verbose");
+                if verbose_count == 0 || verbose_count == 2 {
+                    match regex_parser(path, regex.clone(), 2) {
                         Ok(mut t) => {
                             tokens.append(&mut t);
                         },
@@ -140,120 +142,76 @@ fn main() -> std::io::Result<()> {
                 }
             }
         }
-        
-        if matches.is_present("sort") {
-            if matches.value_of("sort").unwrap() == "priority" {
-                fn token_priority_sort(t : &Token) -> String {
+
+        if let Some(sort) = matches.value_of("sort") {
+            match sort {
+                "priority" => tokens.sort_unstable_by_key(|t : &Token| -> String {
                     t.priority.clone().unwrap_or_else(|| "z".into())
-                }
-                tokens.sort_unstable_by_key(token_priority_sort);
-            }
-            else if matches.value_of("sort").unwrap() == "deadline" {
-                fn token_deadline_sort(t : &Token) -> NaiveDate {
-                    t.date.clone().unwrap_or_else(|| NaiveDate::from_ymd(3000, 1, 1))
-                }
-                tokens.sort_unstable_by_key(token_deadline_sort);
-            }
-            else if matches.value_of("sort").unwrap() == "member" {
-                fn token_member_sort(t : &Token) -> String {
-                    t.priority.clone().unwrap_or_else(|| "z".into())
-                }
-                tokens.sort_unstable_by_key(token_member_sort);
+                }),
+                "deadline" => tokens.sort_unstable_by_key(|t : &Token| -> NaiveDate {
+                    t.date.clone().unwrap_or_else(|| NaiveDate::from_ymd(9999, 1, 1))
+                }),
+                "member" => tokens.sort_unstable_by_key(|t : &Token| -> String {
+                    t.member.clone().unwrap_or_else(|| "zzzzzzzzzzzzz".into())
+                }),
+                _ => {}, // IGNORE
             }
         }
-        
-        if matches.is_present("list") {
-            let lines = match matches.value_of("list").unwrap().parse::<usize>() {
-                Ok(lines) => lines,
-                Err(_) => {
+
+        if let Some(list) = matches.value_of("list") {
+            let lines = match list.parse::<usize>() {
+                Ok(lines) => lines, Err(_) => {
                     eprintln!("{}", "list argument should be a valid number!".red());
                     panic!()
                 }
-            }; 
-
-            let mut new_tokens : Vec<Token> = vec![];
-            for i in tokens {
-                if new_tokens.len() < lines {
-                    new_tokens.push(i.clone());
-                } else {
-                    break;
-                }
-            }
-            tokens = new_tokens;
+            };
+            tokens = tokens.iter().take(lines).map(|t| t.clone()).collect::<Vec<Token>>();
         }
 
-        if matches.is_present("member") {
-            let filters : Vec<&str> = matches.values_of("member").unwrap().collect();
-            let mut new_tokens : Vec<Token> = vec![];
-            for i in tokens{
-                // println!("{}", i);
-                for y in &filters {
-                    if i.member.clone().is_some() && i.member.clone().unwrap() == *y.to_string() {
-                        println!("pushing");
-                        new_tokens.push(i.clone());
-                        break;
-                    }
-                }
-            }
-            tokens = new_tokens;
+        if let Some(members) = matches.values_of("member") {
+            let members = members.collect::<HashSet<&str>>();
+            tokens = tokens.iter()
+                .filter(|t| t.member.as_ref().map(|m| members.contains(m.as_str())).unwrap_or(false))
+                .map(|t| t.clone())
+                .collect::<Vec<Token>>();
         }
 
-        if matches.is_present("filter") {
-            let filters : Vec<&str> = matches.values_of("filter").unwrap().collect();
-            let mut new_tokens : Vec<Token> = vec![];
-            for i in tokens {
-                for y in &filters {
-                    if i.keyword == *y {
-                        new_tokens.push(i.clone());
-                        break;
-                    }
-                }
-            }
-            tokens = new_tokens;
-            // tokens = new.into_iter().filter(|t| t.keyword == String::from(matches.value_of("filter").unwrap())).collect();
+        if let Some(filters) = matches.values_of("filter") {
+            let filters = filters.collect::<HashSet<&str>>();
+            tokens = tokens.iter()
+                .filter(|t| filters.contains(t.keyword.as_str()))
+                .map(|t| t.clone())
+                .collect::<Vec<Token>>();
         }
 
-        if matches.is_present("exclude") {
-            let excludes : Vec<&str> = matches.values_of("exclude").unwrap().collect();
-            let mut new_tokens : Vec<Token> = vec![];
-            for i in tokens{
-                for y in 0..excludes.len() {
-                    if i.keyword == excludes[y] {
-                        break;
-                    }
-                    else if y == excludes.len() -1 {
-                        new_tokens.push(i.clone());
-                    }     
-                }
-                
-            }
-            tokens = new_tokens;
-            // tokens = new.into_iter().filter(|t| t.keyword == String::from(matches.value_of("filter").unwrap())).collect();
+        if let Some(excludes) = matches.values_of("exclude") {
+            let excludes = excludes.collect::<HashSet<&str>>();
+            tokens = tokens.iter()
+                .filter(|t| !excludes.contains(t.keyword.as_str()))
+                .map(|t| t.clone())
+                .collect::<Vec<Token>>();
         }
+
         if matches.is_present("inline") {
-            for i in tokens {
-                i.inline();
-            }
+            tokens.iter().for_each(|i| i.inline());
         } else {
-            for i in tokens {
-                println!("{}", i);
-            }
+            tokens.iter().for_each(|i| println!("{}", i));
         }
-        
+
         Ok(())
-}
+    }
 }
 
 #[allow(dead_code)]
 // test zone
 //TODO refactor
-//todo implement 2001/11/01 #3 getters !clement
-//todo implement 2001/11/01 #3 getters !thomas
-//fix implement 18/11/2001 getters !jht5945
+//todo implement @2001/11/01 #3 getters !clement
+//todo implement @2001-11-01 #3 getters !thomas
+//fix implement @18/11/2001 getters !jht5945
 //4
 //10/10/10
 fn test(){
     todo!("implements getters");
 }
 
-//todo implement 2020/08/14 #5 getters !clement
+//todo implement @2020/08/14 #5 getters !clement