easy-sgr 0.1.1

An easy to use Select Graphics Rendition(SGR) library
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
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178

use std::default::Default;

use easy_sgr::{CleanKind, Color::*, ColorKind, EasySGR, SGRString, Style::*, StyleKind};

#[test]
fn general() {
    assert_eq!("", SGRString::default().to_string());
    assert_eq!(
        "test\x1b[0m",
        String::from("test").clean(CleanKind::Reset).to_string()
    );
    assert_eq!(
        "",
        (&String::default()).clean(CleanKind::Reverse).to_string()
    );
    assert_eq!(
        "\x1b[31;1m",
        SGRString {
            bold: StyleKind::Place,
            foreground: ColorKind::Red,
            ..Default::default()
        }
        .to_string()
    );
    assert_eq!(
        "\x1b[31;1mtest",
        SGRString {
            text: String::from("test"),
            bold: StyleKind::Place,
            foreground: ColorKind::Red,
            ..Default::default()
        }
        .to_string()
    );
}
#[test]
fn fully_loaded() {
    assert_eq!(
        "\x1b[0;31;41;1;2;3;4;5;7;8;9;100mtest\x1b[39;49;22;22;23;24;25;27;28;29;100m",
        SGRString {
            text: "test".to_string(),
            clean: CleanKind::Reverse,
            custom_places: vec![100],
            custom_cleans: vec![100],
            foreground: ColorKind::Red,
            background: ColorKind::Red,
            reset: true,
            bold: StyleKind::Place,
            dim: StyleKind::Place,
            italic: StyleKind::Place,
            underline: StyleKind::Place,
            blinking: StyleKind::Place,
            inverse: StyleKind::Place,
            hidden: StyleKind::Place,
            strikethrough: StyleKind::Place
        }
        .to_string()
    );
    assert_eq!(
        "\x1b[0;31;41;22;22;23;24;25;27;28;29;100mtest\x1b[39;49;1;2;3;4;5;7;8;9;100m",
        SGRString {
            text: "test".to_string(),
            clean: CleanKind::Reverse,
            custom_places: vec![100],
            custom_cleans: vec![100],
            foreground: ColorKind::Red,
            background: ColorKind::Red,
            reset: true,
            bold: StyleKind::Clean,
            dim: StyleKind::Clean,
            italic: StyleKind::Clean,
            underline: StyleKind::Clean,
            blinking: StyleKind::Clean,
            inverse: StyleKind::Clean,
            hidden: StyleKind::Clean,
            strikethrough: StyleKind::Clean
        }
        .to_string()
    );
}

#[test]
fn colors() {
    for (correct, color) in [
        ("", ColorKind::None),
        ("\x1b[30;40m", ColorKind::Black),
        ("\x1b[31;41m", ColorKind::Red),
        ("\x1b[32;42m", ColorKind::Green),
        ("\x1b[33;43m", ColorKind::Yellow),
        ("\x1b[34;44m", ColorKind::Blue),
        ("\x1b[35;45m", ColorKind::Magenta),
        ("\x1b[36;46m", ColorKind::Cyan),
        ("\x1b[37;47m", ColorKind::White),
        ("\x1b[38;5;208;48;5;208m", ColorKind::Byte(208)),
        (
            "\x1b[38;2;208;208;208;48;2;208;208;208m",
            ColorKind::Rgb(208, 208, 208),
        ),
        ("\x1b[39;49m", ColorKind::Default),
    ] {
        assert_eq!(
            correct,
            SGRString {
                foreground: color.clone(),
                background: color,
                ..Default::default()
            }
            .to_string()
        )
    }
}

#[test]
fn easy_sgr() {
    assert_eq!("test", "test".to_sgr().to_string());
    assert_eq!("test", "".text("test").to_string());
    assert_eq!("\x1b[100mtest", "test".custom(100).to_string());
    assert_eq!("\x1b[100mtest", "test".custom_place(100).to_string());
    assert_eq!("test\x1b[100m", "test".custom_clean(100).to_string());

    assert_eq!("\x1b[31;3m", Italic.color(RedFg).to_string());
    assert_eq!("\x1b[31;3m", RedFg.style(Italic).to_string());
}

#[test]
fn easy_sgr_style() {
    for (correct, style) in [
        ("\x1b[0m", Reset),
        ("\x1b[1m", Bold),
        ("\x1b[2m", Dim),
        ("\x1b[3m", Italic),
        ("\x1b[4m", Underline),
        ("\x1b[5m", Blinking),
        ("\x1b[7m", Inverse),
        ("\x1b[8m", Hidden),
        ("\x1b[9m", Strikethrough),
        ("\x1b[22m", NotBold),
        ("\x1b[22m", NotDim),
        ("\x1b[23m", NotItalic),
        ("\x1b[24m", NotUnderline),
        ("\x1b[25m", NotBlinking),
        ("\x1b[27m", NotInverse),
        ("\x1b[28m", NotHidden),
        ("\x1b[29m", NotStrikethrough),
    ] {
        assert_eq!(correct, "".style(style).to_string());
    }
}

#[test]
fn easy_sgr_color() {
    for (correct, color) in [
        ("\x1b[30m", BlackFg),
        ("\x1b[31m", RedFg),
        ("\x1b[32m", GreenFg),
        ("\x1b[33m", YellowFg),
        ("\x1b[34m", BlueFg),
        ("\x1b[35m", MagentaFg),
        ("\x1b[36m", CyanFg),
        ("\x1b[37m", WhiteFg),
        ("\x1b[38;5;208m", ByteFg(208)),
        ("\x1b[38;2;208;208;208m", RgbFg(208, 208, 208)),
        ("\x1b[39m", DefaultFg),
        ("\x1b[40m", BlackBg),
        ("\x1b[41m", RedBg),
        ("\x1b[42m", GreenBg),
        ("\x1b[43m", YellowBg),
        ("\x1b[44m", BlueBg),
        ("\x1b[45m", MagentaBg),
        ("\x1b[46m", CyanBg),
        ("\x1b[47m", WhiteBg),
        ("\x1b[48;5;208m", ByteBg(208)),
        ("\x1b[48;2;208;208;208m", RgbBg(208, 208, 208)),
        ("\x1b[49m", DefaultBg),
    ] {
        assert_eq!(correct, "".color(color).to_string())
    }
}