refactor(filesource): replace repetitive #[cfg()] usages with cfg_if!{}

src/currentprocess/filesource.rs

@@ -5,6 +5,7 @@ use std::{
  sync::{Arc, Mutex, MutexGuard},
 };
 
+use cfg_if::cfg_if;
 use enum_dispatch::enum_dispatch;
 
 use super::terminalsource::{ColorableTerminal, StreamSelector};
@@ -47,53 +48,49 @@ impl StdinSource for super::OSProcess {
 
 // ----------------------- test support for stdin ------------------
 
-#[cfg(feature = "test")]
-struct TestStdinLock<'a> {
- inner: MutexGuard<'a, Cursor<String>>,
-}
+cfg_if! {
+ if #[cfg(feature = "test")] {
+ struct TestStdinLock<'a> {
+ inner: MutexGuard<'a, Cursor<String>>,
+ }
 
-#[cfg(feature = "test")]
-impl StdinLock for TestStdinLock<'_> {}
+ impl StdinLock for TestStdinLock<'_> {}
 
-#[cfg(feature = "test")]
-impl Read for TestStdinLock<'_> {
- fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
- self.inner.read(buf)
- }
-}
+ impl Read for TestStdinLock<'_> {
+ fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+ self.inner.read(buf)
+ }
+ }
 
-#[cfg(feature = "test")]
-impl BufRead for TestStdinLock<'_> {
- fn fill_buf(&mut self) -> io::Result<&[u8]> {
- self.inner.fill_buf()
- }
- fn consume(&mut self, n: usize) {
- self.inner.consume(n)
- }
-}
+ impl BufRead for TestStdinLock<'_> {
+ fn fill_buf(&mut self) -> io::Result<&[u8]> {
+ self.inner.fill_buf()
+ }
+ fn consume(&mut self, n: usize) {
+ self.inner.consume(n)
+ }
+ }
 
-#[cfg(feature = "test")]
-pub(crate) type TestStdinInner = Arc<Mutex<Cursor<String>>>;
+ pub(crate) type TestStdinInner = Arc<Mutex<Cursor<String>>>;
 
-#[cfg(feature = "test")]
-struct TestStdin(TestStdinInner);
+ struct TestStdin(TestStdinInner);
 
-#[cfg(feature = "test")]
-impl Stdin for TestStdin {
- fn lock(&self) -> Box<dyn StdinLock + '_> {
- Box::new(TestStdinLock {
- inner: self.0.lock().unwrap_or_else(|e| e.into_inner()),
- })
- }
- fn read_line(&self, buf: &mut String) -> Result<usize> {
- self.lock().read_line(buf)
- }
-}
+ impl Stdin for TestStdin {
+ fn lock(&self) -> Box<dyn StdinLock + '_> {
+ Box::new(TestStdinLock {
+ inner: self.0.lock().unwrap_or_else(|e| e.into_inner()),
+ })
+ }
+ fn read_line(&self, buf: &mut String) -> Result<usize> {
+ self.lock().read_line(buf)
+ }
+ }
 
-#[cfg(feature = "test")]
-impl StdinSource for super::TestProcess {
- fn stdin(&self) -> Box<dyn Stdin> {
- Box::new(TestStdin(self.stdin.clone()))
+ impl StdinSource for super::TestProcess {
+ fn stdin(&self) -> Box<dyn Stdin> {
+ Box::new(TestStdin(self.stdin.clone()))
+ }
+ }
  }
 }
 
@@ -189,79 +186,74 @@ impl StderrSource for super::OSProcess {
 
 // ----------------------- test support for writers ------------------
 
-#[cfg(feature = "test")]
-pub(super) struct TestWriterLock<'a> {
- inner: MutexGuard<'a, Vec<u8>>,
-}
+cfg_if! {
+ if #[cfg(feature = "test")] {
+ pub(super) struct TestWriterLock<'a> {
+ inner: MutexGuard<'a, Vec<u8>>,
+ }
 
-#[cfg(feature = "test")]
-impl WriterLock for TestWriterLock<'_> {}
+ impl WriterLock for TestWriterLock<'_> {}
 
