zero4rs 2.0.0

zero4rs is a powerful, pragmatic, and extremely fast web framework for Rust
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

use std::fmt::Arguments;

use clap::Parser;
use fern::colors::{Color, ColoredLevelConfig};
use fern::FormatCallback;
use log::{LevelFilter, Record};
use strum::EnumString;

#[derive(Parser)]
pub struct LoggingArgs {
    /// Sets the log-level of rustube [default: Info]
    /// (-v = Error, ..., -vvvvv = Trace)
    /// (other crates have log level Warn)
    // #[clap(long, short, parse(from_occurrences))]
    #[clap(long, short)]
    verbose: u8,

    /// Show a progress bar
    #[clap(long, short, conflicts_with = "verbose")]
    progress: bool,

    /// When to log coloredd
    // #[clap(long, default_value = "always", possible_values = & ["always", "never"], value_name = "WHEN")]
    #[clap(long, default_value = "always",
        value_parser = clap::builder::PossibleValuesParser::new(["always", "never"]),
        value_name = "WHEN")]
    color: ColorUsage,

    /// Turn off logging for all crates
    #[clap(long, short, conflicts_with = "verbose")]
    quiet: bool,
}

impl LoggingArgs {
    pub fn init_logger(&self) {
        if self.quiet || self.progress {
            return;
        }

        let formatter = self.log_msg_formatter();

        fern::Dispatch::new()
            .level(log::LevelFilter::Warn)
            .level_for("rustube", self.level_filter())
            .format(formatter)
            .chain(std::io::stdout())
            .apply()
            .expect("The global logger was already initialized");
    }

    fn log_msg_formatter(&self) -> fn(FormatCallback, &Arguments, &Record) {
        #[inline(always)]
        fn format_msg(
            out: FormatCallback,
            level: impl std::fmt::Display,
            record: &Record,
            msg: &Arguments,
        ) {
            out.finish(format_args!(
                "{:<5} [{}:{}]: {}",
                level,
                record.target(),
                record.line().unwrap_or_default(),
                msg,
            ))
        }

        match self.color {
            ColorUsage::Always => |out: FormatCallback, message: &Arguments, record: &Record| {
                static COLORS: ColoredLevelConfig = ColoredLevelConfig {
                    error: Color::Red,
                    warn: Color::Yellow,
                    info: Color::Green,
                    debug: Color::BrightBlue,
                    trace: Color::White,
                };

                format_msg(out, COLORS.color(record.level()), record, message);
            },
            ColorUsage::Never => |out: FormatCallback, message: &Arguments, record: &Record| {
                format_msg(out, record.level(), record, message);
            },
        }
    }

    fn level_filter(&self) -> log::LevelFilter {
        match self.verbose {
            1 => LevelFilter::Error,
            2 => LevelFilter::Warn,
            0 | 3 => LevelFilter::Info,
            4 => LevelFilter::Debug,
            _ => LevelFilter::Trace,
        }
    }
}

#[derive(Parser, EnumString, Clone)]
#[strum(serialize_all = "kebab-case")]
enum ColorUsage {
    Always,
    Never,
}