refactor(fmt): Pull out DefaultFormat

Author: epage

src/fmt/mod.rs

@@ -202,18 +202,10 @@ impl fmt::Debug for Formatter {
 
 pub(crate) type FormatFn = Box<dyn Fn(&mut Formatter, &Record<'_>) -> io::Result<()> + Sync + Send>;
 
+#[derive(Default)]
 pub(crate) struct Builder {
-    pub(crate) format_timestamp: Option<TimestampPrecision>,
-    pub(crate) format_module_path: bool,
-    pub(crate) format_target: bool,
-    pub(crate) format_level: bool,
-    pub(crate) format_indent: Option<usize>,
+    pub(crate) default_format: DefaultFormat,
     pub(crate) custom_format: Option<FormatFn>,
-    pub(crate) format_suffix: &'static str,
-    pub(crate) format_file: bool,
-    pub(crate) format_line_number: bool,
-    #[cfg(feature = "kv")]
-    pub(crate) kv_format: Option<Box<KvFormatFn>>,
     built: bool,
 }
 
@@ -239,17 +231,21 @@ impl Builder {
         } else {
             Box::new(move |buf, record| {
                 let fmt = DefaultFormatWriter {
-                    timestamp: built.format_timestamp,
-                    module_path: built.format_module_path,
-                    target: built.format_target,
-                    level: built.format_level,
+                    timestamp: built.default_format.timestamp,
+                    module_path: built.default_format.module_path,
+                    target: built.default_format.target,
+                    level: built.default_format.level,
                     written_header_value: false,
-                    indent: built.format_indent,
-                    suffix: built.format_suffix,
-                    source_file: built.format_file,
-                    source_line_number: built.format_line_number,
+                    indent: built.default_format.indent,
+                    suffix: built.default_format.suffix,
+                    source_file: built.default_format.source_file,
+                    source_line_number: built.default_format.source_line_number,
                     #[cfg(feature = "kv")]
-                    kv_format: built.kv_format.as_deref().unwrap_or(&default_kv_format),
+                    kv_format: built
+                        .default_format
+                        .kv_format
+                        .as_deref()
+                        .unwrap_or(&default_kv_format),
                     buf,
                 };
 
@@ -259,25 +255,6 @@ impl Builder {
     }
 }
 
-impl Default for Builder {
-    fn default() -> Self {
-        Builder {
-            format_timestamp: Some(Default::default()),
-            format_module_path: false,
-            format_target: true,
-            format_level: true,
-            format_file: false,
-            format_line_number: false,
-            format_indent: Some(4),
-            custom_format: None,
-            format_suffix: "\n",
-            #[cfg(feature = "kv")]
-            kv_format: None,
-            built: false,
-        }
-    }
-}
-
 #[cfg(feature = "color")]
 type SubtleStyle = StyledValue<&'static str>;
 #[cfg(not(feature = "color"))]
@@ -307,6 +284,39 @@ impl<T: Display> Display for StyledValue<T> {
 #[cfg(not(feature = "color"))]
 type StyledValue<T> = T;
 
+/// The default format.
+///
+/// This format needs to work with any combination of crate features.
+pub(crate) struct DefaultFormat {
+    pub(crate) timestamp: Option<TimestampPrecision>,
+    pub(crate) module_path: bool,
+    pub(crate) target: bool,
+    pub(crate) level: bool,
+    pub(crate) source_file: bool,
+    pub(crate) source_line_number: bool,
+    pub(crate) indent: Option<usize>,
+    pub(crate) suffix: &'static str,
+    #[cfg(feature = "kv")]
+    pub(crate) kv_format: Option<Box<KvFormatFn>>,
+}
+
+impl Default for DefaultFormat {
+    fn default() -> Self {
+        Self {
+            timestamp: Some(Default::default()),
+            module_path: false,
+            target: true,
+            level: true,
+            source_file: false,
+            source_line_number: false,
+            indent: Some(4),
+            suffix: "\n",
+            #[cfg(feature = "kv")]
+            kv_format: None,
+        }
+    }
+}
+
 /// The default format.
 ///
 /// This format needs to work with any combination of crate features.

src/logger.rs

@@ -258,21 +258,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.format_level = write;
+        self.format.default_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.format_file = write;
+        self.format.default_format.source_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.format_line_number = write;
+        self.format.default_format.source_line_number = write;
         self
     }
 
@@ -287,26 +287,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.format_module_path = write;
+        self.format.default_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.format_target = write;
+        self.format.default_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.format_indent = indent;
+        self.format.default_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.format_timestamp = timestamp;
+        self.format.default_format.timestamp = timestamp;
         self
     }
 
@@ -332,7 +332,7 @@ impl Builder {
 
     /// Configures the end of line suffix.
     pub fn format_suffix(&mut self, suffix: &'static str) -> &mut Self {
-        self.format.format_suffix = suffix;
+        self.format.default_format.suffix = suffix;
         self
     }
 
@@ -351,7 +351,7 @@ impl Builder {
     where
         F: Fn(&mut Formatter, &dyn log::kv::Source) -> io::Result<()> + Sync + Send + 'static,
     {
-        self.format.kv_format = Some(Box::new(format));
+        self.format.default_format.kv_format = Some(Box::new(format));
         self
     }