Merge pull request #26 from code-troopers/fix/18

Fix/18

Author: mattboll

.ctproject

@@ -3,4 +3,8 @@ build="cargo build --release" #build the release binary
 help=cat .ctproject
 dummy=echo "toto is dumb"
 ragdoll=echo 'tata is a ragdoll'
-combine=echo "toto is dumb" && echo "tata is a ragdoll" # no recursive ct invoke for this test sentence
+combine=echo "toto is dumb" && echo "tata is a ragdoll" # no recursive ct invoke for this test sentence
+envvar='CTENV="azerty qsdf";echo $CTENV'
+# comment on line
+front='cd ui; ct run' #debugging #18
+dual="ct help && ct help"

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ct"
-version = "0.1.0"
+version = "0.1.2"
 authors = ["Cedric Gatay <[email protected]>"]
 
 [dependencies]
@@ -18,4 +18,5 @@ serde_json = "1.0"
 rocket = "0.3.11"
 rocket_codegen = "0.3.11"
 linked-hash-map = "0.5.1"
-lazy_static = "1.0"
+lazy_static = "1.0"
+clap = "2.0.0"

src/extract.rs

@@ -1,11 +1,12 @@
-extern crate regex;
 extern crate linked_hash_map;
-use self::regex::Regex;
-use self::linked_hash_map::*;
-use std::process::*;
+extern crate regex;
+
 use cli::Config;
 use file_finder::CTFile;
 use log::debug_log;
