hatter/cargo-todo
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

style: code style

Browse Source
This commit is contained in:
Hatter Jiang
2020-07-26 16:39:33 +08:00
parent d91b059d1d
commit fc7b620e75
4 changed files with 73 additions and 113 deletions
Download Patch File Download Diff File Expand all files Collapse all files

130
src/main.rs
View File

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

2
src/parser.rs
View File

@@ -33,6 +33,6 @@ impl Parser {
} }
pub fn parse(&self, path: &str) { pub fn parse(&self, path: &str) {
string_parser_with_file(path, self.get_keyword().as_str(), self.get_end_filter(), self.get_callback()).expect("failed to open file"); string_parser_with_file(path, &self.get_keyword(), self.get_end_filter(), self.get_callback()).expect("failed to open file");
} }
} }

6
src/regex.rs
View File

@@ -1,17 +1,17 @@
use std::fs::File; use std::fs::File;
use std::io::{ self, BufRead, BufReader }; use std::io::{ self, Lines, BufRead, BufReader };
use std::path::Path; use std::path::Path;
use regex::{RegexSet}; use regex::{RegexSet};
use crate::token::*; use crate::token::*;
// The output is wrapped in a Result to allow matching on errors // The output is wrapped in a Result to allow matching on errors
// Returns an Iterator to the Reader of the lines of the file. // Returns an Iterator to the Reader of the lines of the file.
fn read_lines<P>(filename: P) -> io::Result<io::Lines<io::BufReader<File>>> where P: AsRef<Path>, { fn read_lines<P>(filename: P) -> io::Result<Lines<BufReader<File>>> where P: AsRef<Path>, {
let file = File::open(filename)?; let file = File::open(filename)?;
Ok(BufReader::new(file).lines()) Ok(BufReader::new(file).lines())
} }
pub fn regex_parser(path : &str, regex : Vec<String>, verbosity : i8) -> Result<Vec<Token>, io::Error> { pub fn regex_parser(path: &str, regex: Vec<String>, verbosity: i8) -> Result<Vec<Token>, io::Error> {
let set = RegexSet::new(regex).unwrap(); let set = RegexSet::new(regex).unwrap();
let mut tokens = vec![]; let mut tokens = vec![];
for (line_cpt, line) in (read_lines(path)?).enumerate() { for (line_cpt, line) in (read_lines(path)?).enumerate() {

32
src/token.rs
View File

@@ -17,15 +17,12 @@ pub struct Token{
impl Token { impl Token {
pub fn new(file: String, line: usize, s: String, verbosity: i8) -> Token { pub fn new(file: String, line: usize, s: String, verbosity: i8) -> Token {
println!(">>>>>>>>>>>{}", s); // println!(">>>>>>>>>>>{}", s);
let fields: Vec<&str>= s.split_whitespace().collect(); let fields: Vec<&str>= s.split_whitespace().collect();
let number_regex = Regex::new("#[0-9]").unwrap(); let number_regex = Regex::new(r"#[0-9]").unwrap();
let date_regex = Regex::new("(\\d+/\\d+/\\d+)").unwrap(); let date_regex = Regex::new(r"@(\d{4})[/\-](\d{2})[/\-](\d{2})").unwrap();
let member_regex = Regex::new("![\\w]+").unwrap(); let member_regex = Regex::new(r"![\w]+").unwrap();
if date_regex.is_match("5") { // println!("///////////{:?}", fields);
panic!("regex");
}
println!("///////////{:?}", fields);
let mut t = Token { let mut t = Token {
file, file,
@@ -44,11 +41,18 @@ impl Token {
} else if number_regex.is_match(field) { } else if number_regex.is_match(field) {
t.priority = Some(field.chars().skip(1).collect::<String>()); t.priority = Some(field.chars().skip(1).collect::<String>());
} else if date_regex.is_match(field) { } else if date_regex.is_match(field) {
let date: Vec<&str> = field.split('/').collect(); if let Some(capture) = date_regex.captures(field) {
let year = date[0].parse::<i32>().unwrap(); let year = capture.get(1).unwrap().as_str().parse::<i32>().unwrap();
let month = date[1].parse::<u32>().unwrap(); let month = capture.get(2).unwrap().as_str().parse::<u32>().unwrap();
let day = date[2].parse::<u32>().unwrap(); let day = capture.get(3).unwrap().as_str().parse::<u32>().unwrap();
t.date = NaiveDate::from_ymd_opt(year, month, day); t.date = NaiveDate::from_ymd_opt(year, month, day);
}
// let date: Vec<&str> = field.split('/').collect();
// let year = date[0].parse::<i32>().unwrap();
// let month = date[1].parse::<u32>().unwrap();
// let day = date[2].parse::<u32>().unwrap();
// t.date = NaiveDate::from_ymd_opt(year, month, day);
} else if member_regex.is_match(field) { } else if member_regex.is_match(field) {
t.member = Some(field.chars().skip(1).collect::<String>()); t.member = Some(field.chars().skip(1).collect::<String>());
} else { } else {
@@ -64,7 +68,7 @@ impl Token {
pub fn inline(&self) { pub fn inline(&self) {
let mut inline_msg = vec![ let mut inline_msg = vec![
format!("{} line: {} {:<6} ", self.file, self.line.to_string().green(), self.keyword.clone().green()) format!("{} line: {:>4} {:<6} ", self.file, self.line.to_string().green(), self.keyword.clone().green())
]; ];
if let Some(member) = &self.member { if let Some(member) = &self.member {
inline_msg.push(format!("member: {}", member.red())); inline_msg.push(format!("member: {}", member.red()));
@@ -82,8 +86,6 @@ impl Token {
} }
} }
// To use the `{}` marker, the trait `fmt::Display` must be implemented
// manually for the type.
impl fmt::Display for Token { impl fmt::Display for Token {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let mut multiline_msg = vec![ let mut multiline_msg = vec![