src/handlers/console

src/handlers/console_handler.rs

Lines

100.00 %

Functions

100.00 %

Regions

99.43 %


//
// File Name:    console_handler.rs
// Directory:    src/handlers
// 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/>.
//

//!
//! # ConsoleHandler
//!
//! Publishes log entries to the console: `[std::io::stderr]`.
//!

pub mod console_type;

use crate::*;
use console_type::ConsoleType;
use std::{
    fmt,
    io::{self, Error, Write},
};

///
/// Publishes log entries to the console.
///
/// If `console_type` is:
///
/// - `ConsoleType::StdOut` - print to `stdout`,
/// - `ConsoleType::StdErr` - print to `stderr`,
/// - `ConsoleType::Production`:\
///   If `log_entry.level` is `LeveL::INFO`, then\
///   prints unformatted `log_entry.msg` to `stdout`, else\
///   prints formatted `log_entry.msg` to `stderr`.
///
#[derive(Debug, Default)]
pub struct ConsoleHandler {
    console_type: ConsoleType,
    formatter: Formatter,
    writer: Option<Vec<u8>>,
}

impl ConsoleHandler {
    fn _create(console_type: ConsoleType) -> Self {
        ConsoleHandler {
            console_type,
            formatter: FormatType::Simple.create(None),
            writer: None,
        }
    }

    fn log(&self) -> String {
        if let Some(w) = self.writer.to_owned() {
            String::from_utf8(w).unwrap()
        } else {
            String::new()
        }
    }
}

impl fmt::Display for ConsoleHandler {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        self.formatter.fmt(f)
    }
}

impl HandlerTrait for ConsoleHandler {
    fn create(console_type: &str) -> Result<Self, Error>
    where
        Self: Sized,
    {
        Ok(ConsoleHandler::_create(console_type.parse().unwrap()))
    }

    ///
    /// Removes the internal buffer, if in `test_mode`.\
    /// Will therefore, no longer be *in* `test_mode`.
    ///
    fn close(&mut self) {
        if self.writer.is_some() {
            self.writer = None;
        }
    }

    ///
    /// Clears the internal buffer, if in `test_mode`.
    ///
    fn flush(&mut self) {
        if let Some(w) = self.writer.as_mut() {
            w.clear()
        };
    }

    fn get_formatter(&self) -> Formatter {
        self.formatter.clone()
    }

    fn get_log(&self) -> String {
        self.log()
    }

    ///
    /// `ConsoleHandler` is *always* open.
    ///
    fn is_open(&self) -> bool {
        true
    }

    fn publish(&mut self, log_entry: &LogEntry) {
        match self.writer.as_mut() {
            Some(w) => {
                let _ = match self.console_type {
                    ConsoleType::StdOut => writeln!(w, "{}", self.formatter.format(log_entry)),
                    ConsoleType::StdErr => writeln!(w, "{}", self.formatter.format(log_entry)),
                    ConsoleType::Production => production_test(w, &self.formatter, log_entry),
                };
            }
            None => match self.console_type {
                ConsoleType::StdOut => println!("{}", self.formatter.format(log_entry)),
                ConsoleType::StdErr => eprintln!("{}", self.formatter.format(log_entry)),
                ConsoleType::Production => production(&self.formatter, log_entry),
            },
        }
    }

    fn set_formatter(&mut self, formatter: Formatter) {
        self.formatter = formatter;
    }

    ///
    /// Sets the test mode to `state`.
    ///
    /// If set to `true`, use `get_log()` to obtain the
    /// log.
    ///
    fn set_test_mode(&mut self, state: bool) {
        if state {
            // true
            self.writer = Some(Vec::new());
        } else {
            self.writer = None;
        }
    }
}

fn production(formatter: &Formatter, log_entry: &LogEntry) {
    if log_entry.level() == Level::INFO {
        println!("{}", log_entry.message());
    } else {
        eprintln!("{}", formatter.format(log_entry));
    }
}

