Add argparse 0.2.2 as a dependency

This patch adds the crate rust-argparse [0] in version 0.2.2 as a
dependency, as discussed in issue #4.

[0]  https://github.com/tailhook/rust-argparse

Import subrepo argparse/:argparse at 0de60a5e6d9ee1a3570d6089afd3ccd6ed7480c5

3 files changed, 152 insertions, 0 deletions

diff --git a/argparse/examples/greeting.rs b/argparse/examples/greeting.rs
new file mode 100644
index 0000000..77e719c
--- /dev/null
+++ b/argparse/examples/greeting.rs
@@ -0,0 +1,26 @@
+extern crate argparse;
+
+use argparse::{ArgumentParser, StoreTrue, Store, Print};
+
+fn main() {
+    let mut verbose = false;
+    let mut name = "World".to_string();
+    {
+        let mut ap = ArgumentParser::new();
+        ap.set_description("Greet somebody.");
+        ap.add_option(&["-V", "--version"],
+            Print(env!("CARGO_PKG_VERSION").to_string()), "Show version");
+        ap.refer(&mut verbose)
+            .add_option(&["-v", "--verbose"], StoreTrue,
+            "Be verbose");
+        ap.refer(&mut name)
+            .add_option(&["--name"], Store,
+            "Name for the greeting");
+        ap.parse_args_or_exit();
+    }
+
+    if verbose {
+        println!("name is {}", name);
+    }
+    println!("Hello {}!", name);
+}
diff --git a/argparse/examples/structure.rs b/argparse/examples/structure.rs
new file mode 100644
index 0000000..59b9345
--- /dev/null
+++ b/argparse/examples/structure.rs
@@ -0,0 +1,38 @@
+extern crate argparse;
+
+use std::process::exit;
+
+use argparse::{ArgumentParser, StoreTrue, Store};
+
+struct Options {
+    verbose: bool,
+    name: String,
+}
+
+fn main() {
+    let mut options = Options {
+        verbose: false,
+        name: "World".to_string(),
+    };
+    {
+        let mut ap = ArgumentParser::new();
+        ap.set_description("Greet somebody.");
+        ap.refer(&mut options.verbose)
+            .add_option(&["-v", "--verbose"], StoreTrue,
+            "Be verbose");
+        ap.refer(&mut options.name)
+            .add_option(&["--name"], Store,
+            "Name for the greeting");
+        match ap.parse_args() {
+            Ok(()) => {}
+            Err(x) => {
+                exit(x);
+            }
+        }
+    }
+
+    if options.verbose {
+        println!("name is {}", options.name);
+    }
+    println!("Hello {}!", options.name);
+}
diff --git a/argparse/examples/subcommands.rs b/argparse/examples/subcommands.rs
new file mode 100644
index 0000000..8fb061a
--- /dev/null
+++ b/argparse/examples/subcommands.rs
@@ -0,0 +1,88 @@
+use std::str::FromStr;
+use std::io::{stdout, stderr};
+extern crate argparse;
+
+use argparse::{ArgumentParser, StoreTrue, Store, List};
+
+#[allow(non_camel_case_types)]
+#[derive(Debug)]
+enum Command {
+    play,
+    record,
+}
+
+impl FromStr for Command {
+    type Err = ();
+    fn from_str(src: &str) -> Result<Command, ()> {
+        return match src {
+            "play" => Ok(Command::play),
+            "record" => Ok(Command::record),
+            _ => Err(()),
+        };
+    }
+}
+
+
+
+fn play_command(verbose: bool, args: Vec<String>) {
+    let mut output = "".to_string();
+    {
+        let mut ap = ArgumentParser::new();
+        ap.set_description("Plays a sound");
+        ap.refer(&mut output)
+            .add_option(&["--output"], Store,
+                r#"Output sink to play to"#);
+        match ap.parse(args, &mut stdout(), &mut stderr()) {
+            Ok(()) =>  {}
+            Err(x) => {
+                std::process::exit(x);
+            }
+        }
+    }
+    println!("Verbosity: {}, Output: {}", verbose, output);
+}
+
+fn record_command(verbose: bool, args: Vec<String>) {
+    let mut input = "".to_string();
+    {
+        let mut ap = ArgumentParser::new();
+        ap.set_description("Records a sound");
+        ap.refer(&mut input)
+            .add_option(&["--input"], Store,
+                r#"Output source to record from"#);
+        match ap.parse(args, &mut stdout(), &mut stderr()) {
+            Ok(()) =>  {}
+            Err(x) => {
+                std::process::exit(x);
+            }
+        }
+    }
+    println!("Verbosity: {}, Input: {}", verbose, input);
+}
+
+fn main() {
+    let mut verbose = false;
+    let mut subcommand = Command::play;
+    let mut args = vec!();
+    {
+        let mut ap = ArgumentParser::new();
+        ap.set_description("Plays or records sound");
+        ap.refer(&mut verbose)
+            .add_option(&["-v", "--verbose"], StoreTrue,
+            "Be verbose");
+        ap.refer(&mut subcommand).required()
+            .add_argument("command", Store,
+                r#"Command to run (either "play" or "record")"#);
+        ap.refer(&mut args)
+            .add_argument("arguments", List,
+                r#"Arguments for command"#);
+        ap.stop_on_first_argument(true);
+        ap.parse_args_or_exit();
+    }
+
+    args.insert(0, format!("subcommand {:?}", subcommand));
+    match subcommand {
+        Command::play => play_command(verbose, args),
+        Command::record => record_command(verbose, args),
+    }
+}