Merge pull request #2 from dustinknopoff/development

Dustin Knopoff · web-flow · commit e5b926d660cf · 2018-11-06T10:59:42.000-05:00
Development
diff --git a/cli.yml b/cli.yml
@@ -18,6 +18,11 @@ args:
       short: j
       takes_value: true
       value_name: FILE
+  - override:
+      help: override delimiters for this call.
+      short: o
+      long: override
+      takes_value: true
 author: "Dustin Knopoff <dustinknopoff@gmail.com>"
 name: bashdoc
 version: "1.0"
diff --git a/src/doc_structure.rs b/src/doc_structure.rs
@@ -42,21 +42,20 @@ pub mod docs {
     impl Doc {
         /// # Build a `Doc` from an array of strings
         /// Parse `Doc` fields.
-        pub fn make_doc(vector: &[String]) -> Doc {
-            let delims: Delimiters = get_delims();
+        pub fn make_doc(vector: &[String], delims: Delimiters) -> Doc {
             let mut result: Doc = Default::default();
             for line in vector.iter() {
                 if line == &vector[0] {
                     result.short_description.push_str(line);
-                } else if line.contains(delims.params.as_str()) {
+                } else if line.contains(delims.params) {
                     let splitted: Vec<_> = line.split_whitespace().map(|x| x.to_string()).collect();
                     let rest: String = splitted[2..].join(" ");
                     result.params.insert(splitted[1].replace(":", ""), rest);
-                } else if line.contains(delims.ret.as_str()) {
+                } else if line.contains(delims.ret) {
                     let splitted: Vec<_> = line.split_whitespace().map(|x| x.to_string()).collect();
                     let rest: String = splitted[2..].join(" ");
                     result.returns.insert(splitted[1].replace(":", ""), rest);
-                } else if line.contains(delims.opt.as_str()) {
+                } else if line.contains(delims.opt) {
                     let splitted: Vec<_> = line.split_whitespace().map(|x| x.to_string()).collect();
                     let rest: String = splitted[3..].join(" ");
                     result
@@ -91,10 +90,9 @@ pub mod docs {
     /// and adds every line to a `Vec` until the end delimiter.
     ///
     /// A final `Vec` of the collected comment strings is returned.
-    fn get_info(p: &Path) -> Vec<Vec<String>> {
+    fn get_info(p: &Path, delims: Delimiters) -> Vec<Vec<String>> {
         // let mut p = dirs::home_dir().unwrap();
         // p.push(".zshrc");
-        let delims: Delimiters = get_delims();
         let f = File::open(&p).expect("file not found.");
         let f = BufReader::new(f);
         let mut result: Vec<Vec<String>> = Vec::new();
@@ -103,54 +101,55 @@ pub mod docs {
         let mut index = 0;
         for line in f.lines() {
             let curr_line = line.expect("Line cannot be accessed.");
-            if curr_line.contains(delims.start.as_str()) {
+            if curr_line.contains(delims.start) {
                 can_add = true;
                 continue;
-            } else if curr_line.contains(delims.end.as_str()) {
+            } else if curr_line.contains(delims.end) {
                 can_add = false;
                 index += 1;
                 result.push(Vec::new());
             }
             if can_add {
-                if curr_line.contains(delims.opt.as_str()) {
+                if curr_line.contains(delims.opt) {
                     result[index].push(curr_line);
                 } else {
-                    result[index].push(curr_line.replace(delims.comm.as_str(), ""));
+                    result[index].push(curr_line.replace(delims.comm, ""));
                 }
             }
         }
         result
     }
 
-    fn generate_doc_file(docs: &[Vec<String>], fname: String) -> DocFile {
+    fn generate_doc_file(docs: &[Vec<String>], fname: String, delims: Delimiters) -> DocFile {
         let mut all_docs: DocFile = Default::default();
         all_docs.filename = fname;
         for doc in docs.iter() {
             if doc.to_vec().is_empty() {
                 continue;
             }
-            let as_bash_doc = Doc::make_doc(&doc.to_vec());
+            let as_bash_doc = Doc::make_doc(&doc.to_vec(), delims);
             all_docs.add(as_bash_doc);
         }
         all_docs
     }
 
-    pub fn start(p: &str, is_directory: bool) -> Vec<DocFile> {
+    pub fn start(p: &str, is_directory: bool, delims: Delimiters) -> Vec<DocFile> {
         let dir = p.replace("~", home_dir().unwrap().to_str().unwrap());
         if is_directory {
             let files: Vec<_> = glob(&dir).unwrap().filter_map(|x| x.ok()).collect();
             let every_doc: Vec<DocFile> = files
                 .par_iter()
                 .map(|entry| {
-                    let docs = get_info(&entry);
+                    let docs = get_info(&entry, delims);
                     generate_doc_file(
                         &docs,
                         entry.file_name().unwrap().to_str().unwrap().to_string(),
+                        delims,
                     )
                 }).collect();
             every_doc
         } else {
-            let docs = get_info(&Path::new(&p));
+            let docs = get_info(&Path::new(&p), delims);
             let all_docs = generate_doc_file(
                 &docs,
                 Path::new(&dir)
@@ -159,6 +158,7 @@ pub mod docs {
                     .to_str()
                     .unwrap()
                     .to_string(),
+                delims,
             );
             let result = vec![all_docs];
             result
@@ -251,50 +251,70 @@ pub mod docs {
             .expect("Could not write to file.");
     }
 
-    #[derive(Debug, Serialize, Deserialize)]
-    struct Delimiters {
-        start: String,
-        end: String,
-        params: String,
-        ret: String,
-        opt: String,
-        comm: String,
+    #[derive(Debug, Serialize, Deserialize, Copy, Clone)]
+    pub struct Delimiters<'a> {
+        start: &'a str,
+        end: &'a str,
+        params: &'a str,
+        ret: &'a str,
+        opt: &'a str,
+        comm: &'a str,
     }
 
-    impl Default for Delimiters {
-        fn default() -> Delimiters {
+    impl<'a> Default for Delimiters<'a> {
+        fn default() -> Delimiters<'a> {
             Delimiters {
-                start: "#;".to_string(),
-                end: "#\"".to_string(),
-                params: "@param".to_string(),
-                ret: "@return".to_string(),
-                opt: "# -".to_string(),
-                comm: "# ".to_string(),
+                start: "#;",
+                end: "#\"",
+                params: "@param",
+                ret: "@return",
+                opt: "# -",
+                comm: "# ",
             }
         }
     }
 
-    fn get_delims() -> Delimiters {
-        let mut contents = String::new();
-        match env::var_os("BASHDOC_CONFIG_PATH") {
-            Some(val) => {
-                let mut config = File::open(Path::new(&val)).expect("Invalid path");
-                config
-                    .read_to_string(&mut contents)
-                    .expect("could not read from file.");
-                let mut to_convert = String::new();
-                to_convert.push_str(&contents);
-                let sorted: Delimiters = toml::from_str(&to_convert.as_str()).unwrap();
-                sorted
+    impl<'a> Delimiters<'a> {
+        pub fn override_delims(overrides: String) -> Self {
+            let mut result: Delimiters = Delimiters::default();
+            let splitted: Vec<_> = Box::leak(overrides.into_boxed_str())
+                .split_whitespace()
+                .collect();
+            if splitted.len() != 6 {
+                panic!("Please enter the proper number of delimiters");
             }
-            None => {
-                let mut delimiters = Delimiters::default();
-                let content =
-                    toml::to_string_pretty(&delimiters).expect("Could not be converted to TOML");
-                let mut path = home_dir().unwrap();
-                path.push(".bashdocrc");
-                fs::write(path.to_str().unwrap(), content).unwrap();
-                delimiters
+            result.start = &splitted[0];
+            result.end = &splitted[1];
+            result.params = &splitted[2];
+            result.ret = &splitted[3];
+            result.opt = &splitted[4];
+            result.comm = &splitted[5];
+            result
+        }
+
+        pub fn get_delims() -> Self {
+            let mut contents = String::new();
+            match env::var_os("BASHDOC_CONFIG_PATH") {
+                Some(val) => {
+                    let mut config = File::open(Path::new(&val)).expect("Invalid path");
+                    config
+                        .read_to_string(&mut contents)
+                        .expect("could not read from file.");
+                    let mut to_convert = String::new();
+                    to_convert.push_str(&contents);
+                    let mut as_static: &'static str = Box::leak(to_convert.into_boxed_str());
+                    let sorted: Delimiters = toml::from_str(&as_static).unwrap();
+                    sorted
+                }
+                None => {
+                    let mut delimiters = Delimiters::default();
+                    let content = toml::to_string_pretty(&delimiters)
+                        .expect("Could not be converted to TOML");
+                    let mut path = home_dir().unwrap();
+                    path.push(".bashdocrc");
+                    fs::write(path.to_str().unwrap(), content).unwrap();
+                    delimiters
+                }
             }
         }
     }
@@ -324,7 +344,7 @@ pub mod docs {
                 "@params location: where to put it".to_string(),
                 "@returns nothing:".to_string(),
             ];
-            let result = Doc::make_doc(&input);
+            let result = Doc::make_doc(&input, Delimiters::get_delims());
             let mut expected = Doc::default();
             expected.short_description = "runner()".to_string();
             expected.long_description = "This is the beginning".to_string();
@@ -368,7 +388,7 @@ pub mod docs {
         #[test]
         fn test_get_info() {
             let p = Path::new("example.sh");
-            let result = get_info(&p);
+            let result = get_info(&p, Delimiters::get_delims());
             let expected: Vec<Vec<String>> = vec![
                 [
                     "runner()".to_string(),
diff --git a/src/main.rs b/src/main.rs
@@ -59,13 +59,23 @@ use doc_structure::docs::*;
 fn main() {
     let yaml = load_yaml!("../cli.yml");
     let matches = App::from_yaml(yaml).get_matches();
+    let delims = if matches.is_present("override") {
+        Delimiters::override_delims(matches.value_of("override").unwrap().to_string())
+    } else {
+        Delimiters::get_delims()
+    };
     let all_em = if matches.is_present("directory") {
         start(
             matches.value_of("INPUT").expect("directory glob not found"),
             true,
+            delims,
         )
     } else {
-        start(matches.value_of("INPUT").expect("no file found."), false)
+        start(
+            matches.value_of("INPUT").expect("no file found."),
+            false,
+            delims,
+        )
     };
     if matches.is_present("json") {
         to_json(&all_em, matches.value_of("json").unwrap());
