Rename wait_cmd/wait_fun functions

To wait_cmd_result() and wait_fun_result() functions to make it clearer

Author: tao-guo

README.md

@@ -229,11 +229,11 @@ println!("get result: {}", run_fun!(my_cmd)?);
 `spawn!()` macro executes the whole command as a child process, returning a handle to it. By
 default, stdin, stdout and stderr are inherited from the parent.
 
-To get result, you can call `wait_cmd()` or `wait_fun()` to get CmdResult/FunResult.
+To get result, you can call `wait_cmd_result()` or `wait_fun_result()` to get CmdResult/FunResult.
 
 ```rust
-spawn!(ping -c 10 192.168.0.1)?.wait_cmd()?;
-let output = spawn!(/bin/cat file.txt | sed s/a/b/)?.wait_fun()?;
+spawn!(ping -c 10 192.168.0.1)?.wait_cmd_result()?;
+let output = spawn!(/bin/cat file.txt | sed s/a/b/)?.wait_fun_result()?;
 ```
 
 

macros/src/lib.rs

@@ -173,7 +173,7 @@ pub fn run_fun(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
 ///
 /// let handle = spawn!(ping -c 10 192.168.0.1)?;
 /// // ...
-/// if handle.wait_cmd().is_err() {
+/// if handle.wait_cmd_result().is_err() {
 ///     // ...
 /// }
 /// # Ok::<(), std::io::Error>(())

src/child.rs

@@ -12,8 +12,8 @@ impl CmdChildren {
         Self(children)
     }
 
-    pub fn wait_cmd(&mut self) -> CmdResult {
-        let ret = self.wait_cmd_nolog();
+    pub fn wait_cmd_result(&mut self) -> CmdResult {
+        let ret = self.wait_cmd_result_nolog();
         if let Err(ref err) = ret {
             error!(
                 "Running {} failed, Error: {}",
@@ -24,7 +24,7 @@ impl CmdChildren {
         ret
     }
 
-    pub(crate) fn wait_cmd_nolog(&mut self) -> CmdResult {
+    pub(crate) fn wait_cmd_result_nolog(&mut self) -> CmdResult {
         // wait last process result
         let handle = self.0.pop().unwrap();
         handle.wait(true)?;
@@ -66,8 +66,8 @@ impl CmdChildren {
         }
     }
 
-    pub fn wait_fun(&mut self) -> FunResult {
-        let ret = self.wait_fun_nolog();
+    pub fn wait_fun_result(&mut self) -> FunResult {
+        let ret = self.wait_fun_result_nolog();
         if let Err(ref err) = ret {
             error!(
                 "Running {} failed, Error: {}",
@@ -78,7 +78,7 @@ impl CmdChildren {
         ret
     }
 
-    pub(crate) fn wait_fun_nolog(&mut self) -> FunResult {
+    pub(crate) fn wait_fun_result_nolog(&mut self) -> FunResult {
         // wait last process result
         let handle = self.0.pop().unwrap();
         let wait_last = handle.wait_with_output();

src/lib.rs

@@ -254,12 +254,12 @@
 //! `spawn!()` macro executes the whole command as a child process, returning a handle to it. By
 //! default, stdin, stdout and stderr are inherited from the parent.
 //!
-//! To get result, you can call `wait_cmd()` or `wait_fun()` to get CmdResult/FunResult.
+//! To get result, you can call `wait_cmd_result()` or `wait_fun_result()` to get CmdResult/FunResult.
 //!
 //! ```no_run
 //! # use cmd_lib::spawn;
-//! spawn!(ping -c 10 192.168.0.1)?.wait_cmd()?;
-//! let output = spawn!(/bin/cat file.txt | sed s/a/b/)?.wait_fun()?;
+//! spawn!(ping -c 10 192.168.0.1)?.wait_cmd_result()?;
+//! let output = spawn!(/bin/cat file.txt | sed s/a/b/)?.wait_fun_result()?;
 //! # Ok::<(), std::io::Error>(())
 //! ```
 //!

src/process.rs

@@ -196,11 +196,11 @@ impl Cmds {
     }
 
     fn run_cmd(&mut self, current_dir: &mut String) -> CmdResult {
-        self.spawn(current_dir)?.wait_cmd_nolog()
+        self.spawn(current_dir)?.wait_cmd_result_nolog()
     }
 
     fn run_fun(&mut self, current_dir: &mut String) -> FunResult {
-        self.spawn(current_dir)?.wait_fun_nolog()
+        self.spawn(current_dir)?.wait_fun_result_nolog()
     }
 }