logr 1.0.0

Logging for men
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
133
134
135
136
137
138
139
140
141
142

extern crate chrono;
extern crate colored;

use chrono::prelude::*;
use colored::*;

pub struct Logger {
    pub name: String,
    pub config: LoggerConfig,
}

pub struct LoggerConfig {
    pub time_format: String,
    pub short_name: bool,
}

pub enum LoggerLevel {
    Info,
    Error,
    Debug,
    Warn,
}

impl LoggerConfig {
    pub fn new() -> LoggerConfig {
        LoggerConfig {
            time_format: "%Y-%m-%d %H:%M:%S".to_string(),
            short_name: false,
        }
    }

    pub fn time(mut self, format: &str) -> LoggerConfig {
        self.time_format = format.to_string();
        self
    }

    pub fn short_name(mut self, short: bool) -> LoggerConfig {
        self.short_name = short;
        self
    }
}

impl Logger {
    pub fn get<T>() -> Logger {
        let name = std::any::type_name::<T>();
        Logger {
            name: name.to_string(),
            config: LoggerConfig {
                time_format: "%Y-%m-%d %H:%M:%S".to_string(),
                short_name: false,
            },
        }
    }

    pub fn get_config<T>(config: LoggerConfig) -> Logger {
        let full_name = std::any::type_name::<T>();
        let name = full_name.split("::").last().unwrap();
        Logger {
            name: name.to_string(),
            config,
        }
    }

    pub fn get_name(name: &str) -> Logger {
        Logger {
            name: name.to_string(),
            config: LoggerConfig {
                time_format: "%Y-%m-%d %H:%M:%S".to_string(),
                short_name: false,
            },
        }
    }

    pub fn get_name_config(name: &str, config: LoggerConfig) -> Logger {
        Logger {
            name: name.to_string(),
            config,
        }
    }

    pub fn info(&self, m: &str) {
        self.log(LoggerLevel::Info, m)
    }

    pub fn error(&self, m: &str) {
        self.log(LoggerLevel::Error, m)
    }

    pub fn debug(&self, m: &str) {
        self.log(LoggerLevel::Debug, m)
    }

    pub fn warn(&self, m: &str) {
        self.log(LoggerLevel::Warn, m)
    }

    pub fn log(&self, level: LoggerLevel, m: &str) {
        let lvl: ColoredString;

        match level {
            LoggerLevel::Info => lvl = "info".blue(),
            LoggerLevel::Error => lvl = "err".red(),
            LoggerLevel::Debug => lvl = "debug".yellow(),
            LoggerLevel::Warn => lvl = "warn".bold().yellow(),
        }

        println!(
            "[{}] [{}] {}: {}",
            Local::now()
                .format(&self.config.time_format)
                .to_string()
                .purple(),
            self.name.bold().green(),
            lvl,
            m
        )
    }
}

#[cfg(test)]
mod tests {
    use crate::{Logger, LoggerConfig};

    #[test]
    pub fn log_test() {
        let logger = Logger::get::<Logger>();
        logger.info("hi");
        logger.error("hi");
        logger.debug("hi");
        logger.warn("hi");
    }

    #[test]
    pub fn log_config_test() {
        let logger = Logger::get_config::<Logger>(LoggerConfig::new().time("%Y").short_name(false));

        logger.info("hi");
        logger.error("hi");
        logger.debug("hi");
        logger.warn("hi");
    }
}