polk 1.1.6

Dotfile manager and symlinker
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


/// Log a message if verbosity is enabled.
macro_rules! vlog {
    ($verbosity_enabled:expr => $fmt:expr $(, $arg:expr )*) => {
        log!("[log]", YELLOW, $verbosity_enabled => $fmt $(, $arg )* );
    }
}

/// Logs an information message unconditionally.
macro_rules! ilog {
    ($fmt:expr $(, $arg:expr )*) => {
        log!("[info]", BRIGHT_BLUE, true => $fmt $(, $arg )* );
    }
}

/// Logs a warning message unconditionally.
macro_rules! warn {
    ($fmt:expr $(, $arg:expr )*) => {
        log!("warning", MAGENTA, true => $fmt $(, $arg )* );
    }
}

/// Log an error message and terminate the process.
macro_rules! fatal {
    ($fmt:expr $(, $arg:expr )*) => {
        {
            log!("error", RED, true => $fmt $(, $arg )* );
            ::std::process::exit(1);
        }
    }
}

/// Prints out a fatal `Error` and an explanation message then
/// terminates the process.
macro_rules! fatal_error {
    ($error:expr) => {
        {
            use std::io::prelude::*;
            use std::io;

            let error: $crate::Error = $error.into();
            let errors: Vec<_> = error.iter().map(ToString::to_string).collect();

            // Print pretty error messages in release builds.
            #[cfg(not(debug_assertions))]
            {
                fatal!("{}", error)
            }

            // Print useful stacktrace in debug mode.
            #[cfg(debug_assertions)]
            {
                writeln!(io::stderr(), "error: {}", errors.join(" - ")).unwrap();
                panic!("{}", error);
            }
        }
    };

    ($error:expr, $message:expr) => {
        {
            use $crate::ResultExt;

            // We can only chain `Result`, not `Error`.
            let error: Result<(), $crate::Error> = Err($error.into());
            let error = error.chain_err(|| $message);
            let error = error.err().unwrap();

            fatal_error!(error);
        }
    };
}

/// Write a generic log message to standard error.
macro_rules! log {
    ($label:expr, $color:ident,
     $logging_enabled:expr => $fmt:expr $(, $arg:expr )*) => {
        {
            use std::io;
            use std::io::prelude::*;

            if $logging_enabled {
                use term;

                let mut t = term::stderr().unwrap();

                t.fg(term::color::$color).ok();
                write!(io::stderr(), "{}: ", $label).ok();
                t.reset().ok();
                writeln!(io::stderr(), $fmt $( , $arg )*).ok();
            }
        }
    }
}