refactor: drop RikiError::PageProblem, add SiteError

Sponsored-by: author

6 files changed, 52 insertions, 31 deletions

diff --git a/src/directive/img.rs b/src/directive/img.rs
index a931650..0b352fa 100644
--- a/src/directive/img.rs
+++ b/src/directive/img.rs
@@ -89,7 +89,7 @@ impl DirectiveImplementation for Img {
         );
         let src = site
             .resolve(meta.path(), Path::new(&self.src))
-            .map_err(|e| DirectiveError::Riki(Box::new(e)))?;
+            .map_err(|e| DirectiveError::Site(Box::new(e)))?;
         trace!("img src={:?}", src.display());
 
         let mut img = String::new();
diff --git a/src/directive/mod.rs b/src/directive/mod.rs
index 006e334..6b3fc15 100644
--- a/src/directive/mod.rs
+++ b/src/directive/mod.rs
@@ -32,6 +32,9 @@ pub enum DirectiveError {
     Time(#[from] crate::time::TimeError),
 
     #[error(transparent)]
+    Site(#[from] Box<crate::site::SiteError>),
+
+    #[error(transparent)]
     Riki(#[from] Box<crate::error::RikiError>),
 }
 
diff --git a/src/error.rs b/src/error.rs
index bab58fb..6f3ba22 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -30,14 +30,14 @@ pub enum RikiError {
     #[error("link to missing page {1} on {0}")]
     PageMissing(PathBuf, PathBuf),
 
-    #[error("failed to process page {0}")]
-    PageProblem(PathBuf, #[source] Box<Self>),
-
     #[error(transparent)]
     PageSpec(#[from] crate::pagespec::PageSpecError),
 
     #[error(transparent)]
     HtmlError(#[from] HtmlError),
+
+    #[error(transparent)]
+    Site(#[from] crate::site::SiteError),
 }
 
 impl RikiError {
diff --git a/src/page.rs b/src/page.rs
index 3cca57e..94b74bd 100644
--- a/src/page.rs
+++ b/src/page.rs
@@ -159,8 +159,7 @@ impl MarkdownPage {
 
     pub fn body_to_html(&self) -> Result<HtmlPage, RikiError> {
         let head = Element::new(ElementTag::Head);
-        let body = parse(self.markdown())
-            .map_err(|e| RikiError::PageProblem(self.meta.path().into(), Box::new(e.into())))?;
+        let body = parse(self.markdown())?;
         Ok(HtmlPage::new(head, body))
     }
 
@@ -171,8 +170,7 @@ impl MarkdownPage {
         let mut head = Element::new(ElementTag::Head);
         head.push_child(Content::Elt(title));
 
-        let body = parse(self.markdown())
-            .map_err(|e| RikiError::PageProblem(self.meta.path().into(), Box::new(e.into())))?;
+        let body = parse(self.markdown())?;
 
         trace!("MarkdownPage::to_html: head={:?}", head);
         Ok(HtmlPage::new(head, body))
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"));
             }
diff --git a/src/wikitext.rs b/src/wikitext.rs
index f8f4ce6..691f041 100644
--- a/src/wikitext.rs
+++ b/src/wikitext.rs
@@ -34,9 +34,7 @@ impl Snippet {
         let processed = match self {
             Snippet::Markdown(text) => Processed::Markdown(text.into()),
             Snippet::WikiLink(w) => {
-                let resolved = site
-                    .resolve(meta.path(), Path::new(w.target()))
-                    .map_err(|e| RikiError::PageProblem(meta.path().into(), Box::new(e)))?;
+                let resolved = site.resolve(meta.path(), Path::new(w.target()))?;
                 trace!("resolved {} to {}", w.target(), resolved.display());
                 let link = format!("[{}]({})", w.link_text(), resolved.display());
                 Processed::Markdown(link)
@@ -44,9 +42,7 @@ impl Snippet {
             Snippet::Directive(p) => {
                 let e = Directive::try_from(p);
                 if let Ok(d) = e {
-                    d.process(site, meta).map_err(|e| {
-                        RikiError::PageProblem(meta.path().into(), Box::new(e.into()))
-                    })?
+                    d.process(site, meta)?
                 } else if let Some(shortcut) = site.shortcut(p.name()) {
                     let arg = p.unnamed_args().first().unwrap().to_string();
                     let link = format!("[{}]({})", shortcut.desc(&arg), shortcut.url(&arg));