refactor: move format/with_format from builder to formatter

Author: djugei

src/fmt/mod.rs

@@ -200,7 +200,7 @@ impl fmt::Debug for Formatter {
     }
 }
 
-pub(crate) trait RecordFormat {
+pub trait RecordFormat {
     fn format(&self, formatter: &mut Formatter, record: &Record<'_>) -> io::Result<()>;
 }
 
@@ -217,8 +217,7 @@ pub(crate) type FormatFn = Box<dyn RecordFormat + Sync + Send>;
 
 #[derive(Default)]
 pub(crate) struct Builder {
-    pub(crate) default_format: ConfigurableFormat,
-    pub(crate) custom_format: Option<FormatFn>,
+    pub(crate) format: ConfigurableFormat,
     built: bool,
 }
 
@@ -239,11 +238,7 @@ impl Builder {
             },
         );
 
-        if let Some(fmt) = built.custom_format {
-            fmt
-        } else {
-            Box::new(built.default_format)
-        }
+        Box::new(built.format)
     }
 }
 

src/logger.rs

@@ -1,4 +1,4 @@
-use std::{borrow::Cow, cell::RefCell, env, io};
+use std::{borrow::Cow, cell::RefCell, env};
 
 use log::{LevelFilter, Log, Metadata, Record, SetLoggerError};
 
@@ -211,43 +211,6 @@ impl Builder {
         self.parse_env(Env::default())
     }
 
-    /// Sets the format function for formatting the log output.
-    ///
-    /// This function is called on each record logged and should format the
-    /// log record and output it to the given [`Formatter`].
-    ///
-    /// The format function is expected to output the string directly to the
-    /// `Formatter` so that implementations can use the [`std::fmt`] macros
-    /// to format and output without intermediate heap allocations. The default
-    /// `env_logger` formatter takes advantage of this.
-    ///
-    /// When the `color` feature is enabled, styling via ANSI escape codes is supported and the
-    /// output will automatically respect [`Builder::write_style`].
-    ///
-    /// # Examples
-    ///
-    /// Use a custom format to write only the log message:
-    ///
-    /// ```
-    /// use std::io::Write;
-    /// use env_logger::Builder;
-    ///
-    /// let mut builder = Builder::new();
-    ///
-    /// builder.format(|buf, record| writeln!(buf, "{}", record.args()));
-    /// ```
-    ///
-    /// [`Formatter`]: fmt/struct.Formatter.html
-    /// [`String`]: https://doc.rust-lang.org/stable/std/string/struct.String.html
-    /// [`std::fmt`]: https://doc.rust-lang.org/std/fmt/index.html
-    pub fn format<F>(&mut self, format: F) -> &mut Self
-    where
-        F: Fn(&mut Formatter, &Record<'_>) -> io::Result<()> + Sync + Send + 'static,
-    {
-        self.format.custom_format = Some(Box::new(format));
-        self
-    }
-
     /// Use the default format.
     ///
     /// This method will clear any custom format set on the builder.
@@ -258,21 +221,21 @@ impl Builder {
 
     /// Whether or not to write the level in the default format.
     pub fn format_level(&mut self, write: bool) -> &mut Self {
-        self.format.default_format.level(write);
+        self.format.format.level(write);
         self
     }
 
     /// Whether or not to write the source file path in the default format.
     pub fn format_file(&mut self, write: bool) -> &mut Self {
-        self.format.default_format.file(write);
+        self.format.format.file(write);
         self
     }
 
     /// Whether or not to write the source line number path in the default format.
     ///
     /// Only has effect if `format_file` is also enabled
     pub fn format_line_number(&mut self, write: bool) -> &mut Self {
-        self.format.default_format.line_number(write);
+        self.format.format.line_number(write);
         self
     }
 
@@ -287,26 +250,26 @@ impl Builder {
 
     /// Whether or not to write the module path in the default format.
     pub fn format_module_path(&mut self, write: bool) -> &mut Self {
-        self.format.default_format.module_path(write);
+        self.format.format.module_path(write);
         self
     }
 
     /// Whether or not to write the target in the default format.
     pub fn format_target(&mut self, write: bool) -> &mut Self {
-        self.format.default_format.target(write);
+        self.format.format.target(write);
         self
     }
 
     /// Configures the amount of spaces to use to indent multiline log records.
     /// A value of `None` disables any kind of indentation.
     pub fn format_indent(&mut self, indent: Option<usize>) -> &mut Self {
-        self.format.default_format.indent(indent);
+        self.format.format.indent(indent);
         self
     }
 
     /// Configures if timestamp should be included and in what precision.
     pub fn format_timestamp(&mut self, timestamp: Option<fmt::TimestampPrecision>) -> &mut Self {
-        self.format.default_format.timestamp(timestamp);
+        self.format.format.timestamp(timestamp);
         self
     }
 
@@ -332,7 +295,7 @@ impl Builder {
 
     /// Configures the end of line suffix.
     pub fn format_suffix(&mut self, suffix: &'static str) -> &mut Self {
-        self.format.default_format.suffix(suffix);
+        self.format.format.suffix(suffix);
         self
     }
 
@@ -349,9 +312,9 @@ impl Builder {
     #[cfg(feature = "kv")]
     pub fn format_key_values<F>(&mut self, format: F) -> &mut Self
     where
-        F: Fn(&mut Formatter, &dyn log::kv::Source) -> io::Result<()> + Sync + Send + 'static,
+        F: Fn(&mut Formatter, &dyn log::kv::Source) -> std::io::Result<()> + Sync + Send + 'static,
     {
-        self.format.default_format.key_values(format);
+        self.format.format.key_values(format);
         self
     }
 
@@ -641,6 +604,40 @@ impl Logger {
     pub fn matches(&self, record: &Record<'_>) -> bool {
         self.filter.matches(record)
     }
+
+    /// Sets the format function for formatting the log output.
+    ///
+    /// This function is called on each record logged and should format the
+    /// log record and output it to the given [`Formatter`].
+    ///
+    /// The format function is expected to output the string directly to the
+    /// `Formatter` so that implementations can use the [`std::fmt`] macros
+    /// to format and output without intermediate heap allocations. The default
+    /// `env_logger` formatter takes advantage of this.
+    ///
+    /// When the `color` feature is enabled, styling via ANSI escape codes is supported and the
+    /// output will automatically respect [`Builder::write_style`].
+    ///
+    /// # Examples
+    ///
+    /// Use a custom format to write only the log message:
+    ///
+    /// ```
+    /// use std::io::Write;
+    /// use env_logger::Builder;
+    ///
+    /// let mut builder = Builder::new();
+    ///
+    /// builder.format(|buf, record| writeln!(buf, "{}", record.args()));
+    /// ```
+    ///
+    /// [`Formatter`]: fmt/struct.Formatter.html
+    /// [`String`]: https://doc.rust-lang.org/stable/std/string/struct.String.html
+    /// [`std::fmt`]: https://doc.rust-lang.org/std/fmt/index.html
+    pub fn with_format<F>(&mut self, format: FormatFn) -> &mut Self {
+        self.format = format;
+        self
+    }
 }
 
 impl Log for Logger {