src/handlers/console_handler/console

src/handlers/console_handler/console_type.rs

Lines

100.00 %

Functions

100.00 %

Regions

100.00 %


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

//!
//! # ConsoleType
//!

use std::{fmt, str::FromStr};
use strum::{EnumIter, IntoEnumIterator};

///
/// `ConsoleType` configures the `ConsoleHandler`'s output.
///
#[derive(Debug, Default, EnumIter, PartialEq, Eq)]
pub enum ConsoleType {
    #[default]
    ///
    /// Prints to `stdout`.
    ///
    StdOut,
    ///
    /// Print to `stderr`.
    ///
    StdErr,
    ///
    /// If `log_entry.level` is `LeveL::INFO`, then
    /// prints unformatted `log_entry.msg` to `stdout`, else
    /// prints formatted `log_entry.msg` to `stderr`.
    ///
    Production,
}

impl ConsoleType {
    ///
    /// Converts a console type to its string version.
    ///
    pub const fn as_str(&self) -> &'static str {
        match self {
            ConsoleType::StdOut => "stdout",
            ConsoleType::StdErr => "stderr",
            ConsoleType::Production => "production",
        }
    }
}

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

///
/// Returned from `FromStr::from_str()` when an unknown string
/// is passed-in.
///
#[derive(Debug)]
pub struct ConsoleTypeError {
    #[allow(dead_code)]
    msg: String,
}

impl FromStr for ConsoleType {
    type Err = ConsoleTypeError;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match s {
            "stdout" => Ok(ConsoleType::StdOut),
            "stderr" => Ok(ConsoleType::StdErr),
            "production" => Ok(ConsoleType::Production),
            _ => Err(ConsoleTypeError {
                msg: format!("Unknown console type: {s}"),
            }),
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::io::{Result, Write};

    #[test]
    fn as_str_to_from_str() {
        for console_type in ConsoleType::iter() {
            let label = console_type.as_str();
            let console_type2 = ConsoleType::from_str(label).unwrap();
            assert_eq!(console_type, console_type2);
        }
    }

    #[test]
    fn from_str_fail() {
        let bad_label = "file";
        assert!(ConsoleType::from_str(bad_label).is_err());
    }

    #[test]
    fn console_display() {
        let expected = "stdout\nstderr\nproduction\n".to_string();
        let mut buf = Vec::new();

        for console_type in ConsoleType::iter() {
            writeln!(&mut buf, "{console_type}").expect("writeln!() failed");
        }

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

Line	Count	Source (jump to first uncovered line)
1		//
2		// File Name: console_type.rs
3		// Directory: src/handlers/console_handler
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		//! # ConsoleType
26		//!
27
28		use std::{fmt, str::FromStr};
29		use strum::{EnumIter, IntoEnumIterator};
30
31		///
32		/// `ConsoleType` configures the `ConsoleHandler`'s output.
33		///
34		#[derive(Debug, Default, EnumIter, PartialEq, Eq)]
35		pub enum ConsoleType {
36		#[default]
37		///
38		/// Prints to `stdout`.
39		///
40		StdOut,
41		///
42		/// Print to `stderr`.
43		///
44		StdErr,
45		///
46		/// If `log_entry.level` is `LeveL::INFO`, then
47		/// prints unformatted `log_entry.msg` to `stdout`, else
48		/// prints formatted `log_entry.msg` to `stderr`.
49		///
50		Production,
51		}
52
53		impl ConsoleType {
54		///
55		/// Converts a console type to its string version.
56		///
57	37	pub const fn as_str(&self) -> &'static str {
58	37	match self {
59	23	ConsoleType::StdOut => "stdout",
60	8	ConsoleType::StdErr => "stderr",
61	6	ConsoleType::Production => "production",
62		}
63	37	}
64		}
65
66		impl fmt::Display for ConsoleType {
67	3	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
68	3	self.as_str().fmt(f)
69	3	}
70		}
71
72		///
73		/// Returned from `FromStr::from_str()` when an unknown string
74		/// is passed-in.
75		///
76		#[derive(Debug)]
77		pub struct ConsoleTypeError {
78		#[allow(dead_code)]
79		msg: String,
80		}
81
82		impl FromStr for ConsoleType {
83		type Err = ConsoleTypeError;
84
85	35	fn from_str(s: &str) -> Result<Self, Self::Err> {
86	35	match s {
87	22	"stdout" => Ok(ConsoleType::StdOut),
88	7	"stderr" => Ok(ConsoleType::StdErr),
89	5	"production" => Ok(ConsoleType::Production),
90	1	_ => Err(ConsoleTypeError {
91	1	msg: format!("Unknown console type: {s}"),
92	1	}),
93		}
94	35	}
95		}
96
97		#[cfg(test)]
98		mod tests {
99		use super::*;
100		use std::io::{Result, Write};
101
102		#[test]
103	1	fn as_str_to_from_str() {
104	1	for console_type in ConsoleType::iter() {
105	3	let label = console_type.as_str();
106	3	let console_type2 = ConsoleType::from_str(label).unwrap();
107	3	assert_eq!(console_type, console_type2);
108		}
109	1	}
110
111		#[test]
112	1	fn from_str_fail() {
113	1	let bad_label = "file";
114	1	assert!(ConsoleType::from_str(bad_label).is_err());
115	1	}
116
117		#[test]
118	1	fn console_display() {
119	1	let expected = "stdout\nstderr\nproduction\n".to_string();
120	1	let mut buf = Vec::new();
121
122	3	for console_type in ConsoleType::iter() {
123	3	writeln!(&mut buf, "{console_type}").expect("writeln!() failed");
124	3	}
125
126	1	assert_eq!(expected, String::from_utf8(buf).unwrap());
127	1	}
128		}