Add Options to configure NBReader

phaer · phaer · commit 2771b71f2871 · 2023-10-27T12:21:06.000+02:00
Signed-off-by: phaer &lt;hello@phaer.org&gt;
diff --git a/README.md b/README.md
@@ -38,7 +38,7 @@ use rexpect::spawn;
 use rexpect::error::*;
 
 fn do_ftp() -> Result<(), Error> {
-    let mut p = spawn("ftp speedtest.tele2.net", Some(30_000), false)?;
+    let mut p = spawn("ftp speedtest.tele2.net", Some(30_000))?;
     p.exp_regex("Name \\(.*\\):")?;
     p.send_line("anonymous")?;
     p.exp_string("Password")?;
@@ -65,7 +65,7 @@ use rexpect::spawn_bash;
 use rexpect::error::*;
 
 fn do_bash() -> Result<(), Error> {
-    let mut p = spawn_bash(Some(2000), false)?;
+    let mut p = spawn_bash(Some(2000))?;
 
     // case 1: wait until program is done
     p.send_line("hostname")?;
@@ -115,7 +115,7 @@ use rexpect::spawn_bash;
 use rexpect::error::*;
 
 fn do_bash_jobcontrol() -> Result<(), Error> {
-    let mut p = spawn_bash(Some(1000), false)?;
+    let mut p = spawn_bash(Some(1000))?;
     p.execute("ping 8.8.8.8", "bytes of data")?;
     p.send_control('z')?;
     p.wait_for_prompt()?;
diff --git a/examples/bash.rs b/examples/bash.rs
@@ -2,7 +2,7 @@ use rexpect::error::Error;
 use rexpect::spawn_bash;
 
 fn main() -> Result<(), Error> {
-    let mut p = spawn_bash(Some(1000), false)?;
+    let mut p = spawn_bash(Some(1000))?;
     p.execute("ping 8.8.8.8", "bytes")?;
     p.send_control('z')?;
     p.wait_for_prompt()?;
diff --git a/examples/bash_read.rs b/examples/bash_read.rs
@@ -2,7 +2,7 @@ use rexpect::error::Error;
 use rexpect::spawn_bash;
 
 fn main() -> Result<(), Error> {
-    let mut p = spawn_bash(Some(2000), false)?;
+    let mut p = spawn_bash(Some(2000))?;
 
     // case 1: wait until program is done
     p.send_line("hostname")?;
diff --git a/examples/exit_code.rs b/examples/exit_code.rs
@@ -7,13 +7,13 @@ use rexpect::spawn;
 /// cat exited with code 1
 /// Output (stdout and stderr): cat: /this/does/not/exist: No such file or directory
 fn main() -> Result<(), Error> {
-    let p = spawn("cat /etc/passwd", Some(2000), false)?;
+    let p = spawn("cat /etc/passwd", Some(2000))?;
     match p.process.wait() {
         Ok(wait::WaitStatus::Exited(_, 0)) => println!("cat exited with code 0, all good!"),
         _ => println!("cat exited with code >0, or it was killed"),
     }
 
-    let mut p = spawn("cat /this/does/not/exist", Some(2000), false)?;
+    let mut p = spawn("cat /this/does/not/exist", Some(2000))?;
     match p.process.wait() {
         Ok(wait::WaitStatus::Exited(_, 0)) => println!("cat succeeded"),
         Ok(wait::WaitStatus::Exited(_, c)) => {
diff --git a/examples/ftp.rs b/examples/ftp.rs
@@ -2,7 +2,7 @@ use rexpect::error::Error;
 use rexpect::spawn;
 
 fn main() -> Result<(), Error> {
-    let mut p = spawn("ftp speedtest.tele2.net", Some(2000), false)?;
+    let mut p = spawn("ftp speedtest.tele2.net", Some(2000))?;
     p.exp_regex("Name \\(.*\\):")?;
     p.send_line("anonymous")?;
     p.exp_string("Password")?;
diff --git a/examples/repl.rs b/examples/repl.rs
@@ -12,7 +12,7 @@ fn ed_session() -> Result<PtyReplSession, Error> {
 
         // used for `wait_for_prompt()`
         prompt: "> ".to_string(),
-        pty_session: spawn("/bin/ed -p '> '", Some(2000), false)?,
+        pty_session: spawn("/bin/ed -p '> '", Some(2000))?,
         // command which is sent when the instance of this struct is dropped
         // in the below example this is not needed, but if you don't explicitly
         // exit a REPL then rexpect tries to send a SIGTERM and depending on the repl
diff --git a/src/lib.rs b/src/lib.rs
@@ -20,7 +20,7 @@
 //! use rexpect::error::Error;
 //!
 //! fn main() -> Result<(), Error> {
-//!     let mut p = spawn("ftp speedtest.tele2.net", Some(2000), false)?;
+//!     let mut p = spawn("ftp speedtest.tele2.net", Some(2000))?;
 //!     p.exp_regex("Name \\(.*\\):")?;
 //!     p.send_line("anonymous")?;
 //!     p.exp_string("Password")?;
@@ -50,7 +50,7 @@
 //! use rexpect::error::Error;
 //!
 //! fn main() -> Result<(), Error> {
-//!     let mut p = spawn_bash(Some(30_000), false)?;
+//!     let mut p = spawn_bash(Some(30_000))?;
 //!     p.execute("ping 8.8.8.8", "bytes of data")?;
 //!     p.send_control('z')?;
 //!     p.wait_for_prompt()?;
@@ -70,7 +70,7 @@ pub mod reader;
 pub mod session;
 
 pub use reader::ReadUntil;
-pub use session::{spawn, spawn_bash, spawn_python, spawn_stream};
+pub use session::{spawn, spawn_bash, spawn_python, spawn_stream, spawn_with_options};
 
 // include the README.md here to test its doc
 #[doc = include_str!("../README.md")]
diff --git a/src/reader.rs b/src/reader.rs
@@ -98,6 +98,18 @@ pub fn find(needle: &ReadUntil, buffer: &str, eof: bool) -> Option<(usize, usize
     }
 }
 
+/// Options for NBReader
+///
+/// - timeout:
+///  + `None`: read_until is blocking forever. This is probably not what you want
+///  + `Some(millis)`: after millis milliseconds a timeout error is raised
+/// - strip_ansi_escape_codes: Whether to filter out escape codes, such as colors.
+#[derive(Default)]
+pub struct Options {
+    pub timeout_ms: Option<u64>,
+    pub strip_ansi_escape_codes: bool,
+}
+
 /// Non blocking reader
 ///
 /// Typically you'd need that to check for output of a process without blocking your thread.
@@ -116,15 +128,8 @@ impl NBReader {
     /// # Arguments:
     ///
     /// - f: file like object
-    /// - timeout:
-    ///  + `None`: read_until is blocking forever. This is probably not what you want
-    ///  + `Some(millis)`: after millis milliseconds a timeout error is raised
-    /// - strip_ansi_escape_codes: Whether to filter out escape codes, such as colors.
-    pub fn new<R: Read + Send + 'static>(
-        f: R,
-        timeout: Option<u64>,
-        strip_ansi_escape_codes: bool
-    ) -> NBReader {
+    /// - options: see `Options`
+    pub fn new<R: Read + Send + 'static>(f: R, options: Options) -> NBReader {
         let (tx, rx) = channel();
 
         // spawn a thread which reads one char and sends it to tx
@@ -140,21 +145,20 @@ impl NBReader {
                         break;
                     }
                     Ok(_) => {
-                        if strip_ansi_escape_codes && byte[0] == 27 {
+                        if options.strip_ansi_escape_codes && byte[0] == 27 {
                             while let Ok(_) = reader.read(&mut byte) {
                                 if char::from(byte[0]).is_alphabetic() {
                                     break;
                                 }
                             }
-                        }
-                        else {
+                        } else {
                             tx.send(Ok(PipedChar::Char(byte[0])))
-                              .map_err(|_| Error::MpscSendError)?;
+                                .map_err(|_| Error::MpscSendError)?;
                         }
                     }
                     Err(error) => {
                         tx.send(Err(PipeError::IO(error)))
-                          .map_err(|_| Error::MpscSendError)?;
+                            .map_err(|_| Error::MpscSendError)?;
                     }
                 }
             }
@@ -168,7 +172,7 @@ impl NBReader {
             reader: rx,
             buffer: String::with_capacity(1024),
             eof: false,
-            timeout: timeout.map(time::Duration::from_millis),
+            timeout: options.timeout_ms.map(time::Duration::from_millis),
         }
     }
 
@@ -219,11 +223,11 @@ impl NBReader {
     ///
     /// ```
     /// # use std::io::Cursor;
-    /// use rexpect::reader::{NBReader, ReadUntil, Regex};
+    /// use rexpect::reader::{NBReader, ReadUntil, Regex, Options};
     /// // instead of a Cursor you would put your process output or file here
     /// let f = Cursor::new("Hello, miss!\n\
     ///                         What do you mean: 'miss'?");
-    /// let mut e = NBReader::new(f, None, false);
+    /// let mut e = NBReader::new(f, Options::default());
     ///
     /// let (first_line, _) = e.read_until(&ReadUntil::String('\n'.to_string())).unwrap();
     /// assert_eq!("Hello, miss!", &first_line);
@@ -303,7 +307,7 @@ mod tests {
     #[test]
     fn test_expect_melon() {
         let f = io::Cursor::new("a melon\r\n");
-        let mut r = NBReader::new(f, None, false);
+        let mut r = NBReader::new(f, Options::default());
         assert_eq!(
             ("a melon".to_string(), "\r\n".to_string()),
             r.read_until(&ReadUntil::String("\r\n".to_string()))
@@ -320,7 +324,7 @@ mod tests {
     #[test]
     fn test_regex() {
         let f = io::Cursor::new("2014-03-15");
-        let mut r = NBReader::new(f, None, false);
+        let mut r = NBReader::new(f, Options::default());
         let re = Regex::new(r"^\d{4}-\d{2}-\d{2}$").unwrap();
         assert_eq!(
             ("".to_string(), "2014-03-15".to_string()),
@@ -332,7 +336,7 @@ mod tests {
     #[test]
     fn test_regex2() {
         let f = io::Cursor::new("2014-03-15");
-        let mut r = NBReader::new(f, None, false);
+        let mut r = NBReader::new(f, Options::default());
         let re = Regex::new(r"-\d{2}-").unwrap();
         assert_eq!(
             ("2014".to_string(), "-03-".to_string()),
@@ -344,7 +348,7 @@ mod tests {
     #[test]
     fn test_nbytes() {
         let f = io::Cursor::new("abcdef");
-        let mut r = NBReader::new(f, None, false);
+        let mut r = NBReader::new(f, Options::default());
         assert_eq!(
             ("".to_string(), "ab".to_string()),
             r.read_until(&ReadUntil::NBytes(2)).expect("2 bytes")
@@ -362,7 +366,7 @@ mod tests {
     #[test]
     fn test_any_with_multiple_possible_matches() {
         let f = io::Cursor::new("zero one two three four five");
-        let mut r = NBReader::new(f, None, false);
+        let mut r = NBReader::new(f, Options::default());
 
         let result = r
             .read_until(&ReadUntil::Any(vec![
@@ -377,7 +381,7 @@ mod tests {
     #[test]
     fn test_any_with_same_start_different_length() {
         let f = io::Cursor::new("hi hello");
-        let mut r = NBReader::new(f, None, false);
+        let mut r = NBReader::new(f, Options::default());
 
         let result = r
             .read_until(&ReadUntil::Any(vec![
@@ -392,7 +396,7 @@ mod tests {
     #[test]
     fn test_eof() {
         let f = io::Cursor::new("lorem ipsum dolor sit amet");
-        let mut r = NBReader::new(f, None, false);
+        let mut r = NBReader::new(f, Options::default());
         r.read_until(&ReadUntil::NBytes(2)).expect("2 bytes");
         assert_eq!(
             ("".to_string(), "rem ipsum dolor sit amet".to_string()),
@@ -403,18 +407,24 @@ mod tests {
     #[test]
     fn test_skip_ansi_codes() {
         let f = io::Cursor::new("\x1b[31;1;4mHello\x1b[0m");
-        let mut r = NBReader::new(f, None, true);
-        let bytes = r.read_until(&ReadUntil::String("Hello".to_string())).unwrap();
+        let mut r = NBReader::new(
+            f,
+            Options {
+                timeout_ms: None,
+                strip_ansi_escape_codes: true,
+            },
+        );
+        let bytes = r
+            .read_until(&ReadUntil::String("Hello".to_string()))
+            .unwrap();
         assert_eq!(bytes, ("".to_string(), "Hello".to_string()));
         assert_eq!(None, r.try_read());
-
     }
 
-
     #[test]
     fn test_try_read() {
         let f = io::Cursor::new("lorem");
-        let mut r = NBReader::new(f, None, false);
+        let mut r = NBReader::new(f, Options::default());
         let bytes = r.read_until(&ReadUntil::NBytes(4)).unwrap();
         assert!(bytes.0.is_empty());
         assert_eq!(bytes.1, "lore");
diff --git a/src/session.rs b/src/session.rs
