src/handlers/formatters/mod.rs

Lines

100.00 %

Functions

100.00 %

Regions

100.00 %


//
// File Name:    mod.rs
// Directory:    src/handlers/formatters
// Project Name: flogging
//
// Copyright (C) 2025 Bradley Willcott
//
// SPDX-License-Identifier: GPL-3.0-or-later
//
// This library (crate) is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This library (crate) is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this library (crate).  If not, see <https://www.gnu.org/licenses/>.
//

//!
//! # Formatter
//!

// #![allow(unused)]

mod format_trait;
mod format_type;
mod formatter;
mod iso8601_formatter;
mod mock_formatter;
mod simple_formatter;
mod unixtimestamp_formatter;

use crate::LogEntry;
pub use format_trait::FormatTrait;
pub use format_type::FormatType;
pub use formatter::Formatter;
pub use iso8601_formatter::Iso8601Formatter;
pub use mock_formatter::MockFormatter;
pub use simple_formatter::SimpleFormatter;
pub use unixtimestamp_formatter::UnixTimestampFormatter;

#[cfg(test)]
mod test {
    use std::io::{Result, Write};
    // use super::*;
    use crate::{Level::*, *};
    use regex::Regex;

    #[test]
    fn iso8601() {
        let re_str = "^
dt_fmt: \"%\\+\" - fmt_string: \"\\{dt:35} \\{mod_path}->\\{fn_name} \\[\\{level:7}] \\{message}\"
(?:\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}\\.\\d{9}\\+\\d{2}:\\d{2}) ->iso8601 \\[INFO   ] This is a test message
$";

        let re = Regex::new(re_str).unwrap();
        let mut buf = Vec::new();

        let le = LogEntry::create(
            INFO,
            "iso8601".to_string(),
            "This is a test message".to_string(),
        );

        let f = FormatType::Iso8601.create(None);
        let fs = f.format(&le);
        // println!("\n{f:width$}\n{fs}", width = f.width());
        writeln!(&mut buf, "\n{f:width$}\n{fs}", width = f.width()).expect("writeln!() failed");
        let result = String::from_utf8(buf).unwrap();
        // println!("{result}",);

        assert!(re.is_match(&result));
    }

    #[test]
    fn simple_formatter() {
        let expected = "
dt_fmt: \"\" - fmt_string: \"{mod_path}->{fn_name} [{level:7}] {message}\"
->simple_formatter [INFO   ] This is a test message
"
        .to_string();

        let mut buf = Vec::new();

        let le = LogEntry::create(
            INFO,
            "simple_formatter".to_string(),
            "This is a test message".to_string(),
        );

        let f = FormatType::Simple.create(None);
        let fs = f.format(&le);
        // println!("\n{f:width$} {fs}\n", width = f.width());
        writeln!(&mut buf, "\n{f:width$}\n{fs}", width = f.width()).expect("writeln!() failed");

        assert_eq!(expected, String::from_utf8(buf).unwrap());
    }

    #[test]
    fn unix_timestamp() {
        let re_str = "^
dt_fmt: \"%s\\.%f\" - fmt_string: \"\\{dt} \\{mod_path}->\\{fn_name} \\[\\{level:7}] \\{message}\"
(?:\\d{10}\\.\\d{9}) ->unix_timestamp \\[INFO   ] This is a test message
$";

        let re = Regex::new(re_str).unwrap();
        let mut buf = Vec::new();

        let le = LogEntry::create(
            INFO,
            "unix_timestamp".to_string(),
            "This is a test message".to_string(),
        );

        let f = FormatType::UnixTimestamp.create(None);
        let fs = f.format(&le);
        // println!("\n{f:width$}\n{fs}", width = f.width());
        writeln!(&mut buf, "\n{f:width$}\n{fs}", width = f.width()).expect("writeln!() failed");
        let result = String::from_utf8(buf).unwrap();
        // println!("{result}",);

        assert!(re.is_match(&result));
    }

    #[test]
    fn custom() {
        let expected = "\nMockFormatter
MockFormatter
"
        .to_string();

        let mut buf = Vec::new();

        let le = LogEntry::create(
            INFO,
            "custom".to_string(),
            "Testing MockFormatter".to_string(),
        );
        let f = FormatType::Custom.create(Some(Box::new(MockFormatter::new())));
        let fs = f.format(&le);
        // println!("\n{f:width$}\n{fs}", width = f.width());
        writeln!(&mut buf, "\n{f:width$}\n{fs}", width = f.width()).expect("writeln!() failed");

        assert_eq!(expected, String::from_utf8(buf).unwrap());
    }
}