+use self::linked_hash_map::*;
+use self::regex::Regex;
+use std::process::*;
 
 #[derive(Debug)]
 pub struct RunCommand {
@@ -15,21 +16,31 @@ pub struct RunCommand {
 }
 
 impl RunCommand{
-    pub fn all<'a>(file_content: &'a str, config: Option<&Config>) -> LinkedHashMap<String, RunCommand>{
-        let regex = Regex::new(r"(?m)^\s*([^=]*)=([^#\n]*)(#\s*(.*)\s*)?$").unwrap();
+    pub fn all<'a>(file_content: &'a str, config: &Option<Config>) -> LinkedHashMap<String, RunCommand>{
+        let regex = Regex::new(r#"(?m)^\s*([^#=]*)=([^#\n]*)(#\s*(.*)\s*)?$"#).unwrap();
         let mut commands: LinkedHashMap<String, RunCommand> = LinkedHashMap::new();
         for capture in regex.captures_iter(file_content){
             let alias = &capture[1];
-            let command_with_args = &capture[2].replace("\"", "").replace("'", "");
+            debug_log(|| format!(" Handling alias : {}", alias) );
+            debug_log(|| format!(" Raw captured command : {}", &capture[2]) );
+            let extracted_command = &capture[2].trim();
+            let chars = extracted_command.chars().collect::<Vec<char>>();
+            let len = chars.len();
+            let command_with_args: &str;
+            if (chars[0] == '\'' || chars[0] == '"') && chars[len - 1] == chars[0] {
+                command_with_args = extracted_command.trim_matches(chars[0]);
+            }else{
+                command_with_args = extracted_command;
+            }
+            debug_log(|| format!(" Cleaned command {}", command_with_args) );
 
             let doc = capture.get(4).map(|m| m.as_str()).map(ToString::to_string).unwrap_or(String::from(""));
+            //this is probably useless since we're running it with sh -c (and probably invalid as first split might not match command if var are exported at beginning of line
             let commands_vec: Vec<_> = command_with_args.split(" ").collect();
             let (command, args) = commands_vec.split_first().unwrap();
 
             let mut args_as_vect: Vec<String> = args.iter().map(|s| s.to_string()).collect();
-            if config.is_some() {
-                args_as_vect.append(&mut config.unwrap().args.clone());
-            }
+            args_as_vect.append(config.as_ref().map(|c| c.args.clone()).unwrap_or(vec![]).as_mut());
             args_as_vect = args_as_vect.into_iter().filter(|a| { a.len() > 0 }).collect();
 
             commands.insert(alias.to_string(), RunCommand{command: command.to_string(), args: args_as_vect, doc});;
@@ -38,19 +49,25 @@ impl RunCommand{
     }
 
     pub fn run(&self, ct_file: &CTFile){
-        let mut sh_sub_command = Vec::new();
-        sh_sub_command.push(self.command.to_string());
-        sh_sub_command.push(String::from(" "));
-        sh_sub_command.push(self.args.join(" ")); // no need to escape "', it is properly handled
-        debug_log(|| format!("About to run `sh -c {:?}`", sh_sub_command.join("")));
+        let sh_sub_command = self.build_subcommand();
+        debug_log(|| format!("About to run `sh -c {:?}`", sh_sub_command));
         let s = Command::new("sh")
+            .env("CTNOBANNER","true")
             .arg("-c")
-            .arg(sh_sub_command.join(""))
+            .arg(sh_sub_command)
             .current_dir(ct_file.path.clone())
             .spawn().unwrap();
         //result printed to stdout / stderr as expected as io are shared
         let _output = s.wait_with_output();
     }
+
+    fn build_subcommand(&self) -> String {
+        let mut sh_sub_command = Vec::new();
+        sh_sub_command.push(self.command.to_string());
+        sh_sub_command.push(String::from(" "));
+        sh_sub_command.push(self.args.join(" ")); // no need to escape "', it is properly handled
+        sh_sub_command.join("")
+    }
 }
 
 #[cfg(test)]
@@ -60,7 +77,7 @@ mod tests{
     #[test]
     fn it_should_extract_single_quoted_command(){
         let config = Config::new(vec!["ct", "command"].into_iter().map(ToString::to_string).collect()).unwrap();
-        let map = RunCommand::all("command='run'", Some(&config));
+        let map = RunCommand::all("command='run'", &Some(config));
         let run_command = map.get("command").unwrap();
         assert_eq!(run_command.command, "run");
         assert_eq!(run_command.args.join(" "), "");
@@ -69,7 +86,7 @@ mod tests{
     #[test]
     fn it_should_extract_double_quoted_command(){
         let config = Config::new(vec!["ct", "command"].into_iter().map(ToString::to_string).collect()).unwrap();
-        let map = RunCommand::all("command=\"run\"", Some(&config));
+        let map = RunCommand::all("command=\"run\"", &Some(config));
         let run_command = map.get("command").unwrap();
         assert_eq!(run_command.command, "run");
         assert_eq!(run_command.args.join(" "), "");
@@ -78,7 +95,7 @@ mod tests{
     #[test]
     fn it_should_extract_not_quoted_command(){
         let config = Config::new(vec!["ct", "command"].into_iter().map(ToString::to_string).collect()).unwrap();
-        let map = RunCommand::all("command=run", Some(&config));
+        let map = RunCommand::all("command=run", &Some(config));
         let run_command = map.get("command").unwrap();
         assert_eq!(run_command.command, "run");
         assert_eq!(run_command.args.join(" "), "");
@@ -87,7 +104,7 @@ mod tests{
     #[test]
     fn it_should_append_args_to_run_command_if_no_args_in_run_command(){
         let config = Config::new(vec!["ct", "command", "arg1", "arg2"].into_iter().map(ToString::to_string).collect()).unwrap();
-        let map = RunCommand::all("command=run", Some(&config));
+        let map = RunCommand::all("command=run", &Some(config));
         let run_command = map.get("command").unwrap();
         assert_eq!(run_command.command, "run");
         assert_eq!(run_command.args.join(" "), "arg1 arg2");
@@ -96,7 +113,7 @@ mod tests{
     #[test]
     fn it_should_append_args_to_run_command_if_args_in_run_command(){
         let config = Config::new(vec!["ct", "command", "arg1", "arg2"].into_iter().map(ToString::to_string).collect()).unwrap();
-        let map = RunCommand::all("command=run tests", Some(&config));
+        let map = RunCommand::all("command=run tests", &Some(config));
         let run_command = map.get("command").unwrap();
         assert_eq!(run_command.command, "run");
         assert_eq!(run_command.args.join(" "), "tests arg1 arg2");
@@ -107,7 +124,7 @@ mod tests{
         let map = RunCommand::all(r"command=run tests
         command2=run app
         command3=push commits
-        ", None);
+        ", &None);
         assert_eq!(map.len(), 3);
         assert_eq!(map.contains_key("command"), true);
         assert_eq!(map.contains_key("command2"), true);
@@ -116,14 +133,14 @@ mod tests{
 
     #[test]
     fn it_should_match_command_with_leading_spaces(){
-        let map = RunCommand::all("   command=run tests", None);
+        let map = RunCommand::all("   command=run tests", &None);
         assert_eq!(map.len(), 1);
         assert_eq!(map.contains_key("command"), true);
     }
 
     #[test]
     fn it_should_match_command_with_doc(){
-        let map = RunCommand::all("command=run tests # this run tests", None);
+        let map = RunCommand::all("command=run tests # this run tests", &None);
         assert_eq!(map.len(), 1);
         let run_command = map.get("command").unwrap();
         assert_eq!(run_command.command, "run");
@@ -134,17 +151,33 @@ mod tests{
 
     #[test]
     fn it_should_match_command_with_leading_tab(){
-        let map = RunCommand::all("\tcommand=run tests", None);
+        let map = RunCommand::all("\tcommand=run tests", &None);
+        assert_eq!(map.len(), 1);
+        assert_eq!(map.contains_key("command"), true);
+    }
+
+    #[test]
+    fn it_should_remove_surrounding_single_quotes(){
+        let map = RunCommand::all("command='run tests'", &None);
+        assert_eq!(map.len(), 1);
+        assert_eq!(map.contains_key("command"), true);
+        assert_eq!(map.get("command").unwrap().command, "run");
+    }
+
+    #[test]
+    fn it_should_keep_quotes_on_exports(){
+        let map = RunCommand::all(r#"command='VAR="toto tutu";run tests'"#, &None);
         assert_eq!(map.len(), 1);
         assert_eq!(map.contains_key("command"), true);
+        assert_eq!(map.get("command").unwrap().build_subcommand(), r#"VAR="toto tutu";run tests"#);
     }
 
 
     #[test]
     #[should_panic]
     fn it_should_error_if_line_does_not_match_pattern(){
         let config = Config::new(vec!["ct", "command"].into_iter().map(ToString::to_string).collect()).unwrap();
-        let map = RunCommand::all("command", Some(&config));
+        let map = RunCommand::all("command", &Some(config));
         let _run_command = map.get("command").unwrap();
     }
 }

src/file_finder.rs

@@ -3,6 +3,7 @@ use std::io::Read;
 use std::env::current_dir;
 use std::path::PathBuf;
 use std::result::Result::Err;
+use log::debug_log;
 
 const FILE_NAME: &str = ".ctproject";
 
@@ -30,7 +31,7 @@ impl CTFile{
         let mut current_dir = current_dir().unwrap();
         let mut file_path = current_dir.join(FILE_NAME);
         while !file_path.exists() && current_dir.pop() {
-            println!("Did not find in {:?}, looking in directory {:?}", file_path, current_dir);
+            debug_log(|| format!("Did not find in {:?}, looking in directory {:?}", file_path, current_dir));
             file_path = current_dir.join(FILE_NAME);
         }
         if !file_path.exists(){
@@ -47,6 +48,5 @@ impl CTFile{
         ctfile.read_to_string(&mut contents)
             .expect("something went wrong reading the file");
         contents
-        //self.line = contents.clone().lines()
     }
 }

src/lib.rs

@@ -1,17 +1,24 @@
 #![feature(plugin, extern_prelude)]
 #![plugin(rocket_codegen)]
+extern crate colored;
+#[macro_use]
+extern crate lazy_static;
 extern crate rocket;
-
-
 #[macro_use]
 extern crate serde_derive;
-#[macro_use]
-extern crate lazy_static;
 
 
-use cli::Config;
+use colored::*;
 use file_finder::CTFile;
+use man::CTMan;
+use ports::CTPorts;
+use rocket::http::ContentType;
+use rocket::response::Content;
 use std::env;
+use std::error::Error;
+use std::fs::File;
+use std::io::Write;
+use std::path::Path;
 
 pub mod cli;
 pub mod extract;
@@ -24,27 +31,57 @@ pub mod banner;
 #[macro_use]
 pub mod ports_html;
 
-use rocket::response::Content;
-use rocket::http::ContentType;
-use ports::CTPorts;
-
-pub fn find_command(config: &Config, ct_file: &CTFile) -> String{
-    println!("{}", ct_file.content);
-    let matching_line: String = ct_file.content.lines()
-        .filter(|line| line.starts_with(&config.command))
-        .last()
-        //build a "fake" command with the one the user tries to execute
-        .map_or(format!("{}={}", &config.command, &config.command), |v| { v.to_string() });
-    matching_line
-}
-
 pub fn show_banner(){
     let show_banner = env::var("CTNOBANNER").unwrap_or("false".to_string());
     if show_banner == "false" {
         println!("{}", BANNER!());
     }
 }
 
+pub fn init_project(){
+    let path = Path::new(".ctproject");
+    let display = path.display();
+
+    // Open a file in write-only mode, returns `io::Result<File>`
+    if path.exists(){
+        println!("⚠️ .ctproject already exists");
+        return;
+    }
+    let mut file = match File::create(&path) {
+        Err(why) => panic!("❌ couldn't create {}: {}",
+                           display,
+                           why.description()),
+        Ok(file) => file,
+    };
+
+    match file.write_all("run='your run command'\nbuild='your build command'\ntest='your test command'".as_bytes()) {
+        Err(why) => {
+            panic!("❌ couldn't write to {}: {}", display,
+                   why.description())
+        },
+        Ok(_) => println!("{} successfully wrote to {}", "✔︎".green(), display),
+    }
+}
+
+
+pub fn start_port_listening() {
+    println!("👂 Started ports web server at http://localhost:1500, CTRL+C to exit...");
+    start_rocket();
+}
+
+pub fn show_man(man_entry: Option<&str>, ct_file: Option<CTFile>) {
+    if let Some(ct_file) = ct_file {
+        if let Some(ct_man) = CTMan::all(&ct_file) {
+            if man_entry.is_some() {
+                if let Some(man) = ct_man.get(man_entry.unwrap()) {
+                    man.print();
+                }
+            } else {
+                ct_man.values().for_each(CTMan::print);
+            }
+        }
+    }
+}
 
 #[get("/scan")]
 fn scan() -> String {