cargo-todo 0.2.1

Cargo tool to display TODOs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

extern crate string_format;
extern crate regex;
extern crate chrono;

use chrono::NaiveDate;
use string_format::string_format;
use std::fmt;
use colored::Colorize;
use regex::Regex;

#[derive(Clone)]
pub struct Token{
        file : String,
        line : usize,
        pub keyword : String,
        pub comment : Option<String>,
        pub priority : Option<String>,
        pub date : Option<NaiveDate>,
        pub member : Option<String>, 
        verbosity : i8,
}

impl Token {
    pub fn new (file : String, line : usize, s : String, verbosity : i8) -> Token{
        // println!("{}", s);
        let fields : Vec<&str>= s.split_whitespace().collect();
        let number_regex = Regex::new("\\b[1-9]\\b").unwrap();
        let date_regex = Regex::new("(\\d*/\\d*/\\d*)").unwrap();
        let member_regex = Regex::new("!\\w*").unwrap();
        if date_regex.is_match("5") {
            panic!("regex");
        }
        // for i in &fields {
        //     println!("{}", i);
        // }

        let mut t = Token {
                file : file,
                line : line,
                keyword: "todo".to_string(),
                comment : None,
                priority : None,
                date : None,
                member : None,
                verbosity : verbosity
            };

        for i in 0..fields.len() {
            if i == 0{
                t.keyword = fields[0].to_string().to_lowercase();
            }
            else if number_regex.is_match(fields[i]) {
                t.priority = Some(fields[i].to_string());
            }
            else if date_regex.is_match(fields[i]){
                let date : Vec<&str> = fields[i].split("/").collect();
                t.date = NaiveDate::from_ymd_opt(date[0].parse::<i32>().unwrap(), date[1].parse::<u32>().unwrap(), date[2].parse::<u32>().unwrap());
                // t.date = Some(fields[i].to_string());
            }
            else if member_regex.is_match(fields[i]){
                let mut member = String::new(); //from(fields[i].clone()).chars().next().map(|c| &s[c.len_utf8()..]).unwrap();
                let it = fields[i].chars().skip(1);
                for i in it{
                    member.push(i);
                }

                t.member = Some(member);
            }
            else {
                if t.comment.is_none(){
                    t.comment = Some(fields[i].to_string());
                }
                else{
                t.comment = Some(string_format!("{} {}".to_string(),t.comment.unwrap(), fields[i].to_string()));
                }
            }
        }

        t
    }

    pub fn inline(&self) {
        let mut s;
        s = string_format!("{} line: {} {} ".to_string(), self.file.clone(), self.line.to_string().green().to_string(), self.keyword.clone().green().to_string());
        if self.member.is_some(){
            s = string_format!("{} Member: {}".to_string(),s ,self.member.clone().unwrap().red().to_string());
        }
        if self.priority.is_some(){
            s = string_format!("{} Priority: {}".to_string(), s, self.priority.clone().unwrap().red().to_string());
        }
        if self.date.is_some(){
            s = string_format!("{} Deadline: {}".to_string(), s, self.date.clone().unwrap().to_string().red().to_string());
        }
        if self.comment.is_some() {
            s = string_format!("{} {}".to_string(), s, self.comment.clone().unwrap().blue().to_string());
        }
        println!("{}", s);
    }

}

// To use the `{}` marker, the trait `fmt::Display` must be implemented
// manually for the type.
impl fmt::Display for Token {
    // This trait requires `fmt` with this exact signature.
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        let mut s;

        s = string_format!("{} line: {} {} \n".to_string(), self.file.clone(), self.line.to_string().green().to_string(), self.keyword.clone().green().to_string());
        if self.verbosity <= 1{
            if self.comment.is_some() {
                s = string_format!("{}{}\n".to_string(), s, self.comment.clone().unwrap().blue().to_string());
            }
        }
        else {
        if self.member.is_some(){
            s = string_format!("{}Member: {}\n".to_string(),s ,self.member.clone().unwrap().red().to_string());
        }
        if self.priority.is_some(){
            s = string_format!("{}Priority: {}\n".to_string(), s, self.priority.clone().unwrap().red().to_string());
        }
        if self.date.is_some(){
            s = string_format!("{}Deadline: {}\n".to_string(), s, self.date.clone().unwrap().to_string().red().to_string());
        }
        if self.comment.is_some() {
            s = string_format!("{}{}\n".to_string(), s, self.comment.clone().unwrap().blue().to_string());
        }
    }
        
        write!(f, "{}", s)?;
        Ok(())
    }
}