hackerlog 0.2.0

A simple logging tool with no fluff for hackers.
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

#[derive(Debug, Clone)]
pub enum FormatPlaceholder {
    Level,
    Symbol,
    Message,
    Time,
    Date,
    DateTime,
    ThreadName,
    ThreadId,
    ProcessId,
    File,
    Line,
    Context,
    Text(String),
}

#[derive(Debug, Clone, Default)]
pub struct FormatTemplate {
    pub(crate) parts: Vec<FormatPlaceholder>,
}

impl FormatTemplate {
    pub fn new() -> Self {
        Self { parts: Vec::new() }
    }

    pub fn parse(template: &str) -> Self {
        let mut parts = Vec::new();
        let mut current = 0;

        while let Some(start) = template[current..].find('{') {
            let abs_start = current + start;

            // Add preceding text if any
            if abs_start > current {
                parts.push(FormatPlaceholder::Text(
                    template[current..abs_start].to_string(),
                ));
            }

            // Find closing brace
            if let Some(end) = template[abs_start..].find('}') {
                let placeholder = &template[abs_start + 1..abs_start + end];
                let part = match placeholder {
                    "level" => FormatPlaceholder::Level,
                    "symbol" => FormatPlaceholder::Symbol,
                    "message" => FormatPlaceholder::Message,
                    "time" => FormatPlaceholder::Time,
                    "date" => FormatPlaceholder::Date,
                    "datetime" => FormatPlaceholder::DateTime,
                    "thread" => FormatPlaceholder::ThreadName,
                    "thread_id" => FormatPlaceholder::ThreadId,
                    "pid" => FormatPlaceholder::ProcessId,
                    "file" => FormatPlaceholder::File,
                    "line" => FormatPlaceholder::Line,
                    "context" => FormatPlaceholder::Context,
                    _ => FormatPlaceholder::Text(format!("{{{}}}", placeholder)),
                };
                parts.push(part);
                current = abs_start + end + 1;
            } else {
                // No closing brace found, treat rest as text
                parts.push(FormatPlaceholder::Text(template[abs_start..].to_string()));
                break;
            }
        }

        // Add remaining text
        if current < template.len() {
            parts.push(FormatPlaceholder::Text(template[current..].to_string()));
        }

        Self { parts }
    }
}