lux-lib 0.49.1

Library for the lux package manager for Lua
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
143
144
145
146
147
148
149
150
151
152
153
154
155
156

use std::collections::VecDeque;
use std::sync::Mutex;

use lazy_static::lazy_static;
use serde::Serialize;

const MAX_BACKLOG: usize = 200;

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
#[serde(rename_all = "lowercase")]
pub enum LogLevel {
    Info,
    Warn,
    Error,
}

#[derive(Debug, Clone, Serialize)]
pub struct LogEntry {
    pub level: LogLevel,
    pub message: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub target: Option<String>,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum LoggingState {
    Disabled,
    Enabled,
}

lazy_static! {
    static ref LOG_BUFFER: Mutex<VecDeque<LogEntry>> = Mutex::new(VecDeque::new());
    static ref LOG_STATE: Mutex<LoggingState> = Mutex::new(LoggingState::Disabled);
}

#[allow(clippy::expect_used)]
pub fn set_state(state: LoggingState) {
    *LOG_STATE.lock().expect("log lock poisoned") = state;
}

#[allow(clippy::expect_used)]
pub fn state() -> LoggingState {
    *LOG_STATE.lock().expect("log lock poisoned")
}

#[allow(clippy::expect_used)]
pub fn info(message: String, target: Option<String>) {
    match state() {
        LoggingState::Enabled => push(LogLevel::Info, message, target),
        LoggingState::Disabled => println!("{}", message),
    }
}

pub fn warn(message: String, target: Option<String>) {
    match state() {
        LoggingState::Enabled => push(LogLevel::Warn, message, target),
        LoggingState::Disabled => eprintln!("{}", message),
    }
}

#[allow(clippy::expect_used)]
pub fn error(message: String, target: Option<String>) {
    match state() {
        LoggingState::Enabled => push(LogLevel::Error, message, target),
        LoggingState::Disabled => eprintln!("{}", message),
    }
}

#[allow(clippy::expect_used)]
pub fn push(level: LogLevel, message: String, target: Option<String>) {
    if let LoggingState::Disabled = state() {
        return;
    }

    let entry = LogEntry {
        level,
        message,
        target,
    };

    let mut buffer = LOG_BUFFER.lock().expect("log lock poisoned");

    buffer.push_back(entry);

    if buffer.len() > MAX_BACKLOG {
        buffer.pop_front();
    }
}

#[allow(clippy::expect_used)]
pub fn drain() -> Vec<LogEntry> {
    if let LoggingState::Disabled = state() {
        return Vec::new();
    }

    let mut buffer = LOG_BUFFER.lock().expect("log lock poisoned");
    buffer.drain(..).collect()
}

#[allow(clippy::expect_used)]
pub fn clear() {
    let mut buffer = LOG_BUFFER.lock().expect("log lock poisoned");

    buffer.clear();
}

#[cfg(test)]
mod tests {
    use serial_test::serial;

    use super::*;

    fn reset() {
        set_state(LoggingState::Disabled);
        clear();
    }

    #[test]
    #[serial]
    fn test_push_and_drain() {
        reset();
        set_state(LoggingState::Enabled);
        push(LogLevel::Info, "info".to_string(), None);
        push(
            LogLevel::Warn,
            "warning".to_string(),
            Some("build".to_string()),
        );
        push(
            LogLevel::Error,
            "error".to_string(),
            Some("fetch".to_string()),
        );

        let entries = drain();
        assert_eq!(entries.len(), 3);
        assert!(matches!(entries[0].level, LogLevel::Info));
        assert_eq!(entries[0].message, "info");
        assert!(entries[0].target.is_none());
        assert!(matches!(entries[1].level, LogLevel::Warn));
        assert_eq!(entries[1].message, "warning");
        assert_eq!(entries[1].target.as_deref(), Some("build"));
        assert!(matches!(entries[2].level, LogLevel::Error));

        assert!(drain().is_empty());
    }

    #[test]
    #[serial]
    fn test_push_noop_when_disabled() {
        reset();
        set_state(LoggingState::Disabled);
        push(LogLevel::Info, "should not appear".to_string(), None);
        assert!(drain().is_empty());
    }
}