shy 0.1.1

barebones ssh launcher
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

#![allow(dead_code)]
#![allow(unused_macros)]

//! Terminal colors.
//! Provides a macro to color text as well as sturcts to get their
//! raw ansi codes.

use std::fmt;

/// Shortcut to produce a String colored with one or more colors.
/// Example:
/// ```
///   let s = color_string!("Red string", Red);
///   let x = color_string!("Hyperlink-ish", Blue, Underline);
macro_rules! color_string {
    ($s:expr, $( $color:ident ),+) => {{
        let mut out = String::from("\x1b[");
        $( out.push_str(crate::color::$color::code()); out.push_str(";"); )+
        out.push('m');
        out.push_str(&$s);
        out.push_str(crate::color::Reset.as_ref());
        out.replace(";m", "m")
    }};
}

/// Shortcut to produce a color's ANSI escape code. Don't forget to Reset!
/// ```
///   let mut o = String::new();
///   o.push_str(color!(Blue));
///   o.push_str(color!(Underline));
///   o.push_str("Hyperlinkish.");
///   o.push_str(color!(Reset));
macro_rules! color {
    ($color:ident) => {
        crate::color::$color.as_ref()
    };
}

/// Create a color:: struct that can be used with format!.
/// Example:
/// ```
///   define_color(Red, 91);
///   define_color(Reset, 0);
///
///   println!("{}Error: {}{}", color::Red, msg, color::Reset);
macro_rules! define_color {
    ($color:ident, $code:literal) => {
        #[allow(missing_docs)]
        pub struct $color;
        impl fmt::Display for $color {
            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
                write!(f, "{}", self.as_ref())
            }
        }
        impl $color {
            #[allow(missing_docs)]
            #[inline]
            pub fn code() -> &'static str {
                concat!($code)
            }
        }
        impl AsRef<str> for $color {
            #[inline]
            fn as_ref(&self) -> &'static str {
                concat!("\x1b[", $code, "m")
            }
        }
    };
}

define_color!(Reset, 0);
define_color!(Bold, 1);
define_color!(Underline, 4);

define_color!(Grey, 90);
define_color!(Red, 91);
define_color!(Green, 92);
define_color!(Yellow, 93);
define_color!(Blue, 94);
define_color!(Magenta, 95);
define_color!(Cyan, 96);
define_color!(White, 97);

define_color!(Black, 30);
define_color!(DarkRed, 31);
define_color!(DarkGreen, 32);
define_color!(DarkYellow, 33);
define_color!(DarkBlue, 34);
define_color!(DarkMagenta, 35);
define_color!(DarkCyan, 36);
define_color!(DarkWhite, 37);

define_color!(BlackBG, 40);
define_color!(RedBG, 41);
define_color!(GreenBG, 42);
define_color!(YellowBG, 43);
define_color!(BlueBG, 44);
define_color!(MagentaBG, 45);
define_color!(CyanBG, 46);
define_color!(WhiteBG, 47);

#[cfg(test)]
mod tests {
    #[test]
    fn test_colors() {
        assert_eq!(color_string!("Error", Red), "\x1b[91mError\x1b[0m");
        assert_eq!(
            color_string!("Fancy Pants", Blue, Underline),
            "\x1b[94;4mFancy Pants\x1b[0m"
        );
        assert_eq!(
            color_string!("Super-duper-fancy-pants", Magenta, Underline, Bold, BlueBG),
            "\x1b[95;4;1;44mSuper-duper-fancy-pants\x1b[0m"
        )
    }
}