cranko 0.0.25

A cross-platform, cross-language release automation tool
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

// Copyright 2020 Peter Williams <peter@newton.cx> and collaborators
// Licensed under the MIT License.

//! A very simple logger.
//!
//! I've had a shockingly difficult time finding a simple logging option the
//! provides the CLI look that I want.
//!
//! Loosely derived from the logger in ripgrep, but with a few more bells and
//! whistles.

use lazy_static::lazy_static;
use log::{Level, Log};
use std::{
    io::{self, Write},
    sync::RwLock,
};
use termcolor::{Color, ColorChoice, ColorSpec, StandardStream, WriteColor};

/// A simple logger.
pub struct Logger {
    inner: RwLock<InnerLogger>,
    trace_cspec: ColorSpec,
    debug_cspec: ColorSpec,
    info_cspec: ColorSpec,
    warn_cspec: ColorSpec,
    error_cspec: ColorSpec,
}

pub struct InnerLogger {
    stdout: StandardStream,
    stderr: StandardStream,
}

lazy_static! {
    static ref LOGGER: Logger = {
        let stdout = StandardStream::stdout(ColorChoice::Auto);
        let stderr = StandardStream::stderr(ColorChoice::Auto);
        let trace_cspec = ColorSpec::new();
        let debug_cspec = ColorSpec::new();
        let mut info_cspec = ColorSpec::new();
        let mut warn_cspec = ColorSpec::new();
        let mut error_cspec = ColorSpec::new();

        warn_cspec.set_fg(Some(Color::Yellow)).set_bold(true);
        info_cspec.set_fg(Some(Color::Green)).set_bold(true);
        error_cspec.set_fg(Some(Color::Red)).set_bold(true);

        Logger {
            inner: RwLock::new(InnerLogger { stdout, stderr }),
            trace_cspec,
            debug_cspec,
            info_cspec,
            warn_cspec,
            error_cspec,
        }
    };
}

impl Logger {
    /// Set up this type as the global static logger.
    pub fn init() -> Result<(), log::SetLoggerError> {
        log::set_logger(&*LOGGER)
    }

    pub fn print_cause(err: &(dyn std::error::Error + 'static)) {
        if let Ok(mut inner) = LOGGER.inner.write() {
            let _r = inner.stderr.set_color(&LOGGER.error_cspec);
            let _r = write!(&mut inner.stderr, "caused by:");
            let _r = inner.stderr.reset();
            let _r = writeln!(&mut inner.stderr, " {}", err);
        }
    }
}

impl Log for Logger {
    fn enabled(&self, _: &log::Metadata) -> bool {
        // Rely on `log::set_max_level()` for filtering
        true
    }

    fn log(&self, record: &log::Record) {
        if let Ok(mut inner) = self.inner.write() {
            match record.level() {
                Level::Trace => {
                    let _r = inner.stderr.set_color(&self.trace_cspec);
                    let _r = write!(&mut inner.stderr, "trace:");
                    let _r = inner.stderr.reset();
                    let _r = writeln!(&mut inner.stderr, " {}", record.args());
                }

                Level::Debug => {
                    let _r = inner.stderr.set_color(&self.debug_cspec);
                    let _r = write!(&mut inner.stderr, "debug:");
                    let _r = inner.stderr.reset();
                    let _r = writeln!(&mut inner.stderr, " {}", record.args());
                }

                Level::Info => {
                    let _r = inner.stdout.set_color(&self.info_cspec);
                    let _r = write!(&mut inner.stdout, "info:");
                    let _r = inner.stdout.reset();
                    let _r = writeln!(&mut inner.stdout, " {}", record.args());
                }

                Level::Warn => {
                    let _r = inner.stderr.set_color(&self.warn_cspec);
                    let _r = write!(&mut inner.stderr, "warning:");
                    let _r = inner.stderr.reset();
                    let _r = writeln!(&mut inner.stderr, " {}", record.args());
                }

                Level::Error => {
                    let _r = inner.stderr.set_color(&self.error_cspec);
                    let _r = write!(&mut inner.stderr, "error:");
                    let _r = inner.stderr.reset();
                    let _r = writeln!(&mut inner.stderr, " {}", record.args());
                }
            }
        }
    }

    fn flush(&self) {
        let _r = io::stdout().flush();
    }
}