devloop 0.2.2

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
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

extern crate crossterm;
extern crate ctrlc;
#[macro_use]
extern crate lazy_static;
#[macro_use]
extern crate serde_derive;
extern crate structopt;
#[macro_use]
extern crate thiserror;

mod args;
mod config;

use crossterm::style::Colorize;
use crossterm::terminal::{Clear, ClearType};
use crossterm::ExecutableCommand;

use std::io::{stdin, stdout, Write};
use std::sync::atomic::AtomicBool;

lazy_static! {
    pub(crate) static ref CTRLC_PRESSED: AtomicBool = AtomicBool::new(false);
}

fn main() {
    let args = args::get_opts();

    ctrlc::set_handler(ctrl_c_handler).expect("set ctrl+c handler");

    let config = match config::load_config(&args.config) {
        Ok(config) => config,
        Err(e) => {
            eprintln!("Error: {}", e);
            std::process::exit(1)
        }
    };
    run_loop(config);
}

fn run_loop(config: config::DevloopConfig) {
    let help_msg = config.help_characters();
    let done_help_msg = format!("Done [{}]:", help_msg).black().on_green();
    let error_msg = format!("Error. [{}]:", help_msg).black().on_red();
    let interrupted_msg = format!("Interrupted. [{}]:", help_msg).black().on_red();

    'main: loop {
        // Clear on success
        stdout()
            .execute(Clear(ClearType::All))
            .expect("clear terminal")
            .execute(crossterm::cursor::MoveTo(0, 0))
            .expect("reset cursor");

        match execute_tasks(&config.tasks) {
            Some(true) => {
                print!("{}", done_help_msg);
                stdout().flush().expect("flush stdout");
            }
            Some(false) => {
                print!("{}", error_msg);
                stdout().flush().expect("flush stdout");
            }
            None => {
                print!("{}", interrupted_msg);
                stdout().flush().expect("flush stdout");
            }
        }

        // Try actions until success
        loop {
            let mut line = String::new();
            stdin().read_line(&mut line).expect("read a line");
            match line.as_str().trim_end() {
                "" => break, // Clear
                "q" => break 'main,
                action_key => {
                    let action = config.actions.get(action_key);
                    if let Some(action) = action {
                        match action.execute() {
                            Some(true) => {
                                if action.pause {
                                    stdin().read_line(&mut String::new()).unwrap();
                                }
                                break;
                                // Clear
                            }
                            Some(false) => {
                                print!("{}", error_msg);
                                stdout().flush().expect("flush stdout");
                                // Choose action again
                            }
                            None => {
                                print!("\n{}", interrupted_msg);
                                stdout().flush().expect("flush stdout");
                            }
                        }
                    } else {
                        print!("{} ", "No such action.".black().on_red());
                        stdout().flush().expect("flush stdout");
                        // Choose action again, use previous prompt for help
                    }
                }
            }
        }
    }
    println!("{}", config.reminders.black().on_yellow());
}

fn execute_tasks(tasks: &[config::Task]) -> Option<bool> {
    for task in tasks {
        if !task.execute()? {
            return Some(false);
        }
    }
    Some(true)
}

fn ctrl_c_handler() {
    use std::sync::atomic::Ordering;
    CTRLC_PRESSED.store(true, Ordering::SeqCst);
}