style: Make clippy happy

Author: epage

examples/bash_read.rs

@@ -8,7 +8,7 @@ fn main() -> Result<(), Error> {
     p.send_line("hostname")?;
     let hostname = p.read_line()?;
     p.wait_for_prompt()?; // go sure `hostname` is really done
-    println!("Current hostname: {}", hostname);
+    println!("Current hostname: {hostname}");
 
     // case 2: wait until done, only extract a few infos
     p.send_line("wc /etc/passwd")?;
@@ -17,17 +17,14 @@ fn main() -> Result<(), Error> {
     let (_, words) = p.exp_regex("[0-9]+")?;
     let (_, bytes) = p.exp_regex("[0-9]+")?;
     p.wait_for_prompt()?; // go sure `wc` is really done
-    println!(
-        "/etc/passwd has {} lines, {} words, {} chars",
-        lines, words, bytes
-    );
+    println!("/etc/passwd has {lines} lines, {words} words, {bytes} chars");
 
     // case 3: read while program is still executing
     p.execute("ping 8.8.8.8", "bytes of data")?; // returns when it sees "bytes of data" in output
     for _ in 0..5 {
         // times out if one ping takes longer than 2s
         let (_, duration) = p.exp_regex("[0-9. ]+ ms")?;
-        println!("Roundtrip time: {}", duration);
+        println!("Roundtrip time: {duration}");
     }
     p.send_control('c')?;
     Ok(())

examples/exit_code.rs

@@ -17,7 +17,7 @@ fn main() -> Result<(), Error> {
     match p.process.wait() {
         Ok(wait::WaitStatus::Exited(_, 0)) => println!("cat succeeded"),
         Ok(wait::WaitStatus::Exited(_, c)) => {
-            println!("Cat failed with exit code {}", c);
+            println!("Cat failed with exit code {c}");
             println!("Output (stdout and stderr): {}", p.exp_eof()?);
         }
         // for other possible return types of wait()

examples/repl.rs

@@ -11,13 +11,13 @@ fn ed_session() -> Result<PtyReplSession, Error> {
         echo_on: false,
 
         // used for `wait_for_prompt()`
-        prompt: "> ".to_string(),
+        prompt: "> ".to_owned(),
         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
         // this does not end the repl and would end up in an error
-        quit_command: Some("Q".to_string()),
+        quit_command: Some("Q".to_owned()),
     };
     ed.wait_for_prompt()?;
     Ok(ed)

src/error.rs

@@ -2,7 +2,7 @@ use std::time;
 
 #[derive(Debug, thiserror::Error)]
 pub enum Error {
-    #[error("EOF (End of File): Expected {} but got EOF after reading \"{}\" process terminated with {:?}", .expected, .got, .exit_code.as_ref().unwrap_or(&"unknown".to_string()))]
+    #[error("EOF (End of File): Expected {} but got EOF after reading \"{}\" process terminated with {:?}", .expected, .got, .exit_code.as_ref().unwrap_or(&"unknown".to_owned()))]
     EOF {
         expected: String,
         got: String,

src/lib.rs

@@ -39,7 +39,7 @@
 //! # Example with bash
 //!
 //! Tip: try the chain of commands first in a bash session.
-//! The tricky thing is to get the wait_for_prompt right.
+//! The tricky thing is to get the `wait_for_prompt` right.
 //! What `wait_for_prompt` actually does is seeking to the next
 //! visible prompt. If you forgot to call this once your next call to
 //! `wait_for_prompt` comes out of sync and you're seeking to a prompt

src/process.rs

@@ -19,7 +19,7 @@ use std::{thread, time};
 /// Start a process in a forked tty so you can interact with it the same as you would
 /// within a terminal
 ///
-/// The process and pty session are killed upon dropping PtyProcess
+/// The process and pty session are killed upon dropping `PtyProcess`
 ///
 /// # Example
 ///
@@ -142,8 +142,8 @@ impl PtyProcess {
         unsafe { Ok(File::from_raw_fd(fd)) }
     }
 
-    /// At the drop of PtyProcess the running process is killed. This is blocking forever if
-    /// the process does not react to a normal kill. If kill_timeout is set the process is
+    /// At the drop of `PtyProcess` the running process is killed. This is blocking forever if
+    /// the process does not react to a normal kill. If `kill_timeout` is set the process is
     /// `kill -9`ed after duration
     pub fn set_kill_timeout(&mut self, timeout_ms: Option<u64>) {
         self.kill_timeout = timeout_ms.map(time::Duration::from_millis);
@@ -197,7 +197,7 @@ impl PtyProcess {
     /// Kill the process with a specific signal. This method blocks, until the process is dead
     ///
     /// repeatedly sends SIGTERM to the process until it died,
-    /// the pty session is closed upon dropping PtyMaster,
+    /// the pty session is closed upon dropping `PtyMaster`,
     /// so we don't need to explicitly do that here.
     ///
     /// if `kill_timeout` is set and a repeated sending of signal does not result in the process
@@ -221,7 +221,7 @@ impl PtyProcess {
             // kill -9 if timout is reached
             if let Some(timeout) = self.kill_timeout {
                 if start.elapsed() > timeout {
-                    signal::kill(self.child_pid, signal::Signal::SIGKILL).map_err(Error::from)?
+                    signal::kill(self.child_pid, signal::Signal::SIGKILL).map_err(Error::from)?;
                 }
             }
         }
@@ -244,7 +244,7 @@ mod tests {
 
     #[test]
     /// Open cat, write string, read back string twice, send Ctrl^C and check that cat exited
-    fn test_cat() -> std::io::Result<()> {
+    fn test_cat() -> io::Result<()> {
         let process = PtyProcess::new(Command::new("cat")).expect("could not execute cat");
         let f = process.get_file_handle().unwrap();
         let mut writer = LineWriter::new(&f);

src/reader.rs

@@ -5,8 +5,8 @@ pub use regex::Regex;
 use std::io::prelude::*;
 use std::io::{self, BufReader};
 use std::sync::mpsc::{channel, Receiver};
+use std::thread;
 use std::{fmt, time};
-use std::{result, thread};
 
 #[derive(Debug)]
 enum PipeError {
@@ -29,14 +29,14 @@ pub enum ReadUntil {
 }
 
 impl fmt::Display for ReadUntil {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let printable = match self {
-            ReadUntil::String(ref s) if s == "\n" => "\\n (newline)".to_string(),
-            ReadUntil::String(ref s) if s == "\r" => "\\r (carriage return)".to_string(),
-            ReadUntil::String(ref s) => format!("\"{}\"", s),
-            ReadUntil::Regex(ref r) => format!("Regex: \"{}\"", r),
-            ReadUntil::EOF => "EOF (End of File)".to_string(),
-            ReadUntil::NBytes(n) => format!("reading {} bytes", n),
+            ReadUntil::String(ref s) if s == "\n" => "\\n (newline)".to_owned(),
+            ReadUntil::String(ref s) if s == "\r" => "\\r (carriage return)".to_owned(),
+            ReadUntil::String(ref s) => format!("\"{s}\""),
+            ReadUntil::Regex(ref r) => format!("Regex: \"{r}\""),
+            ReadUntil::EOF => "EOF (End of File)".to_owned(),
+            ReadUntil::NBytes(n) => format!("reading {n} bytes"),
             ReadUntil::Any(ref v) => {
                 let mut res = Vec::new();
                 for r in v {
@@ -45,7 +45,7 @@ impl fmt::Display for ReadUntil {
                 res.join(", ")
             }
         };
-        write!(f, "{}", printable)
+        write!(f, "{printable}")
     }
 }
 
@@ -98,12 +98,12 @@ pub fn find(needle: &ReadUntil, buffer: &str, eof: bool) -> Option<(usize, usize
     }
 }
 
-/// Options for NBReader
+/// Options for `NBReader`
 ///
 /// - timeout:
-///  + `None`: read_until is blocking forever. This is probably not what you want
+///  + `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.
+/// - `strip_ansi_escape_codes`: Whether to filter out escape codes, such as colors.
 #[derive(Default)]
 pub struct Options {
     pub timeout_ms: Option<u64>,
@@ -116,7 +116,7 @@ pub struct Options {
 /// Internally a thread is spawned and the output is read ahead so when
 /// calling `read_line` or `read_until` it reads from an internal buffer
 pub struct NBReader {
-    reader: Receiver<result::Result<PipedChar, PipeError>>,
+    reader: Receiver<Result<PipedChar, PipeError>>,
     buffer: String,
     eof: bool,
     timeout: Option<time::Duration>,
@@ -192,7 +192,7 @@ impl NBReader {
                 Err(PipeError::IO(ref err)) => {
                     // For an explanation of why we use `raw_os_error` see:
                     // https://github.com/zhiburt/ptyprocess/commit/df003c8e3ff326f7d17bc723bc7c27c50495bb62
-                    self.eof = err.raw_os_error() == Some(5)
+                    self.eof = err.raw_os_error() == Some(5);
                 }
             }
         }
@@ -207,7 +207,7 @@ impl NBReader {
     ///
     /// There are different modes:
     ///
-    /// - `ReadUntil::String` searches for string (use '\n'.to_string() to search for newline).
+    /// - `ReadUntil::String` searches for string (use '\n'.`to_string()` to search for newline).
     ///   Returns not yet read data in first String, and needle in second String
     /// - `ReadUntil::Regex` searches for regex
     ///   Returns not yet read data in first String and matched regex in second String
@@ -310,8 +310,8 @@ mod tests {
         let f = io::Cursor::new("a melon\r\n");
         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()))
+            ("a melon".to_owned(), "\r\n".to_owned()),
+            r.read_until(&ReadUntil::String("\r\n".to_owned()))
                 .expect("cannot read line")
         );
         // check for EOF
@@ -328,7 +328,7 @@ mod tests {
         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()),
+            ("".to_owned(), "2014-03-15".to_owned()),
             r.read_until(&ReadUntil::Regex(re))
                 .expect("regex doesn't match")
         );
@@ -340,7 +340,7 @@ mod tests {
         let mut r = NBReader::new(f, Options::default());
         let re = Regex::new(r"-\d{2}-").unwrap();
         assert_eq!(
-            ("2014".to_string(), "-03-".to_string()),
+            ("2014".to_owned(), "-03-".to_owned()),
             r.read_until(&ReadUntil::Regex(re))
                 .expect("regex doesn't match")
         );
@@ -351,15 +351,15 @@ mod tests {
         let f = io::Cursor::new("abcdef");
         let mut r = NBReader::new(f, Options::default());
         assert_eq!(
-            ("".to_string(), "ab".to_string()),
+            ("".to_owned(), "ab".to_owned()),
             r.read_until(&ReadUntil::NBytes(2)).expect("2 bytes")
         );
         assert_eq!(
-            ("".to_string(), "cde".to_string()),
+            ("".to_owned(), "cde".to_owned()),
             r.read_until(&ReadUntil::NBytes(3)).expect("3 bytes")
         );
         assert_eq!(
-            ("".to_string(), "f".to_string()),
+            ("".to_owned(), "f".to_owned()),
             r.read_until(&ReadUntil::NBytes(4)).expect("4 bytes")
         );
     }
@@ -371,12 +371,12 @@ mod tests {
 
         let result = r
             .read_until(&ReadUntil::Any(vec![
-                ReadUntil::String("two".to_string()),
-                ReadUntil::String("one".to_string()),
+                ReadUntil::String("two".to_owned()),
+                ReadUntil::String("one".to_owned()),
             ]))
             .expect("finding string");
 
-        assert_eq!(("zero ".to_string(), "one".to_string()), result);
+        assert_eq!(("zero ".to_owned(), "one".to_owned()), result);
     }
 
     #[test]
@@ -386,12 +386,12 @@ mod tests {
 
         let result = r
             .read_until(&ReadUntil::Any(vec![
-                ReadUntil::String("hello".to_string()),
-                ReadUntil::String("hell".to_string()),
+                ReadUntil::String("hello".to_owned()),
+                ReadUntil::String("hell".to_owned()),
             ]))
             .expect("finding string");
 
-        assert_eq!(("hi ".to_string(), "hell".to_string()), result);
+        assert_eq!(("hi ".to_owned(), "hell".to_owned()), result);
     }
 
     #[test]
@@ -400,7 +400,7 @@ mod tests {
         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()),
+            ("".to_owned(), "rem ipsum dolor sit amet".to_owned()),
             r.read_until(&ReadUntil::EOF).expect("reading until EOF")
         );
     }
@@ -416,9 +416,9 @@ mod tests {
             },
         );
         let bytes = r
-            .read_until(&ReadUntil::String("Hello".to_string()))
+            .read_until(&ReadUntil::String("Hello".to_owned()))
             .unwrap();
-        assert_eq!(bytes, ("".to_string(), "Hello".to_string()));
+        assert_eq!(bytes, ("".to_owned(), "Hello".to_owned()));
         assert_eq!(None, r.try_read());
     }
 
@@ -433,9 +433,9 @@ mod tests {
             },
         );
         let bytes = r
-            .read_until(&ReadUntil::String("Hello".to_string()))
+            .read_until(&ReadUntil::String("Hello".to_owned()))
             .unwrap();
-        assert_eq!(bytes, ("".to_string(), "Hello".to_string()));
+        assert_eq!(bytes, ("".to_owned(), "Hello".to_owned()));
         assert_eq!(None, r.try_read());
     }