rodu 0.1.3

Tiny Todo CLI To Add Task In Current Dir
Documentation 
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
134
135
136
137
138
139

use git2::Repository;
use std::fs::{File, OpenOptions};
use std::io::Write;
use std::io::{BufRead, BufReader};
use std::os::unix::fs::FileExt;
use std::path::PathBuf;

fn todo_file_locate<'a>() -> Option<PathBuf> {
    let repo = match Repository::discover(".") {
        Ok(repo) => repo,
        Err(_) => return None,
    };
    let root = match repo.path().parent() {
        Some(root) => root,
        None => return None,
    };
    Some(root.join(".todo"))
}

pub fn todo_exist() -> bool {
    if let Some(p) = todo_file_locate() {
        return p.exists();
    }
    false
}

pub fn todo_init() {
    if let Some(p) = todo_file_locate() {
        if let Ok(_) = File::create(p) {
            add_git_ignore_rule();
            println!("Init .todo File For This Repo")
        }
    }
}

// TODO: use git2 method
fn add_git_ignore_rule() {
    match Repository::discover(".") {
        Ok(repo) => {
            if let Some(root) = repo.path().parent() {
                let mut f = OpenOptions::new()
                    .append(true)
                    .open(root.join(".gitignore"))
                    .unwrap();
                if let Ok(_) = f.write(".todo\n".as_bytes()) {
                    println!("Add \".todo\" Git Ignore Rule");
                }
            }
        }
        Err(_) => {
            println!("This Repo Miss Git Init");
            return;
        }
    }
}

pub fn todo_add(task: &String) {
    if let Ok(_) = find_task(task) {
        println!("ERROR: Task \"{}\" already exists!", task.trim());
        return;
    }
    if let Some(p) = todo_file_locate() {
        let mut f = OpenOptions::new().append(true).open(p).unwrap();
        if let Ok(_) = f.write_all(task.as_bytes()) {
            println!("Add New Todo Task: \"{}\"", task.trim());
        }
    }
}

pub fn todo_list() {
    if let Some(p) = todo_file_locate() {
        std::fs::read_to_string(p)
            .unwrap()
            .split("\n")
            .map(|task| task.trim().to_string()) // trim and convert to string
            .filter(|task| !task.is_empty() && !task.starts_with("!")) // filter empty lines
            .for_each(|task| println!("{}", task));
    }
}

pub fn todo_done(task: &String) {
    let cursor = if let Ok(c) = find_task(task) {
        c
    } else {
        println!("ERROR: Task \"{}\" has not been added!", task.trim());
        return;
    };
    if let Some(p) = todo_file_locate() {
        let file = OpenOptions::new().write(true).open(&p).unwrap();
        if let Err(e) = file.write_at("!".as_bytes(), cursor) {
            println!("{}", e);
        } else {
            println!("Done your task {}! Great!", task.trim());
        }
    }
}

fn find_task(task: &String) -> Result<u64, bool> {
    let task = task.trim();
    let mut cursor = 0;
    let mut found = false;
    if let Some(p) = todo_file_locate() {
        let file = File::open(&p).unwrap();
        let mut reader = BufReader::new(&file);
        loop {
            let mut line = String::new();
            if let Ok(len) = reader.read_line(&mut line) {
                if len == 0 {
                    break;
                }
                line = line.trim().to_string();
                if line.starts_with("!") {
                    cursor += len;
                    continue;
                } else if line != task {
                    cursor += len;
                } else {
                    found = true;
                    break;
                }
            }
        }
    }
    if !found {
        Err(found)
    } else {
        Ok(cursor as u64)
    }
}

// #[cfg(test)]
// mod utils_test {
//     use super::todo_exist;
//
//     #[test]
//     fn test_todo_is_exist() {
//         assert_eq!(true, todo_exist())
//     }
// }