Add formatter builder

Author: piegamesde

src/builders.rs

@@ -15,6 +15,9 @@ use log::Log;
 
 use crate::{log_impl, Filter, FormatCallback, Formatter};
 
+#[cfg(feature = "colored")]
+use crate::colors::ColoredLevelConfig;
+
 #[cfg(feature = "date-based")]
 use crate::log_impl::DateBasedState;
 
@@ -1230,3 +1233,129 @@ impl From<DateBased> for Output {
         })))
     }
 }
+
+/// A generic formatter that easily provides good defaults while being configurable
+pub struct FormatterBuilder {
+    #[cfg(feature = "colored")]
+    color_config: Option<ColoredLevelConfig>,
+    #[cfg(feature = "chrono")]
+    chrono: bool,
+    level: bool,
+    target: bool,
+}
+
+impl Default for FormatterBuilder {
+    fn default() -> Self {
+        FormatterBuilder {
+            #[cfg(feature = "colored")]
+            color_config: Some(Default::default()),
+            #[cfg(feature = "chrono")]
+            chrono: true,
+            level: true,
+            target: true,
+        }
+    }
+}
+
+impl FormatterBuilder {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    pub fn level(mut self, level: bool) -> Self {
+        self.level = level;
+        self
+    }
+
+    pub fn target(mut self, target: bool) -> Self {
+        self.target = target;
+        self
+    }
+
+    #[cfg(feature = "colored")]
+    pub fn color(mut self, color: bool) -> Self {
+        self.color_config = if color {
+            self.color_config.or_else(Default::default)
+        } else {
+            None
+        };
+        self
+    }
+
+    #[cfg(feature = "colored")]
+    pub fn color_config(
+        mut self,
+        modify_config: impl FnOnce(ColoredLevelConfig) -> ColoredLevelConfig,
+    ) -> Self {
+        self.color_config = self.color_config.map(modify_config);
+        self
+    }
+
+    #[cfg(feature = "chrono")]
+    pub fn chrono(mut self, chrono: bool) -> Self {
+        self.chrono = chrono;
+        self
+    }
+
+    #[rustfmt::skip]
+    pub fn build(
+        self,
+    ) -> impl Fn(FormatCallback<'_>, &std::fmt::Arguments<'_>, &log::Record<'_>) + Sync + Send + 'static
+    {
+        move |out, message, record| {
+            let time = {
+                #[cfg(feature = "chrono")]
+                {
+                    self.chrono
+                        .then(|| chrono::Local::now().format("%Y-%m-%d %H:%M:%S,%3f"))
+                }
+                #[cfg(not(feature = "chrono"))]
+                {
+                    None
+                }
+            };
+
+            let level = if self.level {
+                #[cfg(feature = "colored")]
+                {
+                    Some(
+                        self.color_config
+                            .map(|config| config.color(record.level()))
+                            .unwrap_or_else(|| crate::colors::WithFgColor {
+                                text: record.level(),
+                                color: None,
+                            }),
+                    )
+                }
+                #[cfg(not(feature = "colored"))]
+                {
+                    Some(record.level())
+                }
+            } else {
+                None
+            };
+
+            let target = self.target.then(|| {
+                if !record.target().is_empty() {
+                    record.target()
+                } else {
+                    record.module_path().unwrap_or_default()
+                }
+            });
+
+            /* Sadly we cannot store and compose std::fmt::Arguments due to lifetime issues.
+             * In order to avoid unnecessary write calls nevertheless, we must enumerate all options
+             */
+            match (time, level, target) {
+                (Some(time), Some(level), Some(target)) => out.finish(format_args!("{} {:<5} [{}] {}", time, level, target, message)),
+                (Some(time), Some(level), None) => out.finish(format_args!("{} {:<5} {}", time, level, message)),
+                (Some(time), None, Some(target)) => out.finish(format_args!("{} [{}] {}", time, target, message)),
+                (Some(time), None, None) => out.finish(format_args!("{} {}", time, message)),
+                (None, Some(level), Some(target)) => out.finish(format_args!("{:<5} [{}] {}", level, target, message)),
+                (None, None, Some(target)) => out.finish(format_args!("[{}] {}", target, message)),
+                (None, Some(level), None) => out.finish(format_args!("{:<5} {}", level, message)),
+                (None, None, None) => out.finish(format_args!("{}", message)),
+            }
+        }
+    }
+}

src/colors.rs

@@ -82,18 +82,22 @@ pub struct WithFgColor<T>
 where
     T: fmt::Display,
 {
-    text: T,
-    color: Color,
+    pub(super) text: T,
+    pub(super) color: Option<Color>,
 }
 
 impl<T> fmt::Display for WithFgColor<T>
 where
     T: fmt::Display,
 {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "\x1B[{}m", self.color.to_fg_str())?;
-        fmt::Display::fmt(&self.text, f)?;
-        write!(f, "\x1B[0m")?;
+        if let Some(color) = self.color {
+            write!(f, "\x1B[{}m", color.to_fg_str())?;
+            fmt::Display::fmt(&self.text, f)?;
+            write!(f, "\x1B[0m")?;
+        } else {
+            fmt::Display::fmt(&self.text, f)?;
+        }
         Ok(())
     }
 }
