shapely-pretty 3.1.0

Pretty-printing for types implementing the Shapely trait
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

//! ANSI color codes and formatting utilities for direct writing to formatters

use std::fmt::Write;

/// Write ANSI reset code to the formatter
pub fn write_reset<W: Write>(f: &mut W) -> std::fmt::Result {
    f.write_str("\x1b[0m")
}

/// Write ANSI bold formatting to the formatter
pub fn write_bold<W: Write>(f: &mut W) -> std::fmt::Result {
    f.write_str("\x1b[1m")
}

/// ANSI reset code
pub const RESET: &str = "\x1b[0m";

/// ANSI bold formatting code
pub const BOLD: &str = "\x1b[1m";

/// ANSI dim formatting code
pub const DIM: &str = "\x1b[2m";

/// Write ANSI dim formatting to the formatter
pub fn write_dim<W: Write>(f: &mut W) -> std::fmt::Result {
    f.write_str(DIM)
}

/// Write ANSI italic formatting to the formatter
pub fn write_italic<W: Write>(f: &mut W) -> std::fmt::Result {
    f.write_str("\x1b[3m")
}

/// Write ANSI underline formatting to the formatter
pub fn write_underline<W: Write>(f: &mut W) -> std::fmt::Result {
    f.write_str("\x1b[4m")
}

/// Write RGB foreground color code to the formatter
pub fn write_rgb<W: Write>(f: &mut W, r: u8, g: u8, b: u8) -> std::fmt::Result {
    write!(f, "\x1b[38;2;{};{};{}m", r, g, b)
}

/// Write RGB background color code to the formatter
pub fn write_rgb_bg<W: Write>(f: &mut W, r: u8, g: u8, b: u8) -> std::fmt::Result {
    write!(f, "\x1b[48;2;{};{};{}m", r, g, b)
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_write_rgb() {
        let mut out = String::new();
        write_rgb(&mut out, 255, 0, 0).unwrap();
        assert_eq!(out, "\x1b[38;2;255;0;0m");

        let mut out = String::new();
        write_rgb(&mut out, 0, 255, 0).unwrap();
        assert_eq!(out, "\x1b[38;2;0;255;0m");

        let mut out = String::new();
        write_rgb(&mut out, 0, 0, 255).unwrap();
        assert_eq!(out, "\x1b[38;2;0;0;255m");
    }

    #[test]
    fn test_write_rgb_bg() {
        let mut out = String::new();
        write_rgb_bg(&mut out, 255, 0, 0).unwrap();
        assert_eq!(out, "\x1b[48;2;255;0;0m");

        let mut out = String::new();
        write_rgb_bg(&mut out, 0, 255, 0).unwrap();
        assert_eq!(out, "\x1b[48;2;0;255;0m");

        let mut out = String::new();
        write_rgb_bg(&mut out, 0, 0, 255).unwrap();
        assert_eq!(out, "\x1b[48;2;0;0;255m");
    }

    #[test]
    fn test_write_formatting() {
        let mut out = String::new();
        write_bold(&mut out).unwrap();
        assert_eq!(out, "\x1b[1m");

        let mut out = String::new();
        write_dim(&mut out).unwrap();
        assert_eq!(out, "\x1b[2m");

        let mut out = String::new();
        write_reset(&mut out).unwrap();
        assert_eq!(out, "\x1b[0m");
    }
}