ansiconst 0.2.1

Library for declaring nestable ANSI styles in const context
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

use crate::{Ansi, Color::*, Coloree::{self, *}, Effect::{self, *}, Toggle, ToggleColor};
use std::fmt;

enum State { Clean, Dirty }

impl State {
    #[inline]
    fn write_str<W: fmt::Write>(&self, w: &mut W, s: &str) -> Result<Self, fmt::Error> {
        self._write_separator(w)?;
        w.write_str(s)?;
        Ok(Self::Dirty)
    }
    #[cfg(feature="color256")]
    #[inline]
    fn write_fmt<W: fmt::Write>(&self, w: &mut W, fmt: fmt::Arguments<'_>) -> Result<Self, fmt::Error> {
        self._write_separator(w)?;
        w.write_fmt(fmt)?;
        Ok(Self::Dirty)
    }

    #[inline]
    fn _write_separator<W: fmt::Write>(&self, w: &mut W) -> fmt::Result {
        match self {
            Self::Clean => w.write_str("\x1B["),
            Self::Dirty => w.write_str(";"),
        }
    }
    #[inline]
    fn write_terminator<W: fmt::Write>(&self, w: &mut W) -> Result<Self, fmt::Error> {
        match self {
            Self::Clean => (),
            Self::Dirty => w.write_str("m")?,
        }
        Ok(Self::Clean)
    }
}

pub(crate) struct Formatter<'a,'f> where 'f: 'a {
    f: &'a mut fmt::Formatter<'f>,
    state: State,
}

impl<'a,'f> Formatter<'a,'f> where 'f: 'a {
    #[inline]
    pub(crate) fn fmt_ansi(f: &'a mut fmt::Formatter<'f>, ansi: Ansi) -> fmt::Result {
        if !ansi.is_empty() {
            let mut w = Self::new(f);
            ansi.write(&mut w)?;
            w.write_terminator()?;
        }
        Ok(())
    }
    #[inline]
    fn new(f: &'a mut fmt::Formatter<'f>) -> Self {
        Self { f, state: State::Clean }
    }
    #[inline]
    fn write_str(&mut self, s: &str) -> fmt::Result {
        self.state = self.state.write_str(self.f, s)?;
        Ok(())
    }
    #[cfg(feature="color256")]
    #[inline]
    fn write_fmt(&mut self, fmt: fmt::Arguments<'_>) -> fmt::Result {
        self.state = self.state.write_fmt(self.f, fmt)?;
        Ok(())
    }
    #[inline]
    fn write_terminator(&mut self) -> fmt::Result {
        self.state = self.state.write_terminator(self.f)?;
        Ok(())
    }

    pub(crate) fn write_reset(&mut self) -> fmt::Result { self.write_str("0") }

    pub(crate) fn write_color(&mut self, color: Coloree, value: ToggleColor) -> fmt::Result {
        match (color, value) {
            (Text,       ToggleColor::Reset) => { self.write_str("39") },
            (Background, ToggleColor::Reset) => { self.write_str("49") },
            (Text,       ToggleColor::Set(c)) => match c {
                #[cfg(feature="color256")]
                ColorNum(n)  => { self.write_fmt(format_args!("38;5;{}", n)) },
                #[cfg(feature="rgb")]
                Rgb(r,g,b)   => { self.write_fmt(format_args!("38;2;{};{};{}", r, g, b)) },
                Black        => { self.write_str( "30") },
                Red          => { self.write_str( "31") },
                Green        => { self.write_str( "32") },
                Yellow       => { self.write_str( "33") },
                Blue         => { self.write_str( "34") },
                Purple       => { self.write_str( "35") },
                Cyan         => { self.write_str( "36") },
                White        => { self.write_str( "37") },
                BrightBlack  => { self.write_str( "90") },
                BrightRed    => { self.write_str( "91") },
                BrightGreen  => { self.write_str( "92") },
                BrightYellow => { self.write_str( "93") },
                BrightBlue   => { self.write_str( "94") },
                BrightPurple => { self.write_str( "95") },
                BrightCyan   => { self.write_str( "96") },
                BrightWhite  => { self.write_str( "97") },
            },
            (Background, ToggleColor::Set(c)) => match c {
                #[cfg(feature="color256")]
                ColorNum(n)  => { self.write_fmt(format_args!("48;5;{}", n)) },
                #[cfg(feature="rgb")]
                Rgb(r,g,b)   => { self.write_fmt(format_args!("48;2;{};{};{}", r, g, b)) },
                Black        => { self.write_str( "40") },
                Red          => { self.write_str( "41") },
                Green        => { self.write_str( "42") },
                Yellow       => { self.write_str( "43") },
                Blue         => { self.write_str( "44") },
                Purple       => { self.write_str( "45") },
                Cyan         => { self.write_str( "46") },
                White        => { self.write_str( "47") },
                BrightBlack  => { self.write_str("100") },
                BrightRed    => { self.write_str("101") },
                BrightGreen  => { self.write_str("102") },
                BrightYellow => { self.write_str("103") },
                BrightBlue   => { self.write_str("104") },
                BrightPurple => { self.write_str("105") },
                BrightCyan   => { self.write_str("106") },
                BrightWhite  => { self.write_str("107") },
            },
        }
    }

    pub(crate) fn write_effect(&mut self, effect: Effect, value: Toggle) -> fmt::Result {
        match (effect, value) {
            (Bold,       Toggle::Reset) => { self.write_str("22") },
            (Faint,      Toggle::Reset) => { self.write_str("22") },
            (Italic,     Toggle::Reset) => { self.write_str("23") },
            (Underline,  Toggle::Reset) => { self.write_str("24") },
            (Blink,      Toggle::Reset) => { self.write_str("25") },
            (Reverse,    Toggle::Reset) => { self.write_str("27") },
            (Hidden,     Toggle::Reset) => { self.write_str("28") },
            (Strike,     Toggle::Reset) => { self.write_str("29") },
            (Bold,         Toggle::Set) => { self.write_str( "1") },
            (Faint,        Toggle::Set) => { self.write_str( "2") },
            (Italic,       Toggle::Set) => { self.write_str( "3") },
            (Underline,    Toggle::Set) => { self.write_str( "4") },
            (Blink,        Toggle::Set) => { self.write_str( "5") },
            (Reverse,      Toggle::Set) => { self.write_str( "7") },
            (Hidden,       Toggle::Set) => { self.write_str( "8") },
            (Strike,       Toggle::Set) => { self.write_str( "9") },
        }
    }
}