Update README.md

Author: zhiburt

README.md

@@ -25,7 +25,7 @@ Add `expectrl` to your Cargo.toml.
 ```toml
 # Cargo.toml
 [dependencies]
-expectrl = "0.7"
+expectrl = "0.8"
 ```
 
 An example where the program simulates a used interacting with `ftp`.
@@ -65,27 +65,29 @@ use expectrl::{
 fn main() -> Result<(), Error> {
     let mut p = expectrl::spawn("ftp bks4-speedtest-1.tele2.net")?;
 
-    let mut auth = false;
-    let mut login_lookup = Lookup::new();
+    let mut search = Lookup::new();
     let mut stdin = Stdin::open()?;
 
-    InteractSession::new(&mut p, &mut stdin, stdout(), &mut auth)
-        .set_output_action(move |ctx| {
-            if login_lookup
-                .on(ctx.buf, ctx.eof, "Login successful")?
-                .is_some()
-            {
-                **ctx.state = true;
+    let authenticated = {
+        let mut session = InteractSession::new(&mut p, &mut stdin, stdout(), false);
+        session.set_output_action(move |ctx| {
+            let found = search.on(ctx.buf, ctx.eof, "Login successful")?;
+            if found.is_some() {
+                *ctx.state = true;
                 return Ok(true);
             }
 
             Ok(false)
-        })
-        .spawn()?;
+        });
+
+        session.spawn()?;
+
+        session.into_state()
+    };
 
     stdin.close()?;
 
-    if !auth {
+    if !authenticated {
         println!("An authentication was not passed");
         return Ok(());
     }

examples/bash.rs

@@ -14,16 +14,15 @@ fn main() {
 
     // case 2: wait until done, only extract a few infos
     p.send_line("wc /etc/passwd").unwrap();
-    // `exp_regex` returns both string-before-match and match itself, discard first
-    let lines = p.expect(Regex("[0-9]+")).unwrap();
-    let words = p.expect(Regex("[0-9]+")).unwrap();
-    let bytes = p.expect(Regex("[0-9]+")).unwrap();
+    // `expect` returns both string-before-match and match itself, discard first
+    let found = p.expect(Regex("([0-9]+).*([0-9]+).*([0-9]+)")).unwrap();
+    let lines = String::from_utf8_lossy(&found[1]);
+    let words = String::from_utf8_lossy(&found[2]);
+    let chars = String::from_utf8_lossy(&found[3]);
     p.expect_prompt().unwrap(); // go sure `wc` is really done
     println!(
         "/etc/passwd has {} lines, {} words, {} chars",
-        String::from_utf8_lossy(&lines[0]),
-        String::from_utf8_lossy(&words[0]),
-        String::from_utf8_lossy(&bytes[0]),
+        lines, words, chars,
     );
 
     // case 3: read while program is still executing
@@ -43,7 +42,7 @@ fn main() {
     use expectrl::AsyncExpect;
     use futures_lite::io::AsyncBufReadExt;
 
-    futures_lite::future::block_on(async {
+    let f = async {
         let mut p = spawn_bash().await.unwrap();
 
         // case 1: wait until program is done
@@ -55,16 +54,18 @@ fn main() {
 
         // case 2: wait until done, only extract a few infos
         p.send_line("wc /etc/passwd").await.unwrap();
-        // `exp_regex` returns both string-before-match and match itself, discard first
-        let lines = p.expect(Regex("[0-9]+")).await.unwrap();
-        let words = p.expect(Regex("[0-9]+")).await.unwrap();
-        let bytes = p.expect(Regex("[0-9]+")).await.unwrap();
+        // `expect` returns both string-before-match and match itself, discard first
+        let found = p
+            .expect(Regex("([0-9]+).*([0-9]+).*([0-9]+)"))
+            .await
+            .unwrap();
+        let lines = String::from_utf8_lossy(&found[1]);
+        let words = String::from_utf8_lossy(&found[2]);
+        let chars = String::from_utf8_lossy(&found[3]);
         p.expect_prompt().await.unwrap(); // go sure `wc` is really done
         println!(
             "/etc/passwd has {} lines, {} words, {} chars",
-            String::from_utf8_lossy(lines.get(0).unwrap()),
-            String::from_utf8_lossy(words.get(0).unwrap()),
-            String::from_utf8_lossy(bytes.get(0).unwrap()),
+            lines, words, chars,
         );
 
         // case 3: read while program is still executing
@@ -79,10 +80,12 @@ fn main() {
         }
 
         p.send(ControlCode::EOT).await.unwrap();
-    })
+    };
+
+    futures_lite::future::block_on(f);
 }
 
 #[cfg(windows)]
 fn main() {
-    panic!("An example doesn't supported on windows")
+    panic!("An example is not supported on windows")
 }

examples/check.rs

@@ -2,10 +2,10 @@ use expectrl::{check, spawn, Error, Expect};
 
 #[cfg(not(feature = "async"))]
 fn main() {
-    let mut p = spawn("python ./tests/source/ansi.py").expect("Can't spawn a session");
+    let mut p = spawn("python ./tests/source/ansi.py").unwrap();
 
     loop {
-        match check!(
+        let result = check! {
             &mut p,
             _ = "Password: " => {
                 println!("Set password to SECURE_PASSWORD");
@@ -15,9 +15,12 @@ fn main() {
                 println!("Stop processing");
                 p.send_line("n").unwrap();
             },
-        ) {
+        };
+
+        match result {
+            Ok(_) => {}
             Err(Error::Eof) => break,
-            result => result.unwrap(),
+            Err(_) => result.unwrap(),
         };
     }
 }
@@ -26,26 +29,30 @@ fn main() {
 fn main() {
     use expectrl::AsyncExpect;
 
-    futures_lite::future::block_on(async {
-        let mut session = spawn("python ./tests/source/ansi.py").expect("Can't spawn a session");
+    let f = async {
+        let mut session = spawn("python ./tests/source/ansi.py").unwrap();
 
         loop {
-            match check!(
-                &mut session,
+            let result = check! {
+                &mut p,
                 _ = "Password: " => {
                     println!("Set password to SECURE_PASSWORD");
-                    session.send_line("SECURE_PASSWORD").await.unwrap();
+                    p.send_line("SECURE_PASSWORD").await.unwrap();
                 },
                 _ = "Continue [y/n]:" => {
                     println!("Stop processing");
-                    session.send_line("n").await.unwrap();
+                    p.send_line("n").await.unwrap();
                 },
-            )
-            .await
-            {
+            }
+            .await;
+
+            match result {
+                Ok(_) => {}
                 Err(Error::Eof) => break,
-                result => result.unwrap(),
+                Err(_) => result.unwrap(),
             };
         }
-    })
+    };
+
+    futures_lite::future::block_on(f);
 }