logform 0.7.0

logform 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

use super::Format;
use crate::LogInfo;
use regex::Regex;

#[derive(Clone)]
pub struct Uncolorize {
    level: bool,
    message: bool,
}

impl Default for Uncolorize {
    fn default() -> Self {
        Self::new()
    }
}

impl Uncolorize {
    pub fn new() -> Self {
        Self {
            level: true,
            message: true,
        }
    }

    pub fn with_level(mut self, strip_level: bool) -> Self {
        self.level = strip_level;
        self
    }

    pub fn with_message(mut self, strip_message: bool) -> Self {
        self.message = strip_message;
        self
    }

    pub fn transform(&self, mut info: LogInfo) -> Option<LogInfo> {
        if self.level {
            info.level = strip_colors(&info.level);
        }
        if self.message {
            info.message = strip_colors(&info.message);
        }
        Some(info)
    }
}

use std::sync::OnceLock;

static STRIP_COLORS_REGEX: OnceLock<Regex> = OnceLock::new();

fn strip_colors(input: &str) -> String {
    let re = STRIP_COLORS_REGEX.get_or_init(|| Regex::new(r"\x1b\[[0-9;]*m").unwrap());
    re.replace_all(input, "").to_string()
}

impl Format for Uncolorize {
    type Input = LogInfo;

    fn transform(&self, info: LogInfo) -> Option<Self::Input> {
        self.transform(info)
    }
}

pub fn uncolorize() -> Uncolorize {
    Uncolorize::new()
}

#[cfg(test)]
mod tests {
    use super::super::colorize::colorize;
    use super::*;
    use colored::control::set_override;
    use serde_json::json;

    #[test]
    fn test_uncolorize_formatter() {
        set_override(true);

        let colors = vec![
            ("info".to_string(), json!(["blue"])),
            ("error".to_string(), json!(["red", "bold"])),
        ]
        .into_iter()
        .collect::<std::collections::HashMap<_, _>>();
        let colorizer = colorize().with_colors(colors).with_all(true);

        let info = LogInfo::new("info", "This is an info message").with_meta("key", "value");
        let colorized_info = colorizer.transform(info).unwrap();

        let uncolorizer = uncolorize();
        let uncolorized_info = uncolorizer.transform(colorized_info.clone()).unwrap();

        assert_eq!(uncolorized_info.level, "info");
        assert_eq!(uncolorized_info.message, "This is an info message");
    }
}