Make pattern_encoder feature less infectious

Cargo.toml

@@ -17,9 +17,9 @@ yaml_format = ["serde_yaml"]
 json_format = ["serde_json"]
 toml_format = ["toml"]
 
-console_appender = ["console_writer", "simple_writer", "pattern_encoder"]
-file_appender = ["parking_lot", "simple_writer", "pattern_encoder"]
-rolling_file_appender = ["parking_lot", "simple_writer", "pattern_encoder"]
+console_appender = ["console_writer", "simple_writer"]
+file_appender = ["parking_lot", "simple_writer"]
+rolling_file_appender = ["parking_lot", "simple_writer"]
 compound_policy = []
 delete_roller = []
 fixed_window_roller = []

src/append/console.rs

@@ -13,11 +13,12 @@ use std::{
 use crate::config::{Deserialize, Deserializers};
 #[cfg(feature = "config_parsing")]
 use crate::encode::EncoderConfig;
+#[cfg(feature = "pattern_encoder")]
+use crate::encode::pattern::PatternEncoder;
 use crate::{
     append::Append,
     encode::{
         self,
-        pattern::PatternEncoder,
         writer::{
             console::{ConsoleWriter, ConsoleWriterLock},
             simple::SimpleWriter,
@@ -143,6 +144,7 @@ impl ConsoleAppender {
     /// Creates a new `ConsoleAppender` builder.
     pub fn builder() -> ConsoleAppenderBuilder {
         ConsoleAppenderBuilder {
+            #[cfg(feature = "pattern_encoder")]
             encoder: None,
             target: Target::Stdout,
             tty_only: false,
@@ -152,13 +154,15 @@ impl ConsoleAppender {
 
 /// A builder for `ConsoleAppender`s.
 pub struct ConsoleAppenderBuilder {
+    #[cfg(feature = "pattern_encoder")]
     encoder: Option<Box<dyn Encode>>,
     target: Target,
     tty_only: bool,
 }
 
 impl ConsoleAppenderBuilder {
     /// Sets the output encoder for the `ConsoleAppender`.
+    #[cfg(feature = "pattern_encoder")]
     pub fn encoder(mut self, encoder: Box<dyn Encode>) -> ConsoleAppenderBuilder {
         self.encoder = Some(encoder);
         self
@@ -181,7 +185,27 @@ impl ConsoleAppenderBuilder {
     }
 
     /// Consumes the `ConsoleAppenderBuilder`, producing a `ConsoleAppender`.
+    #[cfg(feature = "pattern_encoder")]
     pub fn build(self) -> ConsoleAppender {
+        self.build_internal(
+            |this| {
+                this.encoder.take().unwrap_or_else(|| Box::new(PatternEncoder::default()))
+            }
+        )
+    }
+
+    /// Consumes the `ConsoleAppenderBuilder`, producing a `ConsoleAppender`.
+    #[cfg(not(feature = "pattern_encoder"))]
+    pub fn build(self, encoder: Box<dyn Encode>) -> ConsoleAppender {
+        self.build_internal(|_| encoder)
+    }
+
+    fn build_internal<F>(mut self, encoder: F) -> ConsoleAppender
+    where
+        F: FnOnce(&mut Self) -> Box<dyn Encode>,
+    {
+        let encoder = encoder(&mut self);
+
         let writer = match self.target {
             Target::Stderr => match ConsoleWriter::stderr() {
                 Some(writer) => Writer::Tty(writer),
@@ -195,13 +219,7 @@ impl ConsoleAppenderBuilder {
 
         let do_write = writer.is_tty() || !self.tty_only;
 
-        ConsoleAppender {
-            writer,
-            encoder: self
-                .encoder
-                .unwrap_or_else(|| Box::new(PatternEncoder::default())),
-            do_write,
-        }
+        ConsoleAppender { writer, encoder, do_write }
     }
 }
 

src/append/file.rs

@@ -15,10 +15,12 @@ use std::{
 use crate::config::{Deserialize, Deserializers};
 #[cfg(feature = "config_parsing")]
 use crate::encode::EncoderConfig;
+#[cfg(feature = "pattern_encoder")]
+use crate::encode::pattern::PatternEncoder;
 
 use crate::{
     append::Append,
-    encode::{pattern::PatternEncoder, writer::simple::SimpleWriter, Encode},
+    encode::{writer::simple::SimpleWriter, Encode},
 };
 
 /// The file appender's configuration.
@@ -31,13 +33,15 @@ pub struct FileAppenderConfig {
     append: Option<bool>,
 }
 
+type SharedFileWriter = Mutex<SimpleWriter<BufWriter<File>>>;
+
 /// An appender which logs to a file.
 #[derive(Derivative)]
 #[derivative(Debug)]
 pub struct FileAppender {
     path: PathBuf,
     #[derivative(Debug = "ignore")]
-    file: Mutex<SimpleWriter<BufWriter<File>>>,
+    file: SharedFileWriter,
     encoder: Box<dyn Encode>,
 }
 
@@ -88,11 +92,40 @@ impl FileAppenderBuilder {
     /// where 'name_here' will be the name of the environment variable that
     /// will be resolved. Note that if the variable fails to resolve,
     /// $ENV{name_here} will NOT be replaced in the path.
+    #[cfg(feature = "pattern_encoder")]
     pub fn build<P: AsRef<Path>>(self, path: P) -> io::Result<FileAppender> {
-        let path = super::env_util::expand_env_vars(path.as_ref().to_path_buf());
+        self.build_internal(
+            path.as_ref(),
+            |this| {
+                this.encoder.take().unwrap_or_else(|| Box::new(PatternEncoder::default()))
+            },
+        )
+    }
+
+    /// Consumes the `FileAppenderBuilder`, producing a `FileAppender`.
+    /// The path argument can contain environment variables of the form $ENV{name_here},
+    /// where 'name_here' will be the name of the environment variable that
+    /// will be resolved. Note that if the variable fails to resolve,
+    /// $ENV{name_here} will NOT be replaced in the path.
+    #[cfg(not(feature = "pattern_encoder"))]
+    pub fn build<P: AsRef<Path>>(self, path: P, encoder: Box<dyn Encode>) -> io::Result<FileAppender> {
+        self.build_internal(
+            path.as_ref(),
+            |_| encoder,
+        )
+    }
+
+    fn build_internal<F>(mut self, path: &Path, encoder: F) -> io::Result<FileAppender>
+    where
+        F: FnOnce(&mut Self) -> Box<dyn Encode>,
+    {
+        let encoder = encoder(&mut self);
+
+        let path = super::env_util::expand_env_vars(path.to_path_buf());
         if let Some(parent) = path.parent() {
             fs::create_dir_all(parent)?;
         }
+
         let file = OpenOptions::new()
             .write(true)
             .append(self.append)
@@ -103,9 +136,7 @@ impl FileAppenderBuilder {
         Ok(FileAppender {
             path,
             file: Mutex::new(SimpleWriter(BufWriter::with_capacity(1024, file))),
-            encoder: self
-                .encoder
-                .unwrap_or_else(|| Box::new(PatternEncoder::default())),
+            encoder,
         })
     }
 }

src/append/rolling_file/mod.rs

@@ -29,10 +29,12 @@ use std::{
 use serde_value::Value;
 #[cfg(feature = "config_parsing")]
 use std::collections::BTreeMap;
+#[cfg(feature = "pattern_encoder")]
+use crate::encode::pattern::PatternEncoder;
 
 use crate::{
     append::Append,
-    encode::{self, pattern::PatternEncoder, Encode},
+    encode::{self, Encode},
 };
 
 #[cfg(feature = "config_parsing")]
@@ -193,6 +195,7 @@ impl RollingFileAppender {
     pub fn builder() -> RollingFileAppenderBuilder {
         RollingFileAppenderBuilder {
             append: true,
+            #[cfg(feature = "pattern_encoder")]
             encoder: None,
         }
     }
@@ -224,6 +227,7 @@ impl RollingFileAppender {
 /// A builder for the `RollingFileAppender`.
 pub struct RollingFileAppenderBuilder {
     append: bool,
+    #[cfg(feature = "pattern_encoder")]
     encoder: Option<Box<dyn Encode>>,
 }
 
@@ -239,6 +243,7 @@ impl RollingFileAppenderBuilder {
     /// Sets the encoder used by the appender.
     ///
     /// Defaults to a `PatternEncoder` with the default pattern.
+    #[cfg(feature = "pattern_encoder")]
     pub fn encoder(mut self, encoder: Box<dyn Encode>) -> RollingFileAppenderBuilder {
         self.encoder = Some(encoder);
         self
@@ -249,6 +254,7 @@ impl RollingFileAppenderBuilder {
     /// where 'name_here' will be the name of the environment variable that
     /// will be resolved. Note that if the variable fails to resolve,
     /// $ENV{name_here} will NOT be replaced in the path.
+    #[cfg(feature = "pattern_encoder")]
     pub fn build<P>(
         self,
         path: P,
@@ -257,14 +263,52 @@ impl RollingFileAppenderBuilder {
     where
         P: AsRef<Path>,
     {
-        let path = super::env_util::expand_env_vars(path.as_ref().to_path_buf());
+        self.build_internal(
+            path.as_ref(),
+            |this| this.encoder.take().unwrap_or_else(|| Box::new(PatternEncoder::default())),
+            policy,
+        )
+    }
+
+    /// Constructs a `RollingFileAppender`.
+    /// The path argument can contain environment variables of the form $ENV{name_here},
+    /// where 'name_here' will be the name of the environment variable that
+    /// will be resolved. Note that if the variable fails to resolve,
+    /// $ENV{name_here} will NOT be replaced in the path.
+    #[cfg(not(feature = "pattern_encoder"))]
+    pub fn build<P>(
+        self,
+        path: P,
+        encoder: Box<dyn Encode>,
+        policy: Box<dyn policy::Policy>,
+    ) -> io::Result<RollingFileAppender>
+    where
+        P: AsRef<Path>,
+    {
+        self.build_internal(
+            path.as_ref(),
+            |_| encoder,
+            policy,
+        )
+    }
+
+    fn build_internal<F>(
+        mut self,
+        path: &Path,
+        encoder: F,
+        policy: Box<dyn policy::Policy>,
+    ) -> io::Result<RollingFileAppender>
+    where
+        F: FnOnce(&mut Self) -> Box<dyn Encode>,
+    {
+        let encoder = encoder(&mut self);
+
+        let path = super::env_util::expand_env_vars(path.to_path_buf());
         let appender = RollingFileAppender {
             writer: Mutex::new(None),
             path,
             append: self.append,
-            encoder: self
-                .encoder
-                .unwrap_or_else(|| Box::new(PatternEncoder::default())),
+            encoder,
             policy,
         };