Support builtin commands: pwd, cd, lcd

Author: tao-guo

Cargo.toml

@@ -8,7 +8,7 @@ documentation = "https://docs.rs/cmd_lib"
 keywords = ["shell", "scripts", "commandline", "subprocess", "pipeline"]
 categories = ["command-line-interface", "command-line-utilities"]
 readme = "README.md"
-version = "0.7.5"
+version = "0.7.7"
 authors = ["rust-shell-script <rust-shell-script@gmail.com>"]
 edition = "2018"
 

README.md

@@ -57,18 +57,36 @@ Process::new("ls")
     .wait::<CmdResult>()?;
 ```
 
-## Run commands with different environment settings
+## Builtin commands
+### pwd
+pwd: print current working directory
+
+### cd
+cd: set procecess current directory
+
 ```rust
-Env::new()
-    .cd("/src/rust-shell-script/")
-    .exec("du -ah")
-    .pipe("sort -hr")
-    .pipe("head -n 5")
-    .wait::<CmdResult>()?;
+run_cmd! {
+    cd /tmp
+    ls | wc -l
+};
+run_cmd!("pwd");
+```
 
-let res = Env::new().cd("/home").exec("ls").wait::<FunResult>()?;
+output will be "/tmp"
+
+### lcd
+lcd: set group commands current directory
+
+```rust
+run_cmd! {
+    lcd /tmp
+    ls | wc -l
+};
+run_cmd!("pwd");
 ```
 
+output will be the old current directory
+
 ## Easy Reporting
 ```rust
 info!("Running command xxx ...");
@@ -90,9 +108,12 @@ FATAL: Command exit unexpectedly: disk is full
 use cmd_lib::{info, warn, output, run_cmd, run_fun, CmdResult, FunResult};
 
 fn foo() -> CmdResult {
-    let f = "/var/tmp/nofile";
-    run_cmd!{
-        use f;
+    let dir = "/var/tmp";
+    let f = "nofile";
+
+    run_cmd! {
+        use dir, f;
+        cd ${dir};
         sleep 3;
         ls ${f};
     }
@@ -130,14 +151,13 @@ INFO: Running "echo hello, rust" ...
 hello, rust
 INFO: Running "du -ah . | sort -hr | head -n 5" ...
 INFO: Top 5 directories:
-362M    .
-360M    ./target
-216M    ./target/debug
-131M    ./target/debug/incremental
-117M    ./target/package
+24K .
+16K ./lib.rs
+4.0K    ./main.rs
+INFO: Set process current_dir: "/var/tmp"
 INFO: Running "sleep 3" ...
-INFO: Running "ls "/var/tmp/nofile"" ...
-ls: cannot access '/var/tmp/nofile': No such file or directory
+INFO: Running "ls nofile" ...
+ls: cannot access 'nofile': No such file or directory
 WARN: Failed to run foo()
 INFO: Running "date +%Y" ...
 INFO: You are in year 2019

src/lib.rs

@@ -204,43 +204,6 @@ macro_rules! run_cmd {
     }};
 }
 
