funzzy 1.5.0

Yet another fancy watcher inspired by entr.
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

use std::io::Write;

use crate::environment;

// ANSI color codes for terminal output
pub const GREEN: &str = "\x1b[32m";
pub const RED: &str = "\x1b[31m";
pub const BLUE: &str = "\x1b[34m";
pub const RESET: &str = "\x1b[0m";

#[cfg(not(test))]
pub fn is_colored() -> bool {
    environment::is_enabled("FUNZZY_COLORED")
}

#[cfg(test)]
pub fn is_colored() -> bool {
    false
}

pub fn info(msg: &str) {
    if is_colored() {
        println!("{}Funzzy{}: {}", BLUE, RESET, msg);
    } else {
        println!("Funzzy: {}", msg);
    }
}

pub fn error(msg: &str) {
    if is_colored() {
        println!("{}Funzzy error{}: {}", RED, RESET, msg);
    } else {
        println!("Funzzy error: {}", msg);
    }
}

pub fn warn(msg: &str) {
    println!("Funzzy warning: {}", msg);
}

pub fn show_and_exit(text: &str) -> ! {
    println!("{}", text);
    std::process::exit(0)
}

pub fn failure(text: &str, err: String) -> ! {
    if is_colored() {
        println!("{}Error{}: {}", RED, RESET, text);
    } else {
        println!("Error: {}", text);
    }
    println!("{}", err);
    std::process::exit(1)
}

pub fn verbose(msg: &str, verbose: bool) {
    if !verbose {
        return;
    }

    println!("-----------------------------");
    println!("Funzzy verbose: {} ", msg);
    println!("-----------------------------");
}

#[cfg(not(feature = "test-integration"))]
/// Print the time elapsed in seconds in the format "Finished in 0.1234s"
pub fn print_time_elapsed(elapsed: std::time::Duration) -> () {
    print!("Durantion: {:.4}s", elapsed.as_secs_f32());
    let res = std::io::stdout().flush();

    match res {
        Ok(_) => (),
        Err(e) => {
            warn("Failed to flush stdout, but the program will continue.");
            warn(&format!("Reason: {:?}", e));
        }
    };
}

#[cfg(feature = "test-integration")]
// NOTE: This is for testing purposes only
/// Print mocked time elapsed always as: "Finished in 0.0s"
pub fn print_time_elapsed(_: std::time::Duration) -> () {
    let elapsed = std::time::Duration::from_secs(0);
    print!("Durantion: {:.4}s", elapsed.as_secs_f32());
    std::io::stdout().flush().expect("Failed to flush stdout");
}

pub fn present_results(results: Vec<Result<(), String>>, time_elapsed: std::time::Duration) {
    let errors: Vec<Result<(), String>> = results.iter().cloned().filter(|r| r.is_err()).collect();
    let completed = results.iter().cloned().filter(|r| r.is_ok()).count();
    println!("Funzzy results ----------------------------");
    if !errors.is_empty() {
        if is_colored() {
            print!("{}", RED);
        }

        errors.iter().for_each(|err| {
            println!("- {}", err.as_ref().unwrap_err());
        });

        if is_colored() {
            print!("Failure{}; ", RESET);
        } else {
            print!("Failure; ");
        }
    } else {
        if is_colored() {
            print!("{}Success{}; ", GREEN, RESET);
        } else {
            print!("Success; ");
        }
    }

    print!("Completed: {:?}; Failed: {:?}; ", completed, errors.len());
    print_time_elapsed(time_elapsed);
}

pub fn clear_screen() -> () {
    // See https://archive.ph/d3Z3O
    print!("\n{}[2J", 27 as char);
}