clap_verbosity_flag/
tracing.rs

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
// These re-exports of the tracing crate types it easy to use this crate without having to depend on
// the tracing crate directly. See <https://github.com/clap-rs/clap-verbosity-flag/issues/54> for
// more information.
pub use tracing_core::{Level, LevelFilter};

use crate::VerbosityFilter;

impl From<VerbosityFilter> for LevelFilter {
    fn from(filter: VerbosityFilter) -> Self {
        match filter {
            VerbosityFilter::Off => LevelFilter::OFF,
            VerbosityFilter::Error => LevelFilter::ERROR,
            VerbosityFilter::Warn => LevelFilter::WARN,
            VerbosityFilter::Info => LevelFilter::INFO,
            VerbosityFilter::Debug => LevelFilter::DEBUG,
            VerbosityFilter::Trace => LevelFilter::TRACE,
        }
    }
}

impl From<LevelFilter> for VerbosityFilter {
    fn from(level: LevelFilter) -> Self {
        match level {
            LevelFilter::OFF => Self::Off,
            LevelFilter::ERROR => Self::Error,
            LevelFilter::WARN => Self::Warn,
            LevelFilter::INFO => Self::Info,
            LevelFilter::DEBUG => Self::Debug,
            LevelFilter::TRACE => Self::Trace,
        }
    }
}

impl From<VerbosityFilter> for Option<Level> {
    fn from(filter: VerbosityFilter) -> Self {
        match filter {
            VerbosityFilter::Off => None,
            VerbosityFilter::Error => Some(Level::ERROR),
            VerbosityFilter::Warn => Some(Level::WARN),
            VerbosityFilter::Info => Some(Level::INFO),
            VerbosityFilter::Debug => Some(Level::DEBUG),
            VerbosityFilter::Trace => Some(Level::TRACE),
        }
    }
}

impl From<Option<Level>> for VerbosityFilter {
    fn from(level: Option<Level>) -> Self {
        match level {
            None => Self::Off,
            Some(Level::ERROR) => Self::Error,
            Some(Level::WARN) => Self::Warn,
            Some(Level::INFO) => Self::Info,
            Some(Level::DEBUG) => Self::Debug,
            Some(Level::TRACE) => Self::Trace,
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::{DebugLevel, ErrorLevel, InfoLevel, OffLevel, TraceLevel, Verbosity, WarnLevel};

    #[test]
    fn tracing_level() {
        let v = Verbosity::<OffLevel>::default();
        assert_eq!(v.tracing_level(), None);
        assert_eq!(v.tracing_level_filter(), LevelFilter::OFF);

        let v = Verbosity::<ErrorLevel>::default();
        assert_eq!(v.tracing_level(), Some(Level::ERROR));
        assert_eq!(v.tracing_level_filter(), LevelFilter::ERROR);

        let v = Verbosity::<WarnLevel>::default();
        assert_eq!(v.tracing_level(), Some(Level::WARN));
        assert_eq!(v.tracing_level_filter(), LevelFilter::WARN);

        let v = Verbosity::<InfoLevel>::default();
        assert_eq!(v.tracing_level(), Some(Level::INFO));
        assert_eq!(v.tracing_level_filter(), LevelFilter::INFO);

        let v = Verbosity::<DebugLevel>::default();
        assert_eq!(v.tracing_level(), Some(Level::DEBUG));
        assert_eq!(v.tracing_level_filter(), LevelFilter::DEBUG);

        let v = Verbosity::<TraceLevel>::default();
        assert_eq!(v.tracing_level(), Some(Level::TRACE));
        assert_eq!(v.tracing_level_filter(), LevelFilter::TRACE);
    }
}