-/// Envrionment settings
-pub struct Env {
-    current_dir: String,
-    variables: HashMap<String, String>,
-}
-
-impl Env {
-    pub fn new() -> Self {
-        Self {
-            current_dir: ".".to_string(),
-            variables: HashMap::new(),
-        }
-    }
-
-    pub fn cd(&mut self, dir: &str) -> &Self {
-        self.current_dir = dir.to_string();
-        self
-    }
-
-    pub fn pwd(&self) -> &str {
-        &self.current_dir
-    }
-
-    pub fn set(&mut self, key: String, val: String) -> &Self {
-        self.variables.insert(key, val);
-        self
-    }
-
-    pub fn get(&mut self, key: &str) -> Option<&String> {
-        self.variables.get(key)
-    }
-
-    pub fn exec(&self, cmd: &str) -> Process {
-        Process::new_with_env(self, cmd)
-    }
-}
-
 #[doc(hidden)]
 pub trait ProcessResult {
     fn get_result(process: &mut Process) -> Self;
@@ -257,30 +220,22 @@ pub trait ProcessResult {
 ///     .wait::<CmdResult>()?
 /// ```
 ///
-pub struct Process<'a> {
-    env: Option<&'a Env>,
+pub struct Process {
     cur_dir: Option<String>,
     full_cmd: Vec<Vec<String>>,
 }
 
-impl<'a> Process<'a> {
+impl Process {
     pub fn new<S: Borrow<str>>(pipe_cmd: S) -> Self {
         let args = parse_args(pipe_cmd.borrow());
         let argv = parse_argv(args);
 
         Self {
-            env: None,
             cur_dir: None,
             full_cmd: vec![argv],
         }
     }
 
-    fn new_with_env(env: &'a Env, cmd: &str) -> Self {
-        let mut p = Process::new(cmd);
-        p.env = Some(env);
-        p
-    }
-
     pub fn current_dir<S: Borrow<str>>(&mut self, dir: S) -> &mut Self {
         self.cur_dir = Some(dir.borrow().to_string());
         self
@@ -335,18 +290,14 @@ fn format_full_cmd(full_cmd: &Vec<Vec<String>>) -> String {
 fn run_full_cmd(process: &mut Process, pipe_last: bool) -> Result<(Child, String)> {
     let mut full_cmd_str = format_full_cmd(&process.full_cmd);
     let first_cmd = &process.full_cmd[0];
-    let cur_dir = if let Some(dir) = &process.cur_dir {
+    let mut cmd = Command::new(&first_cmd[0]);
+    if let Some(dir) = &process.cur_dir {
         full_cmd_str += &format!(" (cd: {})", dir);
-        dir
-    } else if let Some(env) = process.env {
-        full_cmd_str += &format!(" (cd: {})", env.current_dir);
-        &env.current_dir
-    } else {
-        "."
-    };
+        cmd.current_dir(dir);
+    }
     info!("Running \"{}\" ...", full_cmd_str);
-    let mut last_proc = Command::new(&first_cmd[0])
-        .current_dir(cur_dir)
+
+    let mut last_proc = cmd
         .args(&first_cmd[1..])
         .stdout(if pipe_last || process.full_cmd.len() > 1 {
             Stdio::piped()
@@ -370,11 +321,39 @@ fn run_full_cmd(process: &mut Process, pipe_last: bool) -> Result<(Child, String
     Ok((last_proc, full_cmd_str))
 }
 
-fn run_pipe_cmd(full_command: &str) -> CmdResult {
+fn run_pipe_cmd(full_command: &str, cd_opt: &mut Option<String>) -> CmdResult {
     let pipe_args = parse_pipes(full_command.trim());
     let pipe_argv = parse_argv(pipe_args);
 
+    let mut pipe_iter =  pipe_argv[0].split_whitespace();
+    let cmd = pipe_iter.next().unwrap();
+    if cmd == "cd" || cmd == "lcd" {
+        let dir = pipe_iter.next().unwrap().trim_matches('"');
+        if pipe_iter.next() != None {
+            let err = Error::new(ErrorKind::Other,
+            format!("{} format wrong: {}", cmd, full_command));
+            return Err(err);
+        } else {
+            if cmd == "cd" {
+                info!("Set env current_dir: \"{}\"", dir);
+                return std::env::set_current_dir(dir);
+            } else {
+                info!("Set local current_dir: \"{}\"", dir);
+                *cd_opt = Some(dir.into());
+                return Ok(());
+            }
+        }
+    } else if cmd == "pwd" {
+        let pwd = std::env::current_dir()?;
+        info!("Running \"pwd\" ...");
+        println!("{}", pwd.display());
+        return Ok(());
+    }
+
     let mut last_proc = Process::new(pipe_argv[0].clone());
+    if let Some(dir) = cd_opt {
+        last_proc.current_dir(dir.clone());
+    }
     for pipe_cmd in pipe_argv.iter().skip(1) {
         last_proc.pipe(pipe_cmd.clone());
     }
@@ -386,6 +365,13 @@ fn run_pipe_fun(full_command: &str) -> FunResult {
     let pipe_args = parse_pipes(full_command.trim());
     let pipe_argv = parse_argv(pipe_args);
 
+    let mut pipe_iter =  pipe_argv[0].split_whitespace();
+    let cmd = pipe_iter.next().unwrap();
+    if cmd == "pwd" {
+        let pwd = std::env::current_dir()?;
+        return Ok(format!("{}", pwd.display()));
+    }
+
     let mut last_proc = Process::new(pipe_argv[0].clone());
     for pipe_cmd in pipe_argv.iter().skip(1) {
         last_proc.pipe(pipe_cmd.clone());
@@ -403,8 +389,9 @@ pub fn run_fun(cmds: &str) -> FunResult {
 pub fn run_cmd(cmds: &str) -> CmdResult {
     let cmd_args = parse_cmds(cmds);
     let cmd_argv = parse_argv(cmd_args);
+    let mut cd_opt: Option<String> = None;
     for cmd in cmd_argv {
-        if let Err(e) = run_pipe_cmd(&cmd) {
+        if let Err(e) = run_pipe_cmd(&cmd, &mut cd_opt) {
             return Err(e);
         }
     }