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

use crate::{styled_write, Ansi};
use std::io::{self, IsTerminal};
use std::fmt;
use std::cell::Cell;

use super::{AnsiPreference, AnsiWrite};

static mut ANSIOUT: Cell<Option<Ansi>> = Cell::new(None);
static mut ANSIERR: Cell<Option<Ansi>> = Cell::new(None);

/// A `Writer` that writes styled output to an inner [`StdoutLock`](std::io::StdoutLock) using
/// a configurable default [`Ansi`] instance.
///
/// Like its inner [`StdoutLock`](std::io::StdoutLock), each instance of this `Writer` is
/// a handle to a *shared* global construct. The configurable default [`Ansi`] is therefore
/// shared amongst all `Ansiout` instances. Threadsafe access is ensured thanks to the
/// inner lock's mutex.
///
/// Created by the [`ansiout`] method.
///
/// **Note**: only calls to this `Writer`'s [`write_fmt()`](io::Write::write_fmt()) method
/// will have the default ANSI styling applied. Calls to any other [`Write`](io::Write)
/// methods are unaffected.
pub struct Ansiout(io::StdoutLock<'static>);
/// A `Writer` that writes styled output to an inner [`StderrLock`](std::io::StderrLock) using
/// a configurable default [`Ansi`] instance.
///
/// Like its inner [`StderrLock`](std::io::StderrLock), each instance of this `Writer` is
/// a handle to a *shared* global construct. The configurable default [`Ansi`] is therefore
/// shared amongst all `Ansierr` instances. Threadsafe access is ensured thanks to the
/// inner lock's mutex.
///
/// Created by the [`ansierr`] method.
///
/// **Note**: only calls to this `Writer`'s [`write_fmt()`](io::Write::write_fmt()) method
/// will have the default ANSI styling applied. Calls to any other [`Write`](io::Write)
/// methods are unaffected.
pub struct Ansierr(io::StderrLock<'static>);

/// Creates an [`Ansiout`] that wraps the result of locking [`stdout()`](io::stdout())
///
pub fn ansiout() -> Ansiout { Ansiout(io::stdout().lock()) }
/// Creates an [`Ansierr`] that wraps the result of locking [`stderr()`](io::stderr())
pub fn ansierr() -> Ansierr { Ansierr(io::stderr().lock()) }

 impl Ansiout {
    // Needed so that this crate's paint*! macros work without having std::io::Write in scope
    #[inline]
    #[doc(hidden)]
    pub fn write_fmt(&mut self, fmt: fmt::Arguments<'_>) -> io::Result<()> {
        io::Write::write_fmt(self, fmt)
    }
}

impl Ansierr {
    // Needed so that this crate's paint*! macros work without having std::io::Write in scope
    #[inline]
    #[doc(hidden)]
    pub fn write_fmt(&mut self, fmt: fmt::Arguments<'_>) -> io::Result<()> {
        io::Write::write_fmt(self, fmt)
    }
}

impl AnsiWrite for Ansiout {
    fn ansi(&self) -> Ansi {
        // Note: actually safe, because we're holding a StdoutLock
        #[allow(static_mut_refs)]
        unsafe {
            match ANSIOUT.get() {
                None => {
                    let ansi: Ansi = self.preferred_ansi();
                    ANSIOUT.set(Some(ansi));
                    ansi
                },
                Some(ansi) => ansi,
            }
        }
    }

    fn set_ansi(&mut self, ansi: Ansi) {
        // Note: actually safe, because we're holding a StdoutLock
        #[allow(static_mut_refs)]
        unsafe { ANSIOUT.set(Some(ansi)); }
    }
}

impl AnsiWrite for Ansierr {
    fn ansi(&self) -> Ansi {
        // Note: actually safe, because we're holding a StderrLock
        #[allow(static_mut_refs)]
        unsafe {
            match ANSIERR.get() {
                None => {
                    let ansi: Ansi = self.preferred_ansi();
                    ANSIERR.set(Some(ansi));
                    ansi
                },
                Some(ansi) => ansi,
            }
        }
    }

    fn set_ansi(&mut self, ansi: Ansi) {
        // Note: actually safe, because we're holding a StderrLock
        #[allow(static_mut_refs)]
        unsafe { ANSIERR.set(Some(ansi)); }
    }
}

impl AnsiPreference for Ansiout {
    fn is_ansi_preferred(&self) -> bool { self.0.is_terminal() }
}
impl AnsiPreference for Ansierr {
    fn is_ansi_preferred(&self) -> bool { self.0.is_terminal() }
}

impl io::Write for Ansiout {
    fn write_fmt(&mut self, fmt: fmt::Arguments<'_>) -> io::Result<()> {
        if ! self.ansi().is_empty() {
            styled_write!(self.0, self.ansi(), "{}", fmt)
        } else {
            self.0.write_fmt(fmt)
        }
    }
    fn write(&mut self, buf: &[u8]) -> io::Result<usize> { self.0.write(buf) }
    fn flush(&mut self) -> io::Result<()> { self.0.flush() }
}
impl io::Write for Ansierr {
    fn write_fmt(&mut self, fmt: fmt::Arguments<'_>) -> io::Result<()> {
        if ! self.ansi().is_empty() {
            styled_write!(self.0, self.ansi(), "{}", fmt)
        } else {
            self.0.write_fmt(fmt)
        }
    }
    fn write(&mut self, buf: &[u8]) -> io::Result<usize> { self.0.write(buf) }
    fn flush(&mut self) -> io::Result<()> { self.0.flush() }
}