devloop 0.1.3

A tool to help with repetitive commands during development.
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

use std::process::Command;

use configuration::{DevloopConfig, Task};
use message::{msg, MessageType};

impl DevloopConfig {
    pub fn run(&self) {
        let help = self.calculate_help();
        'main: loop {
            Command::new("clear").status().expect("clear screen");
            if self.run_tasks() {
                msg(&MessageType::Success, &format!("Done [{}]:", help), true);
            } else {
                msg(&MessageType::Fail, "Error.", false);
            }
            loop {
                match read_line().as_ref() {
                    "q" => break 'main,
                    action => {
                        if self.actions
                            .get(action)
                            .map(|task| task.execute())
                            .unwrap_or(true)
                        {
                            break;
                        } else {
                            msg(&MessageType::Fail, "Error.", false);
                            // Read line again
                        }
                    }
                }
            }
        }
        msg(&MessageType::Reminder, &self.reminders, false);
    }

    fn calculate_help(&self) -> String {
        let keys: Vec<&str> = self.actions
            .keys()
            .map(|i| i.as_ref())
            .chain(Some("q"))
            .collect();

        if keys.iter().any(|key| key.len() > 1) {
            keys.join("|")
        } else {
            keys.concat()
        }
    }

    fn run_tasks(&self) -> bool {
        for task in &self.tasks {
            if !task.execute() {
                return false;
            }
        }
        true
    }
}

fn read_line() -> String {
    use std::io::BufRead;
    let stdin = ::std::io::stdin();
    let line = stdin.lock().lines().next().unwrap().unwrap();
    line.clone()
}

impl Task {
    fn execute(&self) -> bool {
        msg(
            &MessageType::Info,
            &format!("Running {}...", self.name),
            false,
        );

        Command::new("sh")
            .arg("-c")
            .arg(&self.command)
            .status()
            .expect("child exit status")
            .success()
    }
}