config/src/lib.rs

@@ -16,55 +16,66 @@ use getset::Setters;
 * Represents a valid `WANessa` configuration. Intended as a read-only singleton.
 * See [`DEFAULTS`]
 */
-#[derive(Clone,PartialEq, Eq)]
+#[derive(Clone, PartialEq, Eq, Getters, Setters)]
-#[derive(Getters, Setters)]
+#[getset(get = "pub", set = "pub")]
-#[getset(get = "pub")]
 #[allow(clippy::struct_excessive_bools)] // False positive, since it is a config struct.
 pub struct Config {
 	/// See [`LogVerbosity`].<br>
 	/// Default: [`Warning`]
-	pub log_verbosity: LogVerbosity,
+	log_verbosity: LogVerbosity,
 	/// Logs UTC time and date of message, if true.<br>
 	/// Default: `false`
-	pub log_time: bool,
+	log_time: bool,
 	/// Time and date format.<br>
 	/// Defaults to `%F/%T:%f`.<br>
 	/// See [chrono](https://docs.rs/chrono/latest/chrono/format/strftime/index.html).<br>
 	/// Default example : `2001-12-31/23:59:33:26490000`
 	#[getset(skip)]
-    pub log_time_format: Option<String>,
+	log_time_format: Option<String>,
 	/// Logs location in code, where the message was logged, if true.<br>
 	/// Default: `false`
-	pub log_location: bool,
+	log_location: bool,
 	/// If `Some(path)` tries to also write the log to `path` in addition to stderr/stderr.<br>
 	/// Default: [None]
-    pub log_path: Option<PathBuf>,
+	log_path: Option<PathBuf>,
 	/// Logs to standard out, if true.<br>
 	/// Default: `true`
-    pub log_stdout: bool,
+	log_stdout: bool,
 	/// Logs to standard err, if true.<br>
 	/// Default: `true`
-    pub log_stderr: bool,
+	log_stderr: bool,
 	/// Database connection address.
 	/// Is an option to allow constructing a default config during compile time.<br>
 	/// Default: `localhost`.
 	#[getset(skip)]
-	pub db_addr: Option<String>,
+	db_addr: Option<String>,
 	/// Database connection port.<br>
 	/// Default: `6969` (nice).
-	pub db_port: u16,
+	db_port: u16,
 }
 
 impl Config {
 	/// Getter for [`Self::db_addr`].
+	#[must_use]
 	pub fn db_addr(&self) -> &str {
 		self.db_addr.as_ref().map_or("localhost", |addr| addr)
 	}
 
-    /// Getter for the [`Self::log_time_format`].
+	/// Setter for [`Self::db_addr`].
-    pub fn log_time_format(&self) -> &str
+	pub fn set_db_addr(&mut self, db_addr: impl Into<String>) {
-    {
+		self.db_addr = Some(db_addr.into());
-        self.log_time_format.as_ref().map_or("%F-%T:%f", |fmt| fmt)
+	}
+
+	/// Getter for [`Self::log_time_format`].
+	#[must_use]
+	pub fn log_time_format(&self) -> &str {
+		todo!();
+		// self.log_time_format.as_ref().map_or("%F-%T:%f", |fmt| fmt)
+	}
+
+	/// Setter for [`Self::log_time_format`].
+	pub fn set_log_time_format(&mut self, format: impl Into<String>) {
+		self.log_time_format = Some(format.into());
 	}
 }
 
@@ -76,24 +87,26 @@ impl Default for Config {
 	}
 }
 
-/// Default configuration.
+/**
-/// ```rust
+* Default configuration.
-/// # use config::Config;
+* ```rust
-/// # use config::LogVerbosity::Warning;
+* # use config::Config;
-/// let DEFAULTS = Config
+* # use config::LogVerbosity::Warning;
-/// {
+* let DEFAULTS = Config
-///	    log_verbosity: Warning,
+* {
-///	    log_time: false,
+*   log_verbosity: Warning,
-///     log_time_format: None,
+*   log_time: false,
-///	    log_location: false,
+*   log_time_format: None,
-///     log_stdout: true,
+*   log_location: false,
-///     log_stderr: true,
+*   log_stdout: true,
-///     log_path: None,
+*   log_stderr: true,
-///	    db_addr: None,
+*   log_path: None,
-///	    db_port: 6969,
+*   db_addr: None,
-/// };
+*   db_port: 6969,
-/// # assert!(DEFAULTS == config::DEFAULTS)
+* };
-/// ```
+* # assert!(DEFAULTS == config::DEFAULTS)
+* ```
+*/
 pub const DEFAULTS: Config = Config {
 	log_verbosity: Warning,
 	log_time: false,
@@ -113,8 +126,7 @@ pub static CONFIG: RwLock<Config> = RwLock::new(DEFAULTS);
 * Each level includes the previous ones.
 */
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
-pub enum LogVerbosity
+pub enum LogVerbosity {
-{
 	/// Critical Errors, may lead to crashes or deactivating certain features.
 	Error,
 	/// Very minor and recovered errors, such as invalid configs.
@@ -127,22 +139,18 @@ pub enum LogVerbosity
 	Debugging,
 }
 
-impl PartialOrd for LogVerbosity
+impl PartialOrd for LogVerbosity {
-{
 	/// Some operator overloading of comparison symbols (==, <,>=, etc.) as syntactic sugar.
 	/// See [`PartialOrd`].
-    fn partial_cmp(&self, other: &Self) -> Option<Ordering>
+	fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-    {
+		Some(self.cmp(other))
-        (*self as usize).partial_cmp(&(*other as usize))
 	}
 }
 
-impl Ord for LogVerbosity
+impl Ord for LogVerbosity {
-{
 	/// Some operator overloading of comparison symbols (==, <,>=, etc.) as syntactic sugar.
 	/// See [`Ord`].
-    fn cmp(&self, other: &Self) -> Ordering
+	fn cmp(&self, other: &Self) -> Ordering {
-    {
 		(*self as usize).cmp(&(*other as usize))
 	}
 }

logging/src/lib.rs

@@ -11,13 +11,13 @@ use config::LogVerbosity;
 
 use chrono::Utc;
 
-use LogVerbosity::Warning;
 use LogVerbosity::Information;
+use LogVerbosity::Warning;
 
-use LogMessageType::GenericErr;
-use LogMessageType::GenericWarn;
-use LogMessageType::GenericInfo;
 use LogMessageType::GenericDebug;
+use LogMessageType::GenericErr;
+use LogMessageType::GenericInfo;
+use LogMessageType::GenericWarn;
 
 /**
 * Logs the given message.
@@ -27,23 +27,24 @@ use LogMessageType::GenericDebug;
 * or if another error occurs, such as a full disk.
 */
 // TODO: Create macro to make last three parameters optional.
-pub fn log_message(msg: &LogMessage, file: &str, line: &str, column: &str)
+pub fn log_message(msg: &LogMessage, file: &str, line: &str, column: &str) {
-{
+	let conf = config::CONFIG.read().unwrap_or_else(|_| {
-    let conf = config::CONFIG.read().expect(&format!("Failed aqcuire read lock on config\nTried to log message: {msg}"));
+		panic!("Failed aqcuire read lock on config\nTried to log message: {msg}")
+	});
 
-    if conf.log_verbosity() < &msg.1 { return; }
+	if conf.log_verbosity() < &msg.1 {
+		return;
+	}
 
 	let mut log_line = String::new();
 
 	// add time substring
-    if *conf.log_time()
+	if *conf.log_time() {
-    {
 		log_line += &format!("{} ", Utc::now().format(conf.log_time_format()));
 	}
 
 	// add code location substring
-    if *conf.log_location()
+	if *conf.log_location() {
-    {
 		log_line += &format!("{file}:{line},{column} ");
 	}
 
@@ -51,26 +52,27 @@ pub fn log_message(msg: &LogMessage, file: &str, line: &str, column: &str)
 
 	// May panic if file cannot be opened or written to.
 	conf.log_path().as_ref().map_or_else(
-        || {}, |path|
+		|| {},
-        {
+		|path| {
 			let mut file = OpenOptions::new()
 				.write(true)
 				.append(true)
 				.open(path)
-                .expect(
+				.unwrap_or_else(|_| {
-                    &format!("Could not open log file: {path:#?}")
+					panic!(
-                );
+						"Could not open log fil
-            writeln!(file, "{log_line}").expect(&format!("Could not write log to file: {path:#?}"));
+ e: {path:#?}"
-        }
+					)
+				});
+			writeln!(file, "{log_line}")
+				.unwrap_or_else(|_| panic!("Could not write log to file: {path:#?}"));
+		},
 	);
 
-    if msg.1 <= Warning && *conf.log_stderr()
+	if msg.1 <= Warning && *conf.log_stderr() {
-    {
 		// May panic if writing to stderr fails.
 		eprintln!("{log_line}");
-    }
+	} else if msg.1 >= Information && *conf.log_stdout() {
-    else if msg.1 >= Information && *conf.log_stdout()
-    {
 		// May panic if writing to stdout fails.
 		println!("{log_line}");
 	}
@@ -83,10 +85,8 @@ pub fn log_message(msg: &LogMessage, file: &str, line: &str, column: &str)
 */
 pub struct LogMessage(LogMessageType, LogVerbosity);
 
-impl Display for LogMessage
+impl Display for LogMessage {
-{
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error>
-    {
 		self.0.fmt(f) // just display LogMessageType
 	}
 }
@@ -118,13 +118,11 @@ pub enum LogMessageType {
 * respectively and (hopefully) detailed messages.
 */
 
-impl LogMessageType
+impl LogMessageType {
-{
 	/// Returns a new [`LogMessage`] based on the default verbosity of the given [`LogMessageType`].
-    pub fn log_message(&self) -> LogMessage
+	#[must_use]
-    {
+	pub fn log_message(&self) -> LogMessage {
-        let verbosity = match self
+		let verbosity = match self {
-        {
 			GenericErr(_) => LogVerbosity::Error,
 			GenericWarn(_) => LogVerbosity::Warning,
 			GenericInfo(_) => LogVerbosity::Information,
@@ -136,14 +134,20 @@ impl LogMessageType
 }
 
 impl Display for LogMessageType {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error>
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
-    {
+		match self {
-        match self
+			GenericErr(err) => {
-        {
+				write!(f, "Generic Error: {err}")
-            GenericErr(err) => { write!(f, "Generic Error: {err}") },
+			}
-            GenericWarn(warn) => { write!(f, "Generic Warning: {warn}") },
+			GenericWarn(warn) => {
-            GenericInfo(info) => { write!(f, "Generic Information: {info}") },
+				write!(f, "Generic Warning: {warn}")
-            GenericDebug(debug) => { write!(f, "Generic Debug Message: {debug}") },
+			}
+			GenericInfo(info) => {
+				write!(f, "Generic Information: {info}")
+			}
+			GenericDebug(debug) => {
+				write!(f, "Generic Debug Message: {debug}")
+			}
 		}
 	}
 }