e62rs 1.5.0

An in-terminal E621/926 browser.
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

//! error handling stuff
use thiserror::Error;

/// An error
#[derive(Debug, Error)]
pub enum E6Error {
    /// an IO error
    #[error("i/o error: {0}")]
    IO(#[from] std::io::Error),

    /// an infallible conversion error
    #[error("infallible conversion error: {0}")]
    InfallibleConversion(#[from] std::convert::Infallible),

    /// a boundbook error
    #[error("boundbook error: {0}")]
    BoundBook(#[from] boundbook::BbfError),

    /// a csv error
    #[error("csv error: {0}")]
    Csv(#[from] csv::Error),

    /// a redb transaction error
    #[error("redb transaction error: {0}")]
    RedbTransaction(#[from] redb::TransactionError),

    /// a redb table error
    #[error("redb table error: {0}")]
    RedbTable(#[from] redb::TableError),

    /// a redb storage error
    #[error("redb storage error: {0}")]
    RedbStorage(#[from] redb::StorageError),

    /// a redb commit error
    #[error("redb commit error: {0}")]
    RedbCommit(#[from] redb::CommitError),

    /// a system time error
    #[error("system time error: {0}")]
    SystemTime(#[from] std::time::SystemTimeError),

    /// a report from color_eyre
    #[error("{0}")]
    EyreReport(#[from] color_eyre::Report),

    /// a report from miette
    #[error("{0}")]
    MietteReport(miette::Report),

    /// a reqwest error
    #[error("reqwest error: {0}")]
    Reqwest(#[from] reqwest::Error),

    /// a qr code error
    #[error("qr code error: {0}")]
    QR(#[from] qrcode::types::QrError),

    /// a json error
    #[error("json error: {0}")]
    Json(#[from] serde_json::Error),

    /// a toml serialization error
    #[error("toml serialization error: {0}")]
    TOMLSer(#[from] toml::ser::Error),

    /// a miette hook install error
    #[error("error installing miette hook: {0}")]
    MietteInstall(#[from] miette::InstallError),

    /// a tokio acquire error
    #[error("tokio acquire error: {0}")]
    TokioAcquire(#[from] tokio::sync::AcquireError),

    /// an int parse error
    #[error("int parse error: {0}")]
    ParseInt(#[from] std::num::ParseIntError),

    /// an addr parse error
    #[error("error parsing address: {0}")]
    ParseAddr(#[from] std::net::AddrParseError),

    /// a custom error
    #[error("error: {0}")]
    Other(String),
}

impl From<String> for E6Error {
    fn from(value: String) -> Self {
        Self::Other(value)
    }
}

impl From<miette::Report> for E6Error {
    fn from(value: miette::Report) -> Self {
        Self::MietteReport(value)
    }
}

/// A result using [`E6Error`] as the `Err` variant
pub type Result<T, U = E6Error> = miette::Result<T, U>;

/// a report
pub struct Report;

impl Report {
    /// make a new error from a compatible type
    #[allow(clippy::new_ret_no_self)]
    pub fn new<T>(e: T) -> E6Error
    where
        E6Error: std::convert::From<T>,
        T: Into<E6Error>,
    {
        E6Error::from(e)
    }
}

/// bail
#[macro_export]
macro_rules! bail {
    ($msg:literal $(,)?) => {
        return Err($crate::error::E6Error::from(String::from($msg)))
    };

    ($err:expr $(,)?) => {
        return Err($crate::error::E6Error::from($err))
    };

    ($fmt:expr, $($arg:tt)*) => {
        return Err($crate::error::E6Error::from(format!($fmt, $($arg)*)))
    };
}