Initial move to returning results from render calls.

src/renderer/renderer.rs

@@ -9,6 +9,7 @@ use crate::renderer::renderable::Renderable;
 use crate::renderer::walkable::ContextElement;
 use crate::renderer::walkable::Walkable;
 use std::collections::HashMap;
+use std::error::Error;
 use std::ops::Index;
 
 #[derive(Clone, Debug)]
@@ -47,22 +48,23 @@ impl<'a> DustRenderer<'a> {
             .insert(template.name.clone(), &template.template);
     }
 
-    pub fn render<C>(&self, name: &str, context: &C) -> Result<String, RenderError>
+    pub fn render<C>(&self, name: &str, context: &'a C) -> Result<String, RenderError<'a>>
     where
         C: ContextElement,
     {
         let main_template = match self.templates.get(name) {
             Some(tmpl) => tmpl,
             None => {
-                return Err(RenderError {
-                    message: format!("No template named {} in context", name),
-                });
+                return Err(RenderError::Generic(format!(
+                    "No template named {} in context",
+                    name
+                )));
             }
         };
         self.render_body(&main_template.contents, context)
     }
 
-    fn render_body<C>(&self, body: &Body, context: &C) -> Result<String, RenderError>
+    fn render_body<C>(&self, body: &Body, context: &'a C) -> Result<String, RenderError<'a>>
     where
         C: ContextElement,
     {
@@ -78,14 +80,14 @@ impl<'a> DustRenderer<'a> {
         Ok(output)
     }
 
-    fn render_tag<C>(&self, tag: &DustTag, context: &C) -> Result<String, RenderError>
+    fn render_tag<C>(&self, tag: &DustTag, context: &'a C) -> Result<String, RenderError<'a>>
     where
         C: ContextElement,
     {
         match tag {
             DustTag::DTComment(comment) => (),
             DustTag::DTReference(reference) => {
-                let val = walk_path(context, &reference.path.keys);
+                let val = walk_path(context, &reference.path.keys)?;
                 return Ok(val.render());
             }
             _ => (), // TODO: Implement the rest
@@ -94,14 +96,17 @@ impl<'a> DustRenderer<'a> {
     }
 }
 
-fn walk_path<'a>(context: &'a dyn ContextElement, path: &Vec<&str>) -> &'a dyn ContextElement {
+fn walk_path<'a>(
+    context: &'a dyn ContextElement,
+    path: &Vec<&str>,
+) -> Result<&'a dyn ContextElement, RenderError<'a>> {
     let mut output = context;
 
     for elem in path.iter() {
-        output = output.walk(elem);
+        output = output.walk(elem)?;
     }
 
-    output
+    Ok(output)
 }
 
 #[cfg(test)]
@@ -133,19 +138,24 @@ mod tests {
         }
 
         impl<I: ContextElement> Walkable for HashMap<&str, I> {
-            fn walk(&self, segment: &str) -> &dyn ContextElement {
-                self.get(segment).unwrap()
+            fn walk(&self, segment: &str) -> Result<&dyn ContextElement, RenderError> {
+                Ok(self.get(segment).unwrap())
+                // TODO: Handle error here better
+                // self.get(segment).ok_or(RenderError::WontWalk {
+                //     segment: segment.to_string(),
+                //     elem: self,
+                // })
             }
         }
 
         impl Walkable for &str {
-            fn walk(&self, _segment: &str) -> &dyn ContextElement {
+            fn walk(&self, _segment: &str) -> Result<&dyn ContextElement, RenderError> {
                 panic!("Tried to walk down a str");
             }
         }
 
         impl Walkable for u32 {
-            fn walk(&self, _segment: &str) -> &dyn ContextElement {
+            fn walk(&self, _segment: &str) -> Result<&dyn ContextElement, RenderError> {
                 panic!("Tried to walk down a str");
             }
         }