Implement alias/unalias builtin

Cargo.toml

@@ -9,3 +9,9 @@ edition = "2018"
 [dependencies]
 os_pipe = "0.9.2"
 nix = "0.18.0"
+regex = "1.3.9"
+
+[dev-dependencies]
+assert_cmd = "1.0.1"
+escargot = "0.5.0"
+predicates-core = "1.0.0"

README.md

@@ -18,7 +18,7 @@ I know that the name is overused, but it's too good to pass up.
 - [ ] Async execution `&`
 - [ ] Shell builtins
    - [ ] Normal built-ins
-      - [ ] `alias` `unalias`
+      - [x] `alias` `unalias`
       - [X] `cd`
       - [ ] etc
    - [ ] Special built-ins

src/builtins.rs

@@ -1,3 +1,5 @@
+use regex::Regex;
+use std::collections::BTreeMap;
 use std::process::exit as exit_program;
 use std::env;
 use std::rc::Rc;
@@ -7,6 +9,36 @@ use crate::helpers::Shell;
 // Unless specified otherwise, if provided multiple arguments while only
 // accepting one, these use the first argument. Dash does this as well.  
 
+pub fn alias(
+    // Aliases can be added and then printed in the same command
+    aliases: &mut BTreeMap<String, String>,
+    args: Vec<String>,
+) -> bool {
+    if args.is_empty() {
+        for (lhs, rhs) in aliases {
+            println!("alias {}='{}'", lhs, rhs);
+        }
+        true
+    } else {
+        let mut success = true;
+        let assignment_re = Regex::new(r"^(\w+)=(.*)").unwrap();
+        for arg in args {
+            if assignment_re.is_match(&arg) {
+                let caps = assignment_re.captures(&arg).unwrap();
+                let lhs = &caps[1];
+                let rhs = &caps[2];
+                aliases.insert(lhs.to_string(), rhs.to_string());
+            } else if aliases.contains_key(&arg) {
+                println!("alias {}='{}'", arg, aliases[&arg]);
+            } else {
+                eprintln!("rush: alias: {}: not found", arg);
+                success = false;
+            }
+        }
+        success
+    }
+}
+
 pub fn exit(args: Vec<String>) -> bool {
     match args.get(0).map_or(Ok(0), |x| x.parse::<i32>()) {
         Ok(n) => {
@@ -35,3 +67,23 @@ pub fn set(args: Vec<String>, shell: &Rc<RefCell<Shell>>) -> bool {
     true
 }
 
+pub fn unalias(aliases: &mut BTreeMap<String, String>, args: Vec<String>) -> bool {
+    if args.is_empty() {
+        eprintln!("unalias: usage: unalias [-a] name [name ...]");
+        false
+    } else if args[0] == "-a" {
+        aliases.clear();
+        true
+    } else {
+        let mut success = true;
+        for arg in args {
+            if aliases.contains_key(&arg) {
+                aliases.remove(&arg);
+            } else {
+                eprintln!("rush: unalias: {}: not found", arg);
+                success = false;
+            }
+        }
+        success
+    }
+}

src/debug.rs

@@ -0,0 +1,7 @@
+/// Alias of println! but only present in debug builds.
+macro_rules! debug_println {
+    ($($t:tt)*) => {
+        #[cfg(debug_assertions)] // Only include when not built with `--release` flag
+        println!($($t)*);
+    }
+}

src/helpers.rs

@@ -1,6 +1,6 @@
 use nix::unistd::Uid;
 use os_pipe::{dup_stderr, dup_stdin, dup_stdout, PipeReader, PipeWriter};
-use std::collections::HashMap;
+use std::collections::{BTreeMap, HashMap};
 use std::env;
 use std::fs::{self, File, OpenOptions};
 use std::io::{self, BufRead, BufReader, Write};
@@ -38,6 +38,7 @@ pub struct Shell {
     positional: Vec<String>,
     name: String,
     pub vars: HashMap<String, String>,
+    pub aliases: BTreeMap<String, String>,
 }
 
 impl Shell {
@@ -62,6 +63,7 @@ impl Shell {
             positional: Vec::new(),
             name,
             vars: HashMap::new(),
+            aliases: BTreeMap::new(),
         }
     }
 

src/lexer.rs

@@ -360,7 +360,7 @@ impl Lexer {
             }
             Some(_) => match self.read_until(false, false, false, Box::new(is_token_split)) {
                 Ok(w) => {
-                    println!("The words I got: {:?}", w);
+                    debug_println!("The words I got: {:?}", w);
                     match &w[..] {
                         [Literal(s), ..]
                             if s.ends_with('=')

src/lib.rs

@@ -1,3 +1,6 @@
+#[macro_use]
+mod debug;
+
 pub mod lexer;
 pub mod parser;
 pub mod runner;

src/main.rs

@@ -1,3 +1,6 @@
+#[macro_use]
+mod debug;
+
 use rush::lexer::Lexer;
 use rush::parser::Parser;
 use rush::runner::Runner;
@@ -20,8 +23,7 @@ fn main() {
             let mut parser = Parser::new(lexer, Rc::clone(&shell));
             match parser.get() {
                 Ok(command) => {
-                    #[cfg(debug_assertions)] // Only include when not built with `--release` flag
-                    println!("\u{001b}[34m{:#?}\u{001b}[0m", command);
+                    debug_println!("\u{001b}[34m{:#?}\u{001b}[0m", command);
 
                     runner.execute(command, false);
                 }