Add error handling to parse functions (#11)

Add error handling to parse functions, via the `Error` enum. This adds basic
errors for parse and resolve, though provides little context on the actual
error at this time.

Author: djeedai

src/error.rs

@@ -0,0 +1,182 @@
+//! Error management
+
+use std::convert::From;
+use std::fmt;
+
+/// Generic error for all weldr operations.
+#[derive(Debug)]
+pub enum Error {
+    /// An error encountered while parsing some LDraw file content.
+    Parse(ParseError),
+
+    /// An error encountered while resolving a sub-file reference.
+    Resolve(ResolveError),
+}
+
+#[derive(Debug)]
+pub struct ParseError {
+    pub filename: String,
+    pub parse_error: Option<Box<dyn std::error::Error>>,
+}
+
+#[derive(Debug)]
+pub struct ResolveError {
+    pub filename: String,
+    pub resolve_error: Option<Box<dyn std::error::Error>>,
+}
+
+impl ParseError {
+    /// Create a [`ParseError`] that stems from an arbitrary error of an underlying parser.
+    pub fn new(filename: &str, err: impl Into<Box<dyn std::error::Error>>) -> Self {
+        ParseError {
+            filename: filename.to_string(),
+            parse_error: Some(err.into()),
+        }
+    }
+
+    /// Create a [`ParseError`] that stems from a [`nom`] parsing error, capturing the [`nom::error::ErrorKind`]
+    /// from the underlying parser which failed.
+    pub fn new_from_nom(filename: &str, err: &nom::Err<(&[u8], nom::error::ErrorKind)>) -> Self {
+        ParseError {
+            filename: filename.to_string(),
+            parse_error: match err {
+                nom::Err::Incomplete(_) => None,
+                nom::Err::Error((_, e)) => {
+                    // Discard input slice due to lifetime constraint
+                    let e2: nom::Err<_> = nom::Err::Error(*e);
+                    Some(e2.into())
+                }
+                nom::Err::Failure((_, e)) => {
+                    // Discard input slice due to lifetime constraint
+                    let e2: nom::Err<_> = nom::Err::Failure(*e);
+                    Some(e2.into())
+                }
+            },
+        }
+    }
+}
+
+impl ResolveError {
+    /// Create a [`ResolveError`] that stems from an arbitrary error of an underlying resolution error.
+    pub fn new(filename: &str, err: impl Into<Box<dyn std::error::Error>>) -> Self {
+        ResolveError {
+            filename: filename.to_string(),
+            resolve_error: Some(err.into()),
+        }
+    }
+
+    /// Create a [`ResolveError`] without any underlying error.
+    pub fn new_raw(filename: &str) -> Self {
+        ResolveError {
+            filename: filename.to_string(),
+            resolve_error: None,
+        }
+    }
+}
+
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Error::Parse(ParseError {
+                filename,
+                parse_error,
+            }) => write!(f, "parse error in file '{}': {:?}", filename, parse_error),
+            Error::Resolve(ResolveError {
+                filename,
+                resolve_error,
+            }) => write!(
+                f,
+                "resolve error for filename '{}': {:?}",
+                filename, resolve_error
+            ),
+        }
+    }
+}
+
+impl std::error::Error for Error {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        None
+        // match self {
+        //     Error::Parse(ParseError {
+        //         filename,
+        //         parse_error,
+        //     }) => parse_error,
+        //     Error::Resolve(ResolveError {
+        //         filename,
+        //         resolve_error,
+        //     }) => resolve_error,
+        // }
+    }
+}
+
+impl From<ResolveError> for Error {
+    fn from(e: ResolveError) -> Self {
+        Error::Resolve(e)
+    }
+}
+
+impl From<ParseError> for Error {
+    fn from(e: ParseError) -> Self {
+        Error::Parse(e)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+
+    use super::*;
+
+    fn get_error() -> Result<u32, Error> {
+        let underlying = Error::Parse(ParseError {
+            filename: "low_level.ldr".to_string(),
+            parse_error: None,
+        });
+        Err(Error::Resolve(ResolveError::new(
+            "test_file.ldr",
+            underlying,
+        )))
+    }
+
+    #[test]
+    fn test_error() {
+        match get_error() {
+            Err(e) => println!("Error: {}", e),
+            _ => {}
+        };
+    }
+
+    #[test]
+    fn test_new_from_nom() {
+        let nom_error: nom::Err<(&[u8], nom::error::ErrorKind)> =
+            nom::Err::Error((&b""[..], nom::error::ErrorKind::Alpha));
+        let parse_error = ParseError::new_from_nom("file", &nom_error);
+        assert_eq!(parse_error.filename, "file");
+        assert!(parse_error.parse_error.is_some());
+    }
+
+    #[test]
+    fn test_source() {
+        let resolve_error = ResolveError::new_raw("file");
+        let error: Error = resolve_error.into();
+        assert!(std::error::Error::source(&error).is_none());
+    }
+
+    #[test]
+    fn test_from() {
+        let resolve_error = ResolveError::new_raw("file");
+        let error: Error = resolve_error.into();
+        println!("err: {}", error);
+        match &error {
+            Error::Resolve(resolve_error) => assert_eq!(resolve_error.filename, "file"),
+            _ => panic!("Unexpected error type."),
+        }
+
+        let parse_error = ParseError::new("file", error);
+        let error: Error = parse_error.into();
+        println!("err: {}", error);
+        match &error {
+            Error::Parse(parse_error) => assert_eq!(parse_error.filename, "file"),
+            _ => panic!("Unexpected error type."),
+        }
+    }
+}

src/lib.rs

@@ -109,6 +109,10 @@ pub use math::Vec3;
 #[cfg(feature = "cgmath")]
 pub type Vec3 = cgmath::Vector3<f32>;
 
+pub mod error;
+
+pub use error::{Error, ParseError, ResolveError};
+
 // LDraw File Format Specification
 // https://www.ldraw.org/article/218.html
 
@@ -603,15 +607,15 @@ named!(
 ///       Vec3{ x: 1.0, y: 1.0, z: 1.0 }
 ///     ]
 ///   });
-///   assert_eq!(parse_raw(b"0 this is a comment\n2 16 0 0 0 1 1 1"), vec![cmd0, cmd1]);
+///   assert_eq!(parse_raw(b"0 this is a comment\n2 16 0 0 0 1 1 1").unwrap(), vec![cmd0, cmd1]);
 /// }
 /// ```
-pub fn parse_raw(ldr_content: &[u8]) -> Vec<CommandType> {
+pub fn parse_raw(ldr_content: &[u8]) -> Result<Vec<CommandType>, Error> {
     // "An LDraw file consists of one command per line."
-    match many0(read_line)(ldr_content) {
-        Ok((_, cmds)) => cmds,
-        Err(_) => panic!("TODO - Error handling"),
-    }
+    many0(read_line)(ldr_content).map_or_else(
+        |e| Err(Error::Parse(ParseError::new_from_nom("", &e))),
+        |(_, cmds)| Ok(cmds),
+    )
 }
 
 struct QueuedFileRef {
@@ -710,17 +714,20 @@ fn resolve_file_refs(
     }
 }
 
-fn load_and_parse_single_file(filename: &str, resolver: &dyn FileRefResolver) -> SourceFile {
+fn load_and_parse_single_file(
+    filename: &str,
+    resolver: &dyn FileRefResolver,
+) -> Result<SourceFile, Error> {
     //match resolver.resolve(filename) {}
-    let raw_content = resolver.resolve(filename);
+    let raw_content = resolver.resolve(filename)?;
     let mut source_file = SourceFile {
         filename: filename.to_string(),
         raw_content,
         cmds: Vec::new(),
     };
-    let cmds = parse_raw(&source_file.raw_content[..]);
+    let cmds = parse_raw(&source_file.raw_content[..])?;
     source_file.cmds = cmds;
-    source_file
+    Ok(source_file)
 }
 
 /// Parse a single file and its sub-file references recursively.
@@ -731,35 +738,36 @@ fn load_and_parse_single_file(filename: &str, resolver: &dyn FileRefResolver) ->
 /// up populating the given `source_map`, which can be pre-populated manually or from a
 /// previous call with already loaded and parsed files.
 /// ```rust
-/// use weldr::{ FileRefResolver, parse };
+/// use weldr::{ FileRefResolver, parse, ResolveError };
 /// use std::collections::HashMap;
 ///
 /// struct MyCustomResolver {};
 ///
 /// impl FileRefResolver for MyCustomResolver {
-///   fn resolve(&self, filename: &str) -> Vec<u8> {
-///     vec![] // replace with custom impl
+///   fn resolve(&self, filename: &str) -> Result<Vec<u8>, ResolveError> {
+///     Ok(vec![]) // replace with custom impl
 ///   }
 /// }
 ///
-/// fn main() {
+/// fn main() -> Result<(), Box<dyn std::error::Error>> {
 ///   let resolver = MyCustomResolver{};
 ///   let mut source_map = HashMap::new();
-///   let root_file = parse("root.ldr", &resolver, &mut source_map);
+///   let root_file = parse("root.ldr", &resolver, &mut source_map)?;
 ///   assert_eq!(root_file.borrow().filename, "root.ldr");
+///   Ok(())
 /// }
 /// ```
 pub fn parse(
     filename: &str,
     resolver: &dyn FileRefResolver,
     source_map: &mut HashMap<String, Rc<RefCell<SourceFile>>>,
-) -> Rc<RefCell<SourceFile>> {
+) -> Result<Rc<RefCell<SourceFile>>, Error> {
     if let Some(existing_file) = source_map.get(filename) {
-        return Rc::clone(existing_file);
+        return Ok(Rc::clone(existing_file));
     }
     let mut queue = ResolveQueue::new();
     println!("Loading root file: {}", filename);
-    let root_file = load_and_parse_single_file(filename, resolver);
+    let root_file = load_and_parse_single_file(filename, resolver)?;
     let root_file = Rc::new(RefCell::new(root_file));
     {
         println!(
@@ -777,7 +785,7 @@ pub fn parse(
             println!("Already parsed; reusing sub-file: {}", filename);
         } else {
             println!("Not yet parsed; parsing sub-file: {}", filename);
-            let source_file = load_and_parse_single_file(&filename[..], resolver);
+            let source_file = load_and_parse_single_file(&filename[..], resolver)?;
             let subfile = Rc::new(RefCell::new(source_file));
             println!(
                 "Post-loading resolving subfile refs of sub-file: {}",
@@ -796,7 +804,7 @@ pub fn parse(
             resolve_file_refs(queued_file.0.referer, &mut queue, source_map);
         }
     }
-    root_file
+    Ok(root_file)
 }
 
 /// [Line Type 0](https://www.ldraw.org/article/218.html#lt0) META command:
@@ -1029,7 +1037,7 @@ pub trait FileRefResolver {
     /// Unix style `\n` or Windows style `\r\n`.
     ///
     /// See [`parse`] for usage.
-    fn resolve(&self, filename: &str) -> Vec<u8>;
+    fn resolve(&self, filename: &str) -> Result<Vec<u8>, ResolveError>;
 }
 
 #[cfg(test)]
@@ -1980,7 +1988,7 @@ mod tests {
             ],
         });
         assert_eq!(
-            parse_raw(b"0 this is a comment\n2 16 0 0 0 1 1 1"),
+            parse_raw(b"0 this is a comment\n2 16 0 0 0 1 1 1").unwrap(),
             vec![cmd0, cmd1]
         );
 
@@ -2012,7 +2020,8 @@ mod tests {
             file: SubFileRef::UnresolvedRef("aa/aaaaddd".to_string()),
         });
         assert_eq!(
-            parse_raw(b"\n0 this doesn't matter\n\n1 16 0 0 0 1 0 0 0 1 0 0 0 1 aa/aaaaddd"),
+            parse_raw(b"\n0 this doesn't matter\n\n1 16 0 0 0 1 0 0 0 1 0 0 0 1 aa/aaaaddd")
+                .unwrap(),
             vec![cmd0, cmd1]
         );
 
@@ -2046,7 +2055,8 @@ mod tests {
         assert_eq!(
             parse_raw(
                 b"\r\n0 this doesn't \"matter\"\r\n\r\n1 16 0 0 0 1 0 0 0 1 0 0 0 1 aa/aaaaddd\n"
-            ),
+            )
+            .unwrap(),
             vec![cmd0, cmd1]
         );
 
@@ -2101,7 +2111,8 @@ mod tests {
         assert_eq!(
             parse_raw(
                 b"1 16 0 0 0 1 0 0 0 1 0 0 0 1 aa/aaaaddd\n1 16 0 0 0 1 0 0 0 1 0 0 0 1 aa/aaaaddd"
-            ),
+            )
+            .unwrap(),
             vec![cmd0, cmd1]
         );
     }