1 files changed, 41 insertions, 17 deletions

diff --git a/src/site.rs b/src/site.rs
index 9c6463e..03cff51 100644
--- a/src/site.rs
+++ b/src/site.rs
@@ -1,4 +1,3 @@
-use crate::error::RikiError;
 use crate::git::git_whatchanged;
 use crate::name::{Name, NameBuilder, Names};
 use crate::page::{MarkdownPage, Page, UnprocessedPage, WikitextPage};
@@ -11,6 +10,27 @@ use std::collections::HashMap;
 use std::path::{Path, PathBuf};
 use std::time::UNIX_EPOCH;
 
+#[derive(Debug, thiserror::Error)]
+pub enum SiteError {
+    #[error("link to missing page {1} on {0}")]
+    PageMissing(PathBuf, PathBuf),
+
+    #[error(transparent)]
+    Page(#[from] crate::page::PageError),
+
+    #[error(transparent)]
+    Git(#[from] crate::git::GitError),
+
+    #[error(transparent)]
+    Parser(#[from] crate::parser::ParserError),
+
+    #[error(transparent)]
+    WalkDir(#[from] crate::srcdir::SourceDirError),
+
+    #[error(transparent)]
+    Riki(#[from] Box<crate::error::RikiError>),
+}
+
 pub struct Site {
     patterns: TokenPatterns,
     shortcuts: HashMap<String, Shortcut>,
@@ -40,13 +60,13 @@ impl Site {
         }
     }
 
-    pub fn scan(&mut self) -> Result<(), RikiError> {
+    pub fn scan(&mut self) -> Result<(), SiteError> {
         for name in self.all_files()? {
             trace!("scan: name={}", name);
             if name.is_wikitext_page() {
                 trace!("scan: it's a page");
                 debug!("loading wikitext page {}", name.source_path().display());
-                let page = WikitextPage::read(&name)?;
+                let page = WikitextPage::read(&name).map_err(|e| SiteError::Riki(Box::new(e)))?;
                 self.files.insert(name);
                 self.add_wikitextpage(page)?;
             } else {
@@ -60,14 +80,16 @@ impl Site {
         Ok(())
     }
 
-    fn add_wikitextpage(&mut self, page: WikitextPage) -> Result<(), RikiError> {
+    fn add_wikitextpage(&mut self, page: WikitextPage) -> Result<(), SiteError> {
         info!("add wikitext page {}", page.meta().path().display());
         self.pages_that_will_exist.insert(&page);
 
         debug!("parsing wikitext page {}", page.meta().path().display());
         let mut parser = WikitextParser::new(page.wikitext(), &self.patterns);
-        let page = UnprocessedPage::new(page.meta().clone(), &mut parser)?;
-        page.prepare(self)?;
+        let page = UnprocessedPage::new(page.meta().clone(), &mut parser)
+            .map_err(|e| SiteError::Riki(Box::new(e)))?;
+        page.prepare(self)
+            .map_err(|e| SiteError::Riki(Box::new(e)))?;
         let page = Page::new(page.meta().clone(), page);
 
         self.pages.push(page);
@@ -80,7 +102,7 @@ impl Site {
         self.files.insert(name);
     }
 
-    pub fn process(&mut self) -> Result<(), RikiError> {
+    pub fn process(&mut self) -> Result<(), SiteError> {
         trace!("processing queues");
         loop {
             if !self.process_page()? {
@@ -91,13 +113,15 @@ impl Site {
         Ok(())
     }
 
-    fn process_page(&mut self) -> Result<bool, RikiError> {
+    fn process_page(&mut self) -> Result<bool, SiteError> {
         if let Some(page) = self.pages.pop() {
             debug!(
                 "processing unprocessed page {}",
                 page.meta().path().display()
             );
-            let page = page.markdown(self)?;
+            let page = page
+                .markdown(self)
+                .map_err(|e| SiteError::Riki(Box::new(e)))?;
             self.markdown_pages.push(page);
             Ok(true)
         } else {
@@ -122,7 +146,7 @@ impl Site {
         self.pages_that_will_exist.get_path(path).is_some()
     }
 
-    fn all_files(&self) -> Result<Vec<Name>, RikiError> {
+    fn all_files(&self) -> Result<Vec<Name>, SiteError> {
         let whatchanged = git_whatchanged(self.name_builder.srcdir())?;
 
         let mut srcdir = SourceDir::new(self.name_builder.srcdir());
@@ -153,7 +177,7 @@ impl Site {
         }
     }
 
-    pub fn resolve<P: AsRef<Path>>(&self, page: P, target: P) -> Result<PathBuf, RikiError> {
+    pub fn resolve<P: AsRef<Path>>(&self, page: P, target: P) -> Result<PathBuf, SiteError> {
         let page = page.as_ref();
         let target = target.as_ref();
         let resolved = self.resolve_helper(page, target)?;
@@ -169,7 +193,7 @@ impl Site {
         Ok(resolved)
     }
 
-    fn resolve_helper(&self, page: &Path, target: &Path) -> Result<PathBuf, RikiError> {
+    fn resolve_helper(&self, page: &Path, target: &Path) -> Result<PathBuf, SiteError> {
         trace!(
             "recursive_helper: page={} target={}",
             page.display(),
@@ -183,7 +207,7 @@ impl Site {
                 return Ok(path.into());
             } else {
                 trace!("absolute target does not exist");
-                return Err(RikiError::PageMissing(page.into(), target.into()));
+                return Err(SiteError::PageMissing(page.into(), target.into()));
             }
         }
 
@@ -230,7 +254,7 @@ impl Site {
 
         // Target doesn't exist.
         trace!("target does not exist: {}", target.display());
-        Err(RikiError::PageMissing(page.into(), target.into()))
+        Err(SiteError::PageMissing(page.into(), target.into()))
     }
 
     fn file_exists(&self, filename: &Path) -> bool {
@@ -307,7 +331,7 @@ impl Shortcut {
 
 #[cfg(test)]
 mod test {
-    use super::{Name, NameBuilder, Site, RikiError, WikitextPage};
+    use super::{Name, NameBuilder, Site, SiteError, WikitextPage};
     use crate::page::MetaBuilder;
     use crate::pagespec::PageSpec;
     use std::{
@@ -353,7 +377,7 @@ mod test {
     fn link_to_missing_is_an_error() {
         let site = site();
         match site.resolve("/src/foo/bar", "yo") {
-            Err(RikiError::PageMissing(page, target)) => {
+            Err(SiteError::PageMissing(page, target)) => {
                 assert_eq!(target, PathBuf::from("yo"));
                 assert_eq!(page, PathBuf::from("/src/foo/bar"));
             }
@@ -399,7 +423,7 @@ mod test {
         let mut site = site();
         site.process().unwrap();
         match site.resolve("/foo/bar", "yo/yoyo") {
-            Err(RikiError::PageMissing(page, target)) => {
+            Err(SiteError::PageMissing(page, target)) => {
                 assert_eq!(target, PathBuf::from("yo/yoyo"));
                 assert_eq!(page, PathBuf::from("/foo/bar"));
             }