set up parsing for a REPL inside the CLI

 - using "nom" to make parser combinator methods so I can act like
   a good shell and allow for quoted arguments in case they have spaces
 - started wiring up a "clap" App to handle the commands from STDIN
 - run the app with --repl to try it (but it's not very exciting yet)

Author: dylemma

Cargo.lock

@@ -6,6 +6,7 @@ authors = ["Dylan Halperin <dylan@dylemma.io>"]
 [dependencies]
 chrono = "0.4"
 clap = "2.26.2"
+colored = "1.5.3"
 hyper = "0.11"
 maplit = "0.1.4"
 url = "1.5.1"
@@ -14,4 +15,8 @@ serde_json = "1.0"
 serde_derive = "1.0"
 
 # waiting for https://github.com/seanmonstar/reqwest/pull/190 to be released
-reqwest = { git = "https://github.com/seanmonstar/reqwest", branch = "master"}
+reqwest = { git = "https://github.com/seanmonstar/reqwest", branch = "master"}
+
+[dependencies.nom]
+version = "3.2"
+features = ["verbose-errors"]

Cargo.toml

@@ -29,15 +29,18 @@ impl <'a> ApiProjectFilter<'a> {
             metadata: Some(metadata)
         }
     }
+    #[allow(dead_code)]
     pub fn empty() -> ApiProjectFilter<'static> {
         ApiProjectFilter{ name: None, metadata: None }
     }
+    #[allow(dead_code)]
     pub fn with_name(&self, name: &'a str) -> ApiProjectFilter<'a> {
         ApiProjectFilter {
             name: Some(name),
             metadata: self.metadata.clone()
         }
     }
+    #[allow(dead_code)]
     pub fn with_metadata(&self, metadata: HashMap<&'a str, &'a str>) -> ApiProjectFilter<'a> {
         ApiProjectFilter {
             name: self.name,
@@ -82,6 +85,7 @@ impl JobStatus {
             _ => false
         }
     }
+    #[allow(dead_code)]
     pub fn is_success(&self) -> bool {
         match *self {
             JobStatus::Completed => true,
@@ -358,6 +362,7 @@ pub enum ReqBody {
     None,
 }
 impl ReqBody {
+    #[allow(dead_code)]
     pub fn as_json<T: Serialize>(body: T) -> ReqBody {
         ReqBody::Json(serde_json::to_value(body).unwrap())
     }

src/client.rs

@@ -6,10 +6,13 @@ extern crate url;
 
 #[macro_use] extern crate hyper;
 #[macro_use] extern crate maplit;
+#[macro_use] extern crate nom;
 #[macro_use] extern crate serde_json;
 #[macro_use] extern crate serde_derive;
 
 use chrono::Utc;
+use clap::{Arg, App, AppSettings, SubCommand};
+use std::io;
 use std::path::Path;
 use std::time::Duration;
 
@@ -19,7 +22,109 @@ use config::*;
 mod client;
 use client::*;
 
-fn main() {
+mod repl;
+use repl::CmdArgs;
+
+fn main(){
+    let arg1 = ::std::env::args().nth(1);
+    match arg1 {
+        Some(ref flag) if flag == "--repl" => {
+            println!("repl mode!");
+            run_repl();
+        },
+        _ => {
+            println!("arg was {:?}", arg1);
+            main2();
+        },
+    }
+}
+
+fn run_repl() {
+    loop {
+        // grab a line from STDIN
+        let mut input = String::new();
+        io::stdin().read_line(&mut input)
+            .expect("failed to read line");
+
+        // ignore the trailing \n stuff
+        let line = input.trim();
+
+        if line.is_empty() {
+            continue;
+        } else {
+            if let Ok(args) = line.parse::<CmdArgs>() {
+                let mut args_vec = args.0;
+                args_vec.insert(0, "<placeholder>".to_string());
+
+                let matches = repl_app().get_matches_from_safe(args_vec);
+
+                match matches {
+                    Err(ref e) => {
+                        match e.kind {
+                            clap::ErrorKind::HelpDisplayed => {
+                                repl_app().print_help().unwrap();
+                                println!();
+                            },
+                            clap::ErrorKind::VersionDisplayed => {
+                                repl_app().write_version(&mut io::stdout()).unwrap();
+                                println!();
+                            }
+                            _ => {
+                                e.write_to(&mut io::stdout()).unwrap();
+                                println!();
+                            },
+                        }
+                    },
+                    Ok(arg_matches) => {
+                        if let Some(_) = arg_matches.subcommand_matches("exit") {
+                            break;
+                        }
+
+                        println!("matches: {:?}", arg_matches);
+                    },
+                };
+            }
+        }
+
+    }
+    println!("bye");
+}
+
+/// Get a copy of the "App" for the internal REPL.
+///
+/// Note that since some of the methods we want to use on it will "consume" it,
+/// we need to be able to easily get copies of the whole App for convenience.
+fn repl_app() -> App<'static, 'static> {
+    App::new("My Super Program")
+        .bin_name("")
+        .version("2.6.1")
+        .setting(AppSettings::VersionlessSubcommands)
+        .setting(AppSettings::ColoredHelp)
+        .subcommand(SubCommand::with_name("analyze")
+            .about("Analyze some files")
+            .arg(Arg::with_name("name")
+                .short("n")
+                .long("name")
+                .value_name("NAME")
+                .takes_value(true)
+                .required(false)
+            )
+            .arg(Arg::with_name("file")
+                .short("f")
+                .long("file")
+                .value_name("FILE")
+                .takes_value(true)
+                .multiple(true)
+                .required(true)
+            )
+        )
+        .subcommand(SubCommand::with_name("exit")
+            .alias("quit")
+            .about("Exit this program ('quit' works too)")
+        )
+}
+
+fn main2() {
     match ClientConfig::from_cli_args() {
         Ok(config) => {
             let client = ApiClient::new(Box::new(config));
@@ -88,4 +193,4 @@ fn main() {
 
 fn format_current_datetime() -> String {
     Utc::now().format("%Y-%m-%d %H:%M:%S").to_string()
-}
+}