imp(Completions): completions now include aliases to subcommands, including all subcommand options

Aliases to subcommands can now be completed just like the original subcommand they alias.

Imagine a subcommand `update` with alias `install`, the `update` subcommand has an option `--pkg`
which accepts a package to update/install.

The following completion would happen:

```
$ prog <tab><tab>
-h --help -V --version install update

$ prog install <tab><tab>
-h --help -V --version --pkg

$ prog install --pkg <tab><tab>
$ prog install --pkg <PACKAGE>

$ prog update <tab><tab>
-h --help -V --version --pkg

$ prog update --pkg <tab><tab>
$ prog update --pkg <PACKAGE>
```

Closes #556

Author: kbknapp

src/completions.rs

@@ -97,9 +97,7 @@ complete -F _{name} {name}
 
     fn all_subcommands(&self) -> String {
         let mut subcmds = String::new();
-        let mut scs = get_all_subcommands(self.p);
-        scs.sort();
-        scs.dedup();
+        let scs = get_all_subcommands(self.p);
 
         for sc in &scs {
             subcmds = format!(
@@ -153,7 +151,14 @@ complete -F _{name} {name}
         let mut p = self.p;
         for sc in path.split("_").skip(1) {
             debugln!("iter;sc={}", sc);
-            p = &p.subcommands.iter().filter(|s| s.p.meta.name == sc).next().unwrap().p;
+            p = &p.subcommands.iter()
+                              .filter(|s| s.p.meta.name == sc
+                                  || (s.p.meta.aliases.is_some() && s.p.meta.aliases.as_ref()
+                                                                                    .unwrap()
+                                                                                    .iter()
+                                                                                    .any(|&(n,_)| n==sc )))
+                              .next()
+                              .unwrap().p;
         }
         let mut opts = p.short_list.iter().fold(String::new(), |acc, s| format!("{} -{}", acc, s));
         opts = format!("{} {}", opts, p.long_list.iter()
@@ -162,14 +167,19 @@ complete -F _{name} {name}
                                                    .fold(String::new(), |acc, p| format!("{} {}", acc, p)));
         opts = format!("{} {}", opts, p.subcommands.iter()
                                                    .fold(String::new(), |acc, s| format!("{} {}", acc, s.p.meta.name)));
+        for sc in &p.subcommands {
+            if let Some(ref aliases) = sc.p.meta.aliases {
+                opts = format!("{} {}", opts, aliases.iter().map(|&(n,_)| n).fold(String::new(), |acc, a| format!("{} {}", acc, a)));
+            }
+        }
         opts
     }
 
     fn option_details_for_path(&self, path: &str) -> String {
         let mut p = self.p;
         for sc in path.split("_").skip(1) {
             debugln!("iter;sc={}", sc);
-            p = &p.subcommands.iter().filter(|s| s.p.meta.name == sc).next().unwrap().p;
+            p = &p.subcommands.iter().filter(|s| s.p.meta.name == sc || (s.p.meta.aliases.is_some() && s.p.meta.aliases.as_ref().unwrap().iter().any(|&(n,_)| n==sc ))).next().unwrap().p;
         }
         let mut opts = String::new();
         for o in &p.opts {
@@ -195,31 +205,55 @@ complete -F _{name} {name}
 pub fn get_all_subcommands(p: &Parser) -> Vec<String> {
     let mut subcmds = vec![];
     if !p.has_subcommands() {
-        return vec![p.meta.name.clone()]
+        let mut ret = vec![p.meta.name.clone()];
+        if let Some(ref aliases) = p.meta.aliases {
+            for &(n, _) in aliases {
+                ret.push(n.to_owned());
+            }
+        }
+        return ret;
     }
-    for sc in p.subcommands.iter().map(|ref s| s.p.meta.name.clone()) {
-        subcmds.push(sc);
+    for sc in &p.subcommands {
+        if let Some(ref aliases) = sc.p.meta.aliases {
+            for &(n, _) in aliases {
+                subcmds.push(n.to_owned());
+            }
+        }
+        subcmds.push(sc.p.meta.name.clone());
     }
     for sc_v in p.subcommands.iter().map(|ref s| get_all_subcommands(&s.p)) {
         subcmds.extend(sc_v);
     }
+    subcmds.sort();
+    subcmds.dedup();
     subcmds
 }
 
 pub fn get_all_subcommand_paths(p: &Parser, first: bool) -> Vec<String> {
     let mut subcmds = vec![];
     if !p.has_subcommands() {
         if !first {
-            return vec![p.meta.bin_name.as_ref().unwrap().clone().replace(" ", "_")]
+            let name = &*p.meta.name;
+            let path = p.meta.bin_name.as_ref().unwrap().clone().replace(" ", "_");
+            let mut ret = vec![path.clone()];
+            if let Some(ref aliases) = p.meta.aliases {
+                for &(n, _) in aliases {
+                    ret.push(path.replace(name, n));
+                }
+            }
+            return ret;
         }
         return vec![];
     }
-    for sc in p.subcommands.iter()
-                           .map(|ref s| s.p.meta.bin_name.as_ref()
-                                                         .unwrap()
-                                                         .clone()
-                                                         .replace(" ", "_")) {
-        subcmds.push(sc);
+    for sc in &p.subcommands {
+        let name = &*sc.p.meta.name;
+        let path = sc.p.meta.bin_name.as_ref().unwrap().clone().replace(" ", "_");
+        subcmds.push(path.clone());
+        if let Some(ref aliases) = sc.p.meta.aliases {
+            for &(n, _) in aliases {
+                subcmds.push(path.replace(name, n));
+            }
+        }
     }
     for sc_v in p.subcommands.iter().map(|ref s| get_all_subcommand_paths(&s.p, false)) {
         subcmds.extend(sc_v);