fn production_test(
    writer: &mut Vec<u8>,
    formatter: &Formatter,
    log_entry: &LogEntry,
) -> io::Result<()> {
    if log_entry.level() == Level::INFO {
        writeln!(writer, "{}", log_entry.message())?;
    } else {
        writeln!(writer, "{}", formatter.format(log_entry))?;
    }

    Ok(())
}

#[cfg(test)]
mod tests {
    use crate::*;

    #[test]
    fn stdout_handler() {
        let mut log = Logger::console_logger(module_path!());

        log.info("trait methods");
        log.warning("The sky is falling!");

        let handler = log.get_handler(crate::Handler::Console).unwrap();
        handler.set_test_mode(false);

        assert!(handler.is_open());
        assert_eq!(
            handler.get_formatter().to_string(),
            "dt_fmt: \"\" - fmt_string: \"{mod_path}->{fn_name} [{level:7}] {message}\""
                .to_string()
        );

        assert_eq!(handler.get_log(), "".to_string());

        handler.flush();
        handler.close();
    }

    #[test]
    fn stdout_handler_test_mode() {
        let expected = "flogging::handlers::console_handler::tests-> [INFO   ] trait methods
flogging::handlers::console_handler::tests-> [WARNING] The sky is falling!
"
            .to_string();

        let mut log = Logger::console_logger(module_path!());

        let h = log.get_handler(crate::Handler::Console).unwrap();
        h.set_test_mode(true);

        assert!(h.is_open());
        assert_eq!(
            h.get_formatter().to_string(),
            "dt_fmt: \"\" - fmt_string: \"{mod_path}->{fn_name} [{level:7}] {message}\""
                .to_string()
        );

        log.info("trait methods");
        log.warning("The sky is falling!");

        let h = log.get_handler(crate::Handler::Console).unwrap();
        let buf = h.get_log();

        assert_eq!(expected, buf);

        h.flush();
        h.close();
    }

    #[test]
    fn stderr_handler() {
        let mut log = Logger::econsole_logger(module_path!());

        log.info("trait methods");
        log.warning("The sky is falling!");

        let handler = log.get_handler(crate::Handler::EConsole).unwrap();
        handler.set_test_mode(false);

        assert!(handler.is_open());
        assert_eq!(
            handler.get_formatter().to_string(),
            "dt_fmt: \"\" - fmt_string: \"{mod_path}->{fn_name} [{level:7}] {message}\""
                .to_string()
        );

        assert_eq!(handler.get_log(), "".to_string());

        handler.flush();
        handler.close();
    }

    #[test]
    fn stderr_handler_test_mode() {
        let expected = "flogging::handlers::console_handler::tests-> [INFO   ] trait methods
flogging::handlers::console_handler::tests-> [WARNING] The sky is falling!\n"
            .to_string();

        let mut log = Logger::econsole_logger(module_path!());

        let h = log.get_handler(crate::Handler::EConsole).unwrap();
        h.set_test_mode(true);

        assert!(h.is_open());
        assert_eq!(
            h.get_formatter().to_string(),
            "dt_fmt: \"\" - fmt_string: \"{mod_path}->{fn_name} [{level:7}] {message}\""
                .to_string()
        );

        log.info("trait methods");
        log.warning("The sky is falling!");

        let h = log.get_handler(crate::Handler::EConsole).unwrap();
        let buf = h.get_log();

        assert_eq!(expected, buf);

        h.flush();
        h.close();
    }

    #[test]
    fn production_handler() {
        let mut log = Logger::pconsole_logger(module_path!());

        log.info("trait methods");
        log.warning("The sky is falling!");

        let handler = log.get_handler(crate::Handler::PConsole).unwrap();
        handler.set_test_mode(false);

        assert!(handler.is_open());
        assert_eq!(
            handler.get_formatter().to_string(),
            "dt_fmt: \"\" - fmt_string: \"{mod_path}->{fn_name} [{level:7}] {message}\""
                .to_string()
        );

        assert_eq!(handler.get_log(), "".to_string());

        handler.flush();
        handler.close();
    }