@@ -246,26 +250,17 @@ impl ColoredLevelConfig {
 impl Default for ColoredLevelConfig {
     /// Retrieves the default configuration. This has:
     ///
-    /// - [`Error`] as [`Color::Red`]
-    /// - [`Warn`] as [`Color::Yellow`]
-    /// - [`Info`] as [`Color::White`]
-    /// - [`Debug`] as [`Color::White`]
-    /// - [`Trace`] as [`Color::White`]
-    ///
-    /// [`Error`]: https://docs.rs/log/0.4/log/enum.Level.html#variant.Error
-    /// [`Warn`]: https://docs.rs/log/0.4/log/enum.Level.html#variant.Warn
-    /// [`Info`]: https://docs.rs/log/0.4/log/enum.Level.html#variant.Info
-    /// [`Debug`]: https://docs.rs/log/0.4/log/enum.Level.html#variant.Debug
-    /// [`Trace`]: https://docs.rs/log/0.4/log/enum.Level.html#variant.Trace
-    /// [`Color::White`]: https://docs.rs/colored/1/colored/enum.Color.html#variant.White
-    /// [`Color::Yellow`]: https://docs.rs/colored/1/colored/enum.Color.html#variant.Yellow
-    /// [`Color::Red`]: https://docs.rs/colored/1/colored/enum.Color.html#variant.Red
+    /// - [`Error`](log::Level::Error) as [`Color::Red`]
+    /// - [`Warn`](log::Level::Warn) as [`Color::Yellow`]
+    /// - [`Info`](log::Level::Info) as [`Color::White`]
+    /// - [`Debug`](log::Level::Debug) as [`Color::White`]
+    /// - [`Trace`](log::Level::Trace) as [`Color::White`]
     fn default() -> Self {
         ColoredLevelConfig {
             error: Color::Red,
             warn: Color::Yellow,
-            debug: Color::White,
-            info: Color::White,
+            info: Color::Cyan,
+            debug: Color::BrightMagenta,
             trace: Color::White,
         }
     }
@@ -275,7 +270,7 @@ impl ColoredLogLevel for Level {
     fn colored(&self, color: Color) -> WithFgColor<Level> {
         WithFgColor {
             text: *self,
-            color: color,
+            color: Some(color),
         }
     }
 }
@@ -313,7 +308,7 @@ mod test {
                     "{}",
                     WithFgColor {
                         text: "test",
-                        color: color,
+                        color: Some(color),
                     }
                 )
             );
@@ -327,7 +322,7 @@ mod test {
             "{:^8}",
             WithFgColor {
                 text: "test",
-                color: Yellow,
+                color: Some(Yellow),
             }
         );
         assert!(s.contains("  test  "));

src/lib.rs

@@ -229,7 +229,7 @@ use std::{
 use std::collections::HashMap;
 
 pub use crate::{
-    builders::{Dispatch, Output},
+    builders::{Dispatch, FormatterBuilder, Output},
     errors::InitError,
     log_impl::FormatCallback,
 };