terminator 0.3.2

Formatter for pretty panics and errors
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

use std::backtrace::Backtrace;
use std::error::Error;
use std::fmt::Debug;
use std::fmt::Display;
use std::fmt::Formatter;
use std::fmt::Result;
use std::fmt::Write;

use crate::indent::Indent;
use crate::Config;
use crate::GLOBAL_SETTINGS;

#[cfg(feature = "eyre")]
mod eyreimpl;
#[cfg(not(any(feature = "anyhow", feature = "eyre")))]
mod stdimpl;

#[cfg(not(any(feature = "anyhow", feature = "eyre")))]
type Inner = Box<stdimpl::DynError>;
#[cfg(feature = "anyhow")]
type Inner = anyhow::Error;
#[cfg(feature = "eyre")]
type Inner = eyre::Report;

/// Why not use this in main function as `Error` value? It's so pretty :)
pub struct Terminator {
    inner: Inner,
}

impl Terminator {
    fn new(inner: Inner) -> Self {
        Self { inner }
    }

    fn chain(&self) -> impl Iterator<Item = &(dyn Error + 'static)> {
        self.inner.chain()
    }

    #[cfg(not(any(feature = "anyhow", feature = "eyre")))]
    fn backtrace(&self) -> Option<&Backtrace> {
        self.inner.backtrace()
    }

    #[cfg(feature = "anyhow")]
    fn backtrace(&self) -> Option<&Backtrace> {
        let backtrace = self.inner.backtrace();
        if backtrace.status() == std::backtrace::BacktraceStatus::Captured {
            Some(backtrace)
        } else {
            None
        }
    }

    #[cfg(feature = "eyre")]
    fn backtrace(&self) -> Option<&Backtrace> {
        self.inner
            .handler()
            .downcast_ref::<eyreimpl::BacktraceHandler>()
            .and_then(eyreimpl::BacktraceHandler::backtrace)
    }
}

impl Debug for Terminator {
    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
        if f.alternate() {
            return Debug::fmt(&self.inner, f);
        }

        let config = GLOBAL_SETTINGS.get_or_init(Config::new);

        for (index, error) in self.chain().enumerate() {
            write!(f, "\n{:>4}: {}", index, config.theme.error.style(error))?;
        }

        write!(Indent::double(f), "\n\n{}", config.bundle(self.backtrace()))
    }
}

impl Display for Terminator {
    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
        writeln!(f, "Error: {self:?}")
    }
}

#[cfg(feature = "anyhow")]
impl<E> From<E> for Terminator
where
    E: Into<Inner>,
{
    fn from(value: E) -> Self {
        Self::new(value.into())
    }
}

#[cfg(feature = "eyre")]
impl<E> From<E> for Terminator
where
    E: Into<Inner>,
{
    fn from(value: E) -> Self {
        Self::new(value.into())
    }
}

#[cfg(not(any(feature = "anyhow", feature = "eyre")))]
impl<E> From<E> for Terminator
where
    E: Error + Send + Sync + 'static,
{
    fn from(value: E) -> Self {
        Self::new(value.into())
    }
}

/// Error for when [`Config`] had already been installed
#[derive(Debug)]
pub struct InstallError;

impl Display for InstallError {
    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
        f.write_str("`Config` was already installed globally")
    }
}

impl Error for InstallError {}