    #[test]
    fn production_handler_test_mode() {
        let expected = "trait methods
flogging::handlers::console_handler::tests-> [WARNING] The sky is falling!\n"
            .to_string();

        let mut log = Logger::pconsole_logger(module_path!());

        let h = log.get_handler(crate::Handler::PConsole).unwrap();
        h.set_test_mode(true);

        assert!(h.is_open());
        assert_eq!(
            h.get_formatter().to_string(),
            "dt_fmt: \"\" - fmt_string: \"{mod_path}->{fn_name} [{level:7}] {message}\""
                .to_string()
        );

        log.info("trait methods");
        log.warning("The sky is falling!");

        let h = log.get_handler(crate::Handler::PConsole).unwrap();
        let buf = h.get_log();

        assert_eq!(expected, buf);

        h.flush();
        h.close();
    }
}

Line	Count	Source (jump to first uncovered line)
1		//
2		// File Name: console_handler.rs
3		// Directory: src/handlers
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		//! # ConsoleHandler
26		//!
27		//! Publishes log entries to the console: `[std::io::stderr]`.
28		//!
29
30		pub mod console_type;
31
32		use crate::*;
33		use console_type::ConsoleType;
34		use std::{
35		fmt,
36		io::{self, Error, Write},
37		};
38
39		///
40		/// Publishes log entries to the console.
41		///
42		/// If `console_type` is:
43		///
44		/// - `ConsoleType::StdOut` - print to `stdout`,
45		/// - `ConsoleType::StdErr` - print to `stderr`,
46		/// - `ConsoleType::Production`:\
47		/// If `log_entry.level` is `LeveL::INFO`, then\
48		/// prints unformatted `log_entry.msg` to `stdout`, else\
49		/// prints formatted `log_entry.msg` to `stderr`.
50		///
51		#[derive(Debug, Default)]
52		pub struct ConsoleHandler {
53		console_type: ConsoleType,
54		formatter: Formatter,
55		writer: Option<Vec<u8>>,
56		}
57
58		impl ConsoleHandler {
59	31	fn _create(console_type: ConsoleType) -> Self {
60	31	ConsoleHandler {
61	31	console_type,
62	31	formatter: FormatType::Simple.create(None),
63	31	writer: None,
64	31	}
65	31	}
66
67	8	fn log(&self) -> String {
68	8	if let Some(w) = self.writer.to_owned() {
69	5	String::from_utf8(w).unwrap()
70		} else {
71	3	String::new()
72		}
73	8	}
74		}
75
76		impl fmt::Display for ConsoleHandler {
77	1	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
78	1	self.formatter.fmt(f)
79	1	}
80		}
81
82		impl HandlerTrait for ConsoleHandler {
83	31	fn create(console_type: &str) -> Result<Self, Error>
84	31	where
85	31	Self: Sized,
86		{
87	31	Ok(ConsoleHandler::_create(console_type.parse().unwrap()))
88	31	}
89
90		///
91		/// Removes the internal buffer, if in `test_mode`.\
92		/// Will therefore, no longer be in `test_mode`.
93		///
94	6	fn close(&mut self) {
95	3	if self.writer.is_some() {
96	3	self.writer = None;
97	3	}
98	6	}
99
100		///
101		/// Clears the internal buffer, if in `test_mode`.
102		///
103	6	fn flush(&mut self) {
104	6	if let Some(w) = self.writer.as_mut() {
105	3	w.clear()
106	3	};
107	6	}
108
109	6	fn get_formatter(&self) -> Formatter {
110	6	self.formatter.clone()
111	6	}
112
113	8	fn get_log(&self) -> String {
114	8	self.log()
115	8	}
116
117		///
118		/// `ConsoleHandler` is always open.
119		///
120	6	fn is_open(&self) -> bool {
121	6	true
122	6	}
123
124	75	fn publish(&mut self, log_entry: &LogEntry) {
125	75	match self.writer.as_mut() {
126	10	Some(w) => {
127	10	let _ = match self.console_type {
128	6	ConsoleType::StdOut => writeln!(w, "{}", self.formatter.format(log_entry)),
129	2	ConsoleType::StdErr => writeln!(w, "{}", self.formatter.format(log_entry)),
130	2	ConsoleType::Production => production_test(w, &self.formatter, log_entry),
131		};
132		}
133	65	None => match self.console_type {
134	50	ConsoleType::StdOut => println!("{}", self.formatter.format(log_entry)),
135	9	ConsoleType::StdErr => eprintln!("{}", self.formatter.format(log_entry)),
136	6	ConsoleType::Production => production(&self.formatter, log_entry),
137		},
138		}
139	75	}
140
141	7	fn set_formatter(&mut self, formatter: Formatter) {
142	7	self.formatter = formatter;
143	7	}
144
145		///
146		/// Sets the test mode to `state`.
147		///
148		/// If set to `true`, use `get_log()` to obtain the
149		/// log.
150		///
151	8	fn set_test_mode(&mut self, state: bool) {
152	5	if state {
153	5	// true
154	5	self.writer = Some(Vec::new());
155	3	} else {
156	3	self.writer = None;
157	3	}
158	8	}
159		}
160
161	6	fn production(formatter: &Formatter, log_entry: &LogEntry) {
162	3	if log_entry.level() == Level::INFO {
163	3	println!("{}", log_entry.message());
164	3	} else {
165	3	eprintln!("{}", formatter.format(log_entry));
166	3	}
167	6	}
168
169	2	fn production_test(
170	2	writer: &mut Vec<u8>,
171	2	formatter: &Formatter,
172	2	log_entry: &LogEntry,
173	2	) -> io::Result<()> {
174	2	if log_entry.level() == Level::INFO {
175	1	writeln!(writer, "{}", log_entry.message())?;
176		} else {
177	1	writeln!(writer, "{}", formatter.format(log_entry))?;
178		}
179
180	2	Ok(())
181	2	}
182
183		#[cfg(test)]
184		mod tests {
185		use crate::*;
186
187		#[test]
188	1	fn stdout_handler() {
189	1	let mut log = Logger::console_logger(module_path!());
190
191	1	log.info("trait methods");
192	1	log.warning("The sky is falling!");
193
194	1	let handler = log.get_handler(crate::Handler::Console).unwrap();
195	1	handler.set_test_mode(false);
196
197	1	assert!(handler.is_open());
198	1	assert_eq!(
199	1	handler.get_formatter().to_string(),
200	1	"dt_fmt: \"\" - fmt_string: \"{mod_path}->{fn_name} [{level:7}] {message}\""
201	1	.to_string()
202		);
203
204	1	assert_eq!(handler.get_log(), "".to_string());
205
206	1	handler.flush();
207	1	handler.close();
208	1	}
209
210		#[test]
211	1	fn stdout_handler_test_mode() {
212	1	let expected = "flogging::handlers::console_handler::tests-> [INFO ] trait methods
213	1	flogging::handlers::console_handler::tests-> [WARNING] The sky is falling!
214	1	"
215	1	.to_string();
216
217	1	let mut log = Logger::console_logger(module_path!());
218
219	1	let h = log.get_handler(crate::Handler::Console).unwrap();
220	1	h.set_test_mode(true);
221
222	1	assert!(h.is_open());
223	1	assert_eq!(
224	1	h.get_formatter().to_string(),
225	1	"dt_fmt: \"\" - fmt_string: \"{mod_path}->{fn_name} [{level:7}] {message}\""
226	1	.to_string()
227		);
228
229	1	log.info("trait methods");
230	1	log.warning("The sky is falling!");
231
232	1	let h = log.get_handler(crate::Handler::Console).unwrap();
233	1	let buf = h.get_log();
234
235	1	assert_eq!(expected, buf);
236
237	1	h.flush();
238	1	h.close();
239	1	}
240
241		#[test]
242	1	fn stderr_handler() {
243	1	let mut log = Logger::econsole_logger(module_path!());
244
245	1	log.info("trait methods");
246	1	log.warning("The sky is falling!");
247
248	1	let handler = log.get_handler(crate::Handler::EConsole).unwrap();
249	1	handler.set_test_mode(false);
250
251	1	assert!(handler.is_open());
252	1	assert_eq!(
253	1	handler.get_formatter().to_string(),
254	1	"dt_fmt: \"\" - fmt_string: \"{mod_path}->{fn_name} [{level:7}] {message}\""
255	1	.to_string()
256		);
257
258	1	assert_eq!(handler.get_log(), "".to_string());
259
260	1	handler.flush();
261	1	handler.close();
262	1	}
263
264		#[test]
265	1	fn stderr_handler_test_mode() {
266	1	let expected = "flogging::handlers::console_handler::tests-> [INFO ] trait methods
267	1	flogging::handlers::console_handler::tests-> [WARNING] The sky is falling!\n"
268	1	.to_string();
269
270	1	let mut log = Logger::econsole_logger(module_path!());
271
272	1	let h = log.get_handler(crate::Handler::EConsole).unwrap();
273	1	h.set_test_mode(true);
274
275	1	assert!(h.is_open());
276	1	assert_eq!(
277	1	h.get_formatter().to_string(),
278	1	"dt_fmt: \"\" - fmt_string: \"{mod_path}->{fn_name} [{level:7}] {message}\""
279	1	.to_string()
280		);
281
282	1	log.info("trait methods");
283	1	log.warning("The sky is falling!");
284
285	1	let h = log.get_handler(crate::Handler::EConsole).unwrap();
286	1	let buf = h.get_log();
287
288	1	assert_eq!(expected, buf);
289
290	1	h.flush();
291	1	h.close();
292	1	}
293
294		#[test]
295	1	fn production_handler() {
296	1	let mut log = Logger::pconsole_logger(module_path!());
297
298	1	log.info("trait methods");
299	1	log.warning("The sky is falling!");
300
301	1	let handler = log.get_handler(crate::Handler::PConsole).unwrap();
302	1	handler.set_test_mode(false);
303
304	1	assert!(handler.is_open());
305	1	assert_eq!(
306	1	handler.get_formatter().to_string(),
307	1	"dt_fmt: \"\" - fmt_string: \"{mod_path}->{fn_name} [{level:7}] {message}\""
308	1	.to_string()
309		);
310
311	1	assert_eq!(handler.get_log(), "".to_string());
312
313	1	handler.flush();
314	1	handler.close();
315	1	}
316
317		#[test]
318	1	fn production_handler_test_mode() {
319	1	let expected = "trait methods
320	1	flogging::handlers::console_handler::tests-> [WARNING] The sky is falling!\n"
321	1	.to_string();
322
323	1	let mut log = Logger::pconsole_logger(module_path!());
324
325	1	let h = log.get_handler(crate::Handler::PConsole).unwrap();
326	1	h.set_test_mode(true);
327
328	1	assert!(h.is_open());
329	1	assert_eq!(
330	1	h.get_formatter().to_string(),
331	1	"dt_fmt: \"\" - fmt_string: \"{mod_path}->{fn_name} [{level:7}] {message}\""
332	1	.to_string()
333		);
334
335	1	log.info("trait methods");
336	1	log.warning("The sky is falling!");
337
338	1	let h = log.get_handler(crate::Handler::PConsole).unwrap();
339	1	let buf = h.get_log();
340
341	1	assert_eq!(expected, buf);
342
343	1	h.flush();
344	1	h.close();
345	1	}
346		}