Line	Count	Source
1		//
2		// File Name: mod.rs
3		// Directory: src/handlers/formatters
4		// Project Name: flogging
5		//
6		// Copyright (C) 2025 Bradley Willcott
7		//
8		// SPDX-License-Identifier: GPL-3.0-or-later
9		//
10		// This library (crate) is free software: you can redistribute it and/or modify
11		// it under the terms of the GNU General Public License as published by
12		// the Free Software Foundation, either version 3 of the License, or
13		// (at your option) any later version.
14		//
15		// This library (crate) is distributed in the hope that it will be useful,
16		// but WITHOUT ANY WARRANTY; without even the implied warranty of
17		// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18		// GNU General Public License for more details.
19		//
20		// You should have received a copy of the GNU General Public License
21		// along with this library (crate). If not, see <https://www.gnu.org/licenses/>.
22		//
23
24		//!
25		//! # Formatter
26		//!
27
28		// #![allow(unused)]
29
30		mod format_trait;
31		mod format_type;
32		mod formatter;
33		mod iso8601_formatter;
34		mod mock_formatter;
35		mod simple_formatter;
36		mod unixtimestamp_formatter;
37
38		use crate::LogEntry;
39		pub use format_trait::FormatTrait;
40		pub use format_type::FormatType;
41		pub use formatter::Formatter;
42		pub use iso8601_formatter::Iso8601Formatter;
43		pub use mock_formatter::MockFormatter;
44		pub use simple_formatter::SimpleFormatter;
45		pub use unixtimestamp_formatter::UnixTimestampFormatter;
46
47		#[cfg(test)]
48		mod test {
49		use std::io::{Result, Write};
50		// use super::*;
51		use crate::{Level::, };
52		use regex::Regex;
53
54		#[test]
55	1	fn iso8601() {
56	1	let re_str = "^
57	1	dt_fmt: \"%\\+\" - fmt_string: \"\\{dt:35} \\{mod_path}->\\{fn_name} \\[\\{level:7}] \\{message}\"
58	1	(?:\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}\\.\\d{9}\\+\\d{2}:\\d{2}) ->iso8601 \\[INFO ] This is a test message
59	1	$";
60
61	1	let re = Regex::new(re_str).unwrap();
62	1	let mut buf = Vec::new();
63
64	1	let le = LogEntry::create(
65	1	INFO,
66	1	"iso8601".to_string(),
67	1	"This is a test message".to_string(),
68		);
69
70	1	let f = FormatType::Iso8601.create(None);
71	1	let fs = f.format(&le);
72		// println!("\n{f:width$}\n{fs}", width = f.width());
73	1	writeln!(&mut buf, "\n{f:width$}\n{fs}", width = f.width()).expect("writeln!() failed");
74	1	let result = String::from_utf8(buf).unwrap();
75		// println!("{result}",);
76
77	1	assert!(re.is_match(&result));
78	1	}
79
80		#[test]
81	1	fn simple_formatter() {
82	1	let expected = "
83	1	dt_fmt: \"\" - fmt_string: \"{mod_path}->{fn_name} [{level:7}] {message}\"
84	1	->simple_formatter [INFO ] This is a test message
85	1	"
86	1	.to_string();
87
88	1	let mut buf = Vec::new();
89
90	1	let le = LogEntry::create(
91	1	INFO,
92	1	"simple_formatter".to_string(),
93	1	"This is a test message".to_string(),
94		);
95
96	1	let f = FormatType::Simple.create(None);
97	1	let fs = f.format(&le);
98		// println!("\n{f:width$} {fs}\n", width = f.width());
99	1	writeln!(&mut buf, "\n{f:width$}\n{fs}", width = f.width()).expect("writeln!() failed");
100
101	1	assert_eq!(expected, String::from_utf8(buf).unwrap());
102	1	}
103
104		#[test]
105	1	fn unix_timestamp() {
106	1	let re_str = "^
107	1	dt_fmt: \"%s\\.%f\" - fmt_string: \"\\{dt} \\{mod_path}->\\{fn_name} \\[\\{level:7}] \\{message}\"
108	1	(?:\\d{10}\\.\\d{9}) ->unix_timestamp \\[INFO ] This is a test message
109	1	$";
110
111	1	let re = Regex::new(re_str).unwrap();
112	1	let mut buf = Vec::new();
113
114	1	let le = LogEntry::create(
115	1	INFO,
116	1	"unix_timestamp".to_string(),
117	1	"This is a test message".to_string(),
118		);
119
120	1	let f = FormatType::UnixTimestamp.create(None);
121	1	let fs = f.format(&le);
122		// println!("\n{f:width$}\n{fs}", width = f.width());
123	1	writeln!(&mut buf, "\n{f:width$}\n{fs}", width = f.width()).expect("writeln!() failed");
124	1	let result = String::from_utf8(buf).unwrap();
125		// println!("{result}",);
126
127	1	assert!(re.is_match(&result));
128	1	}
129
130		#[test]
131	1	fn custom() {
132	1	let expected = "\nMockFormatter
133	1	MockFormatter
134	1	"
135	1	.to_string();
136
137	1	let mut buf = Vec::new();
138
139	1	let le = LogEntry::create(
140	1	INFO,
141	1	"custom".to_string(),
142	1	"Testing MockFormatter".to_string(),
143		);
144	1	let f = FormatType::Custom.create(Some(Box::new(MockFormatter::new())));
145	1	let fs = f.format(&le);
146		// println!("\n{f:width$}\n{fs}", width = f.width());
147	1	writeln!(&mut buf, "\n{f:width$}\n{fs}", width = f.width()).expect("writeln!() failed");
148
149	1	assert_eq!(expected, String::from_utf8(buf).unwrap());
150	1	}
151		}