Add Error enum

Error will model all possible errors we find during the execution to create
better messages to the user.

Author: edilmedeiros

src/commands.rs

@@ -1,3 +1,4 @@
 pub mod catalog;
 pub mod list;
 pub mod parser;
+pub mod error;

src/commands/error.rs

@@ -0,0 +1,8 @@
+
+pub enum Errors {
+    Utf8Error,
+    ParseFail,
+    CantReadLine,
+    MetadataError,
+    CantOpenFile
+}

src/commands/list.rs

@@ -1,4 +1,4 @@
-use crate::commands::parser;
+use crate::commands::{parser, error};
 extern crate walkdir;
 use walkdir::{DirEntry, WalkDir};
 use std::fs::File;
@@ -12,7 +12,8 @@ fn is_hidden(entry: &DirEntry) -> bool {
          .unwrap_or(false)
 }
 
-pub fn list_path(directory_path: &str) -> Result<Vec<String>, ()> {
+// TODO: return Vec<Result<String>, error::Errors> instead.
+pub fn list_path(directory_path: &str) -> Result<Vec<String>, error::Errors> {
     let mut todos = Vec::new();
     for file_path in WalkDir::new(directory_path)
         .into_iter()
@@ -21,32 +22,35 @@ pub fn list_path(directory_path: &str) -> Result<Vec<String>, ()> {
         .filter_map(|file| file.ok()) {
 
             if file_path.metadata().unwrap().is_file() {
-	              let file = File::open(file_path.path()).unwrap();
+	              let file = File::open(file_path.path())
+                    // TODO: continue instead of returning with ?
+                    .map_err(|_| error::Errors::CantOpenFile)?;
 	              let file_buffer = io::BufReader::new(file);
 
                 for line in file_buffer.lines() {
                     match line.as_deref() {
-                        Ok("") | Err(_) => (),
+                        Ok("") => (),
                         Ok(source_code_line) => {
                             match parse_line(source_code_line) {
                                 Ok(todo_line) => todos.push(todo_line.to_string()),
                                 Err(_) => ()
                             }
                         }
+                        Err(_) => todos.push("Can't read line.".to_string())
                     }
                 }
             }
         }
     Ok(todos)
 }
 
-fn parse_line(line: &str) -> Result<&str, ()> {
+fn parse_line(line: &str) -> Result<&str, error::Errors> {
 
     parser::todo()(line.as_bytes())
-        .map_err(|_| ())
+        .map_err(|_| error::Errors::ParseFail)
         .map(|(_,y)|
              str::from_utf8(y)
-             .map_err(|_| ())
+             .map_err(|_| error::Errors::Utf8Error)
         )?
 }