-#[cfg(feature = "test")]
-impl Write for TestWriterLock<'_> {
- fn write(&mut self, buf: &[u8]) -> Result<usize> {
- self.inner.write(buf)
- }
+ impl Write for TestWriterLock<'_> {
+ fn write(&mut self, buf: &[u8]) -> Result<usize> {
+ self.inner.write(buf)
+ }
 
- fn flush(&mut self) -> Result<()> {
- Ok(())
- }
-}
+  fn flush(&mut self) -> Result<()> {
+  Ok(())
+  }
+ }
 
-#[cfg(feature = "test")]
-pub(super) type TestWriterInner = Arc<Mutex<Vec<u8>>>;
-/// A thread-safe test file handle that pretends to be e.g. stdout.
-#[derive(Clone, Default)]
-#[cfg(feature = "test")]
-pub(super) struct TestWriter(TestWriterInner);
+ pub(super) type TestWriterInner = Arc<Mutex<Vec<u8>>>;
 
-#[cfg(feature = "test")]
-impl TestWriter {
- pub(super) fn lock(&self) -> TestWriterLock<'_> {
- // The stream can be locked even if a test thread panicked: its state
- // will be ok
- TestWriterLock {
- inner: self.0.lock().unwrap_or_else(|e| e.into_inner()),
+ /// A thread-safe test file handle that pretends to be e.g. stdout.
+ #[derive(Clone, Default)]
+ pub(super) struct TestWriter(TestWriterInner);
+
+ impl TestWriter {
+ pub(super) fn lock(&self) -> TestWriterLock<'_> {
+ // The stream can be locked even if a test thread panicked: its state
+ // will be ok
+ TestWriterLock {
+ inner: self.0.lock().unwrap_or_else(|e| e.into_inner()),
+ }
+ }
  }
- }
-}
 
-#[cfg(feature = "test")]
-impl Writer for TestWriter {
- fn is_a_tty(&self) -> bool {
- false
- }
+ impl Writer for TestWriter {
+ fn is_a_tty(&self) -> bool {
+ false
+ }
 
- fn lock(&self) -> Box<dyn WriterLock + '_> {
- Box::new(self.lock())
- }
+  fn lock(&self) -> Box<dyn WriterLock + '_> {
+  Box::new(self.lock())
+  }
 
- fn terminal(&self) -> ColorableTerminal {
- ColorableTerminal::new(StreamSelector::TestWriter(self.clone()))
- }
-}
+  fn terminal(&self) -> ColorableTerminal {
+  ColorableTerminal::new(StreamSelector::TestWriter(self.clone()))
+  }
+ }
 
-#[cfg(feature = "test")]
-impl Write for TestWriter {
- fn write(&mut self, buf: &[u8]) -> Result<usize> {
- self.lock().write(buf)
- }
+ impl Write for TestWriter {
+ fn write(&mut self, buf: &[u8]) -> Result<usize> {
+ self.lock().write(buf)
+ }
 
- fn flush(&mut self) -> Result<()> {
- Ok(())
- }
-}
+  fn flush(&mut self) -> Result<()> {
+  Ok(())
+  }
+ }
 
-#[cfg(feature = "test")]
-impl StdoutSource for super::TestProcess {
- fn stdout(&self) -> Box<dyn Writer> {
- Box::new(TestWriter(self.stdout.clone()))
- }
-}
+ impl StdoutSource for super::TestProcess {
+ fn stdout(&self) -> Box<dyn Writer> {
+ Box::new(TestWriter(self.stdout.clone()))
+ }
+ }
 
-#[cfg(feature = "test")]
-impl StderrSource for super::TestProcess {
- fn stderr(&self) -> Box<dyn Writer> {
- Box::new(TestWriter(self.stderr.clone()))
+ impl StderrSource for super::TestProcess {
+ fn stderr(&self) -> Box<dyn Writer> {
+ Box::new(TestWriter(self.stderr.clone()))
+ }
+ }
  }
 }