Merge pull request #3 from EduardoLR10/rewrite-parser

Rewrite parser

Author: EduardoLR10

src/cli.rs

@@ -14,5 +14,4 @@ pub enum RodoCommands {
     Catalog { opt_filepath: Option<String> },
     /// List all the TODOs in a given folder. The default value is the current directory.
     List { opt_filepath: Option<String> },
-    
 }

src/commands/list.rs

@@ -1,47 +1,39 @@
-use crate::commands::parser;
 extern crate walkdir;
-use walkdir::{DirEntry, WalkDir};
 use std::fs::File;
-use std::io::{ self, BufRead};
+use std::io::{self, Read};
 use std::str;
+use walkdir::{DirEntry, WalkDir};
+
+use super::parser::{parse_file, Todo};
 
 fn is_hidden(entry: &DirEntry) -> bool {
-    entry.file_name()
-         .to_str()
-         .map(|s| s.starts_with('.'))
-         .unwrap_or(false)
+    entry
+        .file_name()
+        .to_str()
+        .map(|s| s.starts_with('.'))
+        .unwrap_or(false)
 }
 
-pub fn list_path(directory_path: &str) -> Result<Vec<String>, ()> {
-  let mut todos = Vec::new();
-  for file_path in WalkDir::new(directory_path).into_iter().filter_entry(|e| !is_hidden(e)).filter_map(|file| file.ok()) {
-      if file_path.metadata().unwrap().is_file() {
-	  let file = File::open(file_path.path()).unwrap();
-	  let mut file_buffer = io::BufReader::new(file);
-	  let mut content_buffer = String::new();
-	  loop {
-	      match file_buffer.read_line(&mut content_buffer) {
-		  Ok(0) => break,
-		  Ok(_) => {
-		      content_buffer.pop(); // This is to remove the new line at the end
-		      match parser::todo()(content_buffer.as_str().as_bytes()) {
-			  Ok(x) => {
-			      match str::from_utf8(x.1) {
-				  Ok(v) => {				      
-				      todos.push(v.to_string());
-				  },
-				  Err(_e) => (),
-			      };
-			  },
-			  Err(_e) => ()
-		      }
-		      content_buffer.clear();
-		  },
-		 Err(_) => ()
-	      }
-	  }
-	  // println!("Parsed TODOs from file {:?}", file_path.path().display());
-      }
-  }
-  Ok(todos)
+pub fn list_path_todos(directory_path: &str) -> Vec<Todo> {
+    let mut todos = Vec::new();
+
+    // recursively enumerate files
+    for file_path in WalkDir::new(directory_path)
+        .into_iter()
+        .filter_entry(|e| !is_hidden(e))
+        .filter_map(|file| file.ok())
+    {
+        let file = File::open(file_path.path()).unwrap();
+        let mut file_buffer = io::BufReader::new(file);
+        let mut content_buffer = String::new();
+
+        // file doesn't contain valid string (binary file): skip
+        file_buffer.read_to_string(&mut content_buffer).ok();
+
+        // look for todos in file
+        let mut file_todos = parse_file(content_buffer.as_str());
+
+        todos.append(&mut file_todos)
+    }
+    todos
 }

src/commands/parser.rs

@@ -1,9 +1,206 @@
-use nom::{*, bytes::complete::{take_until, take_till}, character::{is_newline}, error::*, sequence::*};
+use nom::{
+    bytes::complete::{tag, take_until},
+    character::complete::{newline, not_line_ending},
+    combinator::opt,
+    multi::many0,
+    *,
+};
 
-pub fn todo() -> impl Fn(&[u8]) -> IResult<&[u8], &[u8], Error<&[u8]>> {
-    move |i: &[u8]| {
-	let header = take_until("TODO:");
-	let content = take_till(is_newline);
-	preceded(header, content)(i)
+// TODO: change String to &str in the Todo type \
+// Making this will break the list_todos_path() function because of ownership of
+// the file contents.
+#[derive(Debug, PartialEq, Clone)]
+pub struct Todo {
+    pub tag: String,
+    pub text: String,
+}
+
+fn parse_todo<'a>(todo_tag: &'a str, input: &'a str) -> IResult<&'a str, Todo> {
+    // remove everything prior to the tag
+    let (input, _) = take_until(todo_tag)(input)?;
+
+    let (input, _) = tag(todo_tag)(input)?;
+    let (input, text) = not_line_ending(input)?;
+
+    // discard optional line ending
+    let (input, _) = opt(newline)(input)?;
+
+    Ok((
+        input,
+        Todo {
+            tag: todo_tag.to_owned(),
+            text: text.to_owned(),
+        },
+    ))
+}
+
+fn parse_todos(file_content: &str) -> IResult<&str, Vec<Todo>> {
+    let line_parser = |file_content| parse_todo("TODO:", file_content);
+    let (input, todos) = many0(line_parser)(file_content)?;
+    Ok((input, todos))
+}
+
+pub fn parse_file(file_content: &str) -> Vec<Todo> {
+    match parse_todos(file_content) {
+        Ok((_, todos)) => todos,
+        Err(_) => vec![],
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use crate::commands::parser::{parse_todo, parse_todos, Todo};
+
+    #[test]
+    fn todos() {
+        let input = "line 1\n\
+             TODO: todo1\n\
+             line 2\n\
+             line 3 -- TODO: todo2\n";
+
+        assert_eq!(
+            parse_todos(input),
+            Ok((
+                "",
+                vec![
+                    Todo {
+                        tag: "TODO:".to_owned(),
+                        text: " todo1".to_owned()
+                    },
+                    Todo {
+                        tag: "TODO:".to_owned(),
+                        text: " todo2".to_owned()
+                    },
+                ]
+            ))
+        );
+
+        let input = "line 1\n";
+        assert_eq!(parse_todos(input), Ok(("line 1\n", vec![])));
+
+        let input = "line1 TODO: todo1\n";
+        assert_eq!(
+            parse_todos(input),
+            Ok((
+                "",
+                vec![Todo {
+                    tag: "TODO:".to_owned(),
+                    text: " todo1".to_owned()
+                }]
+            ))
+        );
+
+        let input = "line1\n\
+             line2\n\
+             line3\n\
+             TODO: todo1\n\
+             line4\n";
+        assert_eq!(
+            parse_todos(input),
+            Ok((
+                "line4\n",
+                vec![Todo {
+                    tag: "TODO:".to_owned(),
+                    text: " todo1".to_owned()
+                }]
+            ))
+        );
+
+        let input = "line1\n\
+             line2\n\
+             line3\n\
+             FIXME: todo1\n\
+             line4\n";
+        assert_eq!(parse_todos(input), Ok((input, vec![])));
+    }
+
+    #[test]
+    fn todo_clean() {
+        let input = "TODO: test todo";
+        assert_eq!(
+            parse_todo("TODO:", input),
+            Ok((
+                "",
+                Todo {
+                    tag: "TODO:".to_owned(),
+                    text: " test todo".to_owned()
+                }
+            ))
+        );
+    }
+
+    #[test]
+    fn todo_tag_only() {
+        let input = "TODO:\nline1";
+        assert_eq!(
+            parse_todo("TODO:", input),
+            Ok((
+                "line1",
+                Todo {
+                    tag: "TODO:".to_owned(),
+                    text: "".to_owned()
+                }
+            ))
+        );
+
+        let input = "TODO:";
+        assert_eq!(
+            parse_todo("TODO:", input),
+            Ok((
+                "",
+                Todo {
+                    tag: "TODO:".to_owned(),
+                    text: "".to_owned()
+                }
+            ))
+        );
+
+        let input = "TODO:\n";
+        assert_eq!(
+            parse_todo("TODO:", input),
+            Ok((
+                "",
+                Todo {
+                    tag: "TODO:".to_owned(),
+                    text: "".to_owned()
+                }
+            ))
+        );
+    }
+
+    #[test]
+    fn todo_clean_newline() {
+        let input = "TODO: test todo\nline1";
+        assert_eq!(
+            parse_todo("TODO:", input),
+            Ok((
+                "line1",
+                Todo {
+                    tag: "TODO:".to_owned(),
+                    text: " test todo".to_owned()
+                }
+            ))
+        );
+    }
+
+    #[test]
+    fn todo_in_comment() {
+        let input = "// TODO: test todo";
+        assert_eq!(
+            parse_todo("TODO:", input),
+            Ok((
+                "",
+                Todo {
+                    tag: "TODO:".to_owned(),
+                    text: " test todo".to_owned()
+                }
+            ))
+        );
+    }
+
+    #[test]
+    fn todo_different_tag() {
+        let input = "FIXME: different tag";
+        assert_eq!(parse_todo("TODO:", input).ok(), None);
     }
 }

src/display.rs

@@ -1,16 +1,15 @@
 use colored::Colorize;
 
-fn display_todo(msg: &mut String) {
-    msg.replace_range(..5, "");
-    let body = msg.trim();
-    println!(
-        "{} {}",
-        "TODO:".bold().blue().underline(),
-	body)
+use crate::commands::parser::Todo;
+
+impl Todo {
+    pub fn display(todo: Todo) -> String {
+        format!("{} {}", todo.tag.bold().blue().underline(), todo.text)
+    }
 }
 
-pub fn display_todos(msgs: Vec<String>) {
-    for mut msg in msgs {
-	display_todo(&mut msg);
+pub fn display_todos(todos: Vec<Todo>) {
+    for todo in todos {
+        println!("{}", Todo::display(todo));
     }
 }

src/main.rs

@@ -1,7 +1,7 @@
 mod cli;
+use clap::Parser;
 use cli::Cli;
 use cli::RodoCommands;
-use clap::{Parser};
 mod commands;
 use commands::catalog;
 use commands::list;
@@ -15,13 +15,13 @@ fn main() {
     let current_dir_str = current_dir.into_os_string().into_string().unwrap();
     match &cli.command {
         RodoCommands::Catalog { opt_filepath } => {
-	    let filepath = opt_filepath.to_owned().unwrap_or(current_dir_str);
-	    let _todos = catalog::catalog_path(filepath.as_str()).unwrap();
-        },
-	RodoCommands::List { opt_filepath } => {
-	    let filepath = opt_filepath.to_owned().unwrap_or(current_dir_str);
-	    let todos = list::list_path(filepath.as_str()).unwrap();
-	    display_todos(todos)
+            let filepath = opt_filepath.to_owned().unwrap_or(current_dir_str);
+            let _todos = catalog::catalog_path(filepath.as_str()).unwrap();
+        }
+        RodoCommands::List { opt_filepath } => {
+            let filepath = opt_filepath.to_owned().unwrap_or(current_dir_str);
+            let todos = list::list_path_todos(filepath.as_str());
+            display_todos(todos)
         }
     }
 }