src/handlers/string

src/handlers/string_handler.rs

Lines

100.00 %

Functions

100.00 %

Regions

100.00 %


//
// File Name:    string_handler.rs
// 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/>.
//

//!
//! # StringHandler
//!
use crate::*;
use std::{fmt, io::Error};

///
/// Publishes log entries to an internal list.
///
/// The list can then be accessed via: [get_log()][StringHandler::get_log()].
///
#[derive(Debug, Default)]
pub struct StringHandler {
    formatter: Formatter,
    log: Vec<String>,
}

impl StringHandler {
    fn new() -> Self {
        StringHandler {
            formatter: FormatType::Simple.create(None),
            log: Vec::new(),
        }
    }

    fn log(&self) -> String {
        let mut buf = String::new();

        for s in &self.log {
            buf.push_str(s);
            buf.push('\n');
        }

        buf
    }
}

impl fmt::Display for StringHandler {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let len = self.formatter.to_string().len();
        let line = "-".repeat(len + 3);

        write!(f, "{}\n{line}\n{}", self.formatter, self.log())
    }
}

impl HandlerTrait for StringHandler {
    fn create(_name: &str) -> Result<Self, Error>
    where
        Self: Sized,
    {
        Ok(StringHandler::new())
    }

    fn close(&mut self) {}

    fn flush(&mut self) {
        self.log.clear();
    }

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

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

    fn is_open(&self) -> bool {
        true
    }

    #[allow(private_interfaces)]
    fn publish(&mut self, log_entry: &LogEntry) {
        self.log.push(self.formatter.format(log_entry));
    }

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

    ///
    /// This is a 'NoOp' fn. Use `get_log()`, as this already
    /// has the required functionality.
    ///
    fn set_test_mode(&mut self, _state: bool) {}
}

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

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

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

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

        let handler = log.get_handler(crate::Handler::String).unwrap();
        handler.set_test_mode(true);
        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!(expected, handler.get_log());
        handler.flush();

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

Line	Count	Source (jump to first uncovered line)
1		//
2		// File Name: string_handler.rs
3		// Project Name: flogging
4		//
5		// Copyright (C) 2025 Bradley Willcott
6		//
7		// SPDX-License-Identifier: GPL-3.0-or-later
8		//
9		// This library (crate) is free software: you can redistribute it and/or modify
10		// it under the terms of the GNU General Public License as published by
11		// the Free Software Foundation, either version 3 of the License, or
12		// (at your option) any later version.
13		//
14		// This library (crate) is distributed in the hope that it will be useful,
15		// but WITHOUT ANY WARRANTY; without even the implied warranty of
16		// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17		// GNU General Public License for more details.
18		//
19		// You should have received a copy of the GNU General Public License
20		// along with this library (crate). If not, see <https://www.gnu.org/licenses/>.
21		//
22
23		//!
24		//! # StringHandler
25		//!
26		use crate::*;
27		use std::{fmt, io::Error};
28
29		///
30		/// Publishes log entries to an internal list.
31		///
32		/// The list can then be accessed via: [get_log()][StringHandler::get_log()].
33		///
34		#[derive(Debug, Default)]
35		pub struct StringHandler {
36		formatter: Formatter,
37		log: Vec<String>,
38		}
39
40		impl StringHandler {
41	12	fn new() -> Self {
42	12	StringHandler {
43	12	formatter: FormatType::Simple.create(None),
44	12	log: Vec::new(),
45	12	}
46	12	}
47
48	4	fn log(&self) -> String {
49	4	let mut buf = String::new();
50
51	10	for s in &self.log {
52	10	buf.push_str(s);
53	10	buf.push('\n');
54	10	}
55
56	4	buf
57	4	}
58		}
59
60		impl fmt::Display for StringHandler {
61	1	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
62	1	let len = self.formatter.to_string().len();
63	1	let line = "-".repeat(len + 3);
64
65	1	write!(f, "{}\n{line}\n{}", self.formatter, self.log())
66	1	}
67		}
68
69		impl HandlerTrait for StringHandler {
70	12	fn create(_name: &str) -> Result<Self, Error>
71	12	where
72	12	Self: Sized,
73		{
74	12	Ok(StringHandler::new())
75	12	}
76
77	1	fn close(&mut self) {}
78
79	1	fn flush(&mut self) {
80	1	self.log.clear();
81	1	}
82
83	1	fn get_formatter(&self) -> Formatter {
84	1	self.formatter.clone()
85	1	}
86
87	3	fn get_log(&self) -> String {
88	3	self.log()
89	3	}
90
91	1	fn is_open(&self) -> bool {
92	1	true
93	1	}
94
95		#[allow(private_interfaces)]
96	30	fn publish(&mut self, log_entry: &LogEntry) {
97	30	self.log.push(self.formatter.format(log_entry));
98	30	}
99
100	1	fn set_formatter(&mut self, formatter: Formatter) {
101	1	self.formatter = formatter;
102	1	}
103
104		///
105		/// This is a 'NoOp' fn. Use `get_log()`, as this already
106		/// has the required functionality.
107		///
108	1	fn set_test_mode(&mut self, _state: bool) {}
109		}
110
111		#[cfg(test)]
112		mod tests {
113		use crate::*;
114
115		#[test]
116	1	fn string_handler() {
117	1	let expected = "flogging::handlers::string_handler::tests-> [INFO ] trait methods
118	1	flogging::handlers::string_handler::tests-> [WARNING] The sky is falling!\n"
119	1	.to_string();
120
121	1	let mut log = Logger::string_logger(module_path!());
122
123	1	log.info("trait methods");
124	1	log.warning("The sky is falling!");
125
126	1	let handler = log.get_handler(crate::Handler::String).unwrap();
127	1	handler.set_test_mode(true);
128	1	assert!(handler.is_open());
129	1	assert_eq!(
130	1	handler.get_formatter().to_string(),
131	1	"dt_fmt: \"\" - fmt_string: \"{mod_path}->{fn_name} [{level:7}] {message}\""
132	1	.to_string()
133		);
134	1	assert_eq!(expected, handler.get_log());
135	1	handler.flush();
136
137	1	assert_eq!(handler.get_log(), "".to_string());
138	1	handler.close();
139	1	}
140		}