Remove log and pretty-assertions dependencies (#1325)

Author: squell

Cargo.lock

@@ -32,10 +32,6 @@ path = "bin/visudo.rs"
 [dependencies]
 libc = "0.2.152"
 glob = "0.3.0"
-log = { version = "0.4.11", features = ["std"] }
-
-[dev-dependencies]
-pretty_assertions = "1.2.1"
 
 [features]
 default = ["sudoedit"]

Cargo.toml

@@ -1,8 +1,9 @@
 #![allow(unused_macros)]
 use self::simple_logger::SimpleLogger;
 use self::syslog::Syslog;
-pub use log::Level;
+use std::fmt;
 use std::ops::Deref;
+use std::sync::OnceLock;
 
 mod simple_logger;
 mod syslog;
@@ -11,47 +12,51 @@ mod syslog;
 macro_rules! logger_macro {
     ($name:ident is $rule_level:ident to $target:expr, $d:tt) => {
         macro_rules! $name {
-            ($d($d arg:tt)+) => (::log::log!(target: $target, $crate::log::Level::$rule_level, $d($d arg)+));
+            ($d($d arg:tt)+) => {
+                if let Some(logger) = $crate::log::LOGGER.get() {
+                    logger.log($crate::log::Level::$rule_level, $target, format_args!($d($d arg)+));
+                }
+            };
         }
 
-        #[allow(unused)]
         pub(crate) use $name;
     };
     ($name:ident is $rule_level:ident to $target:expr) => {
         logger_macro!($name is $rule_level to $target, $);
     };
 }
 
-logger_macro!(auth_error is Error to "sudo::auth");
+// logger_macro!(auth_error is Error to "sudo::auth");
 logger_macro!(auth_warn is Warn to "sudo::auth");
 logger_macro!(auth_info is Info to "sudo::auth");
-logger_macro!(auth_debug is Debug to "sudo::auth");
-logger_macro!(auth_trace is Trace to "sudo::auth");
+// logger_macro!(auth_debug is Debug to "sudo::auth");
+// logger_macro!(auth_trace is Trace to "sudo::auth");
 
 logger_macro!(user_error is Error to "sudo::user");
 logger_macro!(user_warn is Warn to "sudo::user");
 logger_macro!(user_info is Info to "sudo::user");
-logger_macro!(user_debug is Debug to "sudo::user");
-logger_macro!(user_trace is Trace to "sudo::user");
+// logger_macro!(user_debug is Debug to "sudo::user");
+// logger_macro!(user_trace is Trace to "sudo::user");
 
-// TODO: dev_logger_macro has an allow_unused that should be removed
 macro_rules! dev_logger_macro {
     ($name:ident is $rule_level:ident to $target:expr, $d:tt) => {
         macro_rules! $name {
             ($d($d arg:tt)+) => {
                 if std::cfg!(feature = "dev") {
-                    (::log::log!(
-                        target: $target,
-                        $crate::log::Level::$rule_level,
-                        "{}: {}",
-                        std::panic::Location::caller(),
-                        format_args!($d($d arg)+)
-                    ));
+                    if let Some(logger) = $crate::log::LOGGER.get() {
+                        logger.log(
+                            $crate::log::Level::$rule_level,
+                            $target,
+                            format_args!("{}: {}",
+                                std::panic::Location::caller(),
+                                format_args!($d($d arg)+)
+                            )
+                        );
+                    }
                 }
             };
         }
 
-        #[allow(unused)]
         pub(crate) use $name;
     };
     ($name:ident is $rule_level:ident to $target:expr) => {
@@ -63,10 +68,12 @@ dev_logger_macro!(dev_error is Error to "sudo::dev");
 dev_logger_macro!(dev_warn is Warn to "sudo::dev");
 dev_logger_macro!(dev_info is Info to "sudo::dev");
 dev_logger_macro!(dev_debug is Debug to "sudo::dev");
-dev_logger_macro!(dev_trace is Trace to "sudo::dev");
+//dev_logger_macro!(dev_trace is Trace to "sudo::dev");
+
+pub static LOGGER: OnceLock<SudoLogger> = OnceLock::new();
 
 #[derive(Default)]
-pub struct SudoLogger(Vec<(String, Box<dyn log::Log>)>);
+pub struct SudoLogger(Vec<(String, Box<dyn Log>)>);
 
 impl SudoLogger {
     pub fn new(prefix: &'static str) -> Self {
@@ -90,25 +97,16 @@ impl SudoLogger {
     }
 
     pub fn into_global_logger(self) {
-        log::set_boxed_logger(Box::new(self))
-            .map(|()| log::set_max_level(log::LevelFilter::Trace))
-            .expect("Could not set previously set logger");
+        if LOGGER.set(self).is_err() {
+            panic!("Could not set previously set logger");
+        }
     }
 
     /// Add a logger for a specific prefix to the stack
     fn add_logger(
         &mut self,
         prefix: impl ToString + Deref<Target = str>,
-        logger: impl log::Log + 'static,
-    ) {
-        self.add_boxed_logger(prefix, Box::new(logger))
-    }
-
-    /// Add a boxed logger for a specific prefix to the stack
-    fn add_boxed_logger(
-        &mut self,
-        prefix: impl ToString + Deref<Target = str>,
-        logger: Box<dyn log::Log>,
+        logger: impl Log + 'static,
     ) {
         let prefix = if prefix.ends_with("::") {
             prefix.to_string()
@@ -117,29 +115,32 @@ impl SudoLogger {
             // but not `my::prefix_to_somewhere`
             format!("{}::", prefix.to_string())
         };
-        self.0.push((prefix, logger))
+        self.0.push((prefix, Box::new(logger)))
     }
 }
 
-impl log::Log for SudoLogger {
-    fn enabled(&self, metadata: &log::Metadata) -> bool {
-        self.0.iter().any(|(_, l)| l.enabled(metadata))
-    }
-
-    fn log(&self, record: &log::Record) {
+impl SudoLogger {
+    pub fn log(&self, level: Level, target: &str, args: fmt::Arguments<'_>) {
         for (prefix, l) in self.0.iter() {
-            if record.target() == &prefix[..prefix.len() - 2] || record.target().starts_with(prefix)
-            {
-                l.log(record);
+            if target == &prefix[..prefix.len() - 2] || target.starts_with(prefix) {
+                l.log(level, &args);
             }
         }
     }
+}
 
-    fn flush(&self) {
-        for (_, l) in self.0.iter() {
-            l.flush();
-        }
-    }
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Debug)]
+#[allow(unused)]
+pub enum Level {
+    Error,
+    Warn,
+    Info,
+    Debug,
+    Trace,
+}
+
+trait Log: Send + Sync {
+    fn log(&self, level: Level, args: &fmt::Arguments<'_>);
 }
 
 #[cfg(test)]

src/log/mod.rs

@@ -1,9 +1,10 @@
+use std::fmt;
 use std::io::Write;
 
 #[cfg(feature = "dev")]
 use std::{fs::File, path::Path};
 
-use log::Log;
+use crate::log::{Level, Log};
 
 pub struct SimpleLogger<W: Send + Sync>
 where
@@ -17,16 +18,9 @@ impl<W: Send + Sync> Log for SimpleLogger<W>
 where
     for<'a> &'a W: Write,
 {
-    fn enabled(&self, metadata: &log::Metadata) -> bool {
-        metadata.level() <= log::max_level() && metadata.level() <= log::STATIC_MAX_LEVEL
-    }
-
-    fn log(&self, record: &log::Record) {
-        let s = format!("{}{}\n", self.prefix, record.args());
+    fn log(&self, _level: Level, args: &fmt::Arguments<'_>) {
+        let s = format!("{}{}\n", self.prefix, args);
         let _ = (&self.target).write_all(s.as_bytes());
-    }
-
-    fn flush(&self) {
         let _ = (&self.target).flush();
     }
 }
@@ -53,13 +47,13 @@ impl SimpleLogger<File> {
 
 #[cfg(test)]
 mod tests {
+
     use std::{
         io,
         sync::{Arc, RwLock},
     };
 
-    use super::SimpleLogger;
-    use log::{LevelFilter, Log};
+    use super::*;
 
     #[derive(Clone, Default)]
     struct MyString {
@@ -86,37 +80,15 @@ mod tests {
         }
     }
 
-    #[test]
-    fn test_default_level() {
-        let logger = SimpleLogger::to_stderr("test");
-        let metadata = log::Metadata::builder().level(log::Level::Trace).build();
-
-        log::set_max_level(LevelFilter::Trace);
-        assert!(logger.enabled(&metadata));
-
-        log::set_max_level(LevelFilter::Info);
-        assert!(!logger.enabled(&metadata));
-    }
-
     #[test]
     fn test_write_and_flush() {
         let target = MyString::default();
         let logger = SimpleLogger {
             target: target.clone(),
             prefix: "[test] ",
         };
-        let record = log::Record::builder()
-            .args(format_args!("Hello World!"))
-            .level(log::Level::Info)
-            .build();
-
-        logger.log(&record);
-
-        let value = target.read();
-        assert_eq!(value, "[test] Hello World!\n");
-        drop(value);
 
-        logger.flush();
+        logger.log(Level::Info, &format_args!("Hello World!"));
 
         let value = target.read();
         assert_eq!(value, "[test] Hello World!\nflushed");