1 files changed, 45 insertions, 12 deletions

diff --git a/src/directive/mod.rs b/src/directive/mod.rs
index ae2dc09..4efde55 100644
--- a/src/directive/mod.rs
+++ b/src/directive/mod.rs
@@ -1,4 +1,3 @@
-use crate::error::SiteError;
 use crate::page::PageMeta;
 use crate::site::Site;
 use crate::wikitext::ParsedDirective;
@@ -6,6 +5,36 @@ use crate::wikitext::ParsedDirective;
 use log::{debug, trace};
 use std::collections::HashSet;
 
+#[derive(Debug, thiserror::Error)]
+pub enum DirectiveError {
+    #[error("unknown directive {0}")]
+    UnknownDirective(String),
+
+    #[error("directive {0} is missing required argument {1}")]
+    DirectiveMissingArg(String, String),
+
+    #[error("directive {0} has unknown argument {1}")]
+    DirectiveUnknownArg(String, String),
+
+    #[error("directive {0} does not allow unnamed arguments")]
+    UnknownArgsNotAllowed(String),
+
+    #[error("directive isn't implemented yet: {0}")]
+    UnimplementedDirective(String),
+
+    #[error("toc directive arguments 'levels' could not be parsed as an integer: {0}")]
+    LevelsParse(String, #[source] std::num::ParseIntError),
+
+    #[error(transparent)]
+    PageSpec(#[from] crate::pagespec::PageSpecError),
+
+    #[error(transparent)]
+    Time(#[from] crate::time::TimeError),
+
+    #[error(transparent)]
+    Site(#[from] Box<crate::site::SiteError>),
+}
+
 pub enum Processed {
     Markdown(String),
     Toc(usize),
@@ -17,9 +46,9 @@ pub trait DirectiveImplementation {
     const ALLOW_ANY_UNNAMED: bool;
 
     fn from_parsed(p: &ParsedDirective) -> Self;
-    fn process(&self, site: &Site, meta: &mut PageMeta) -> Result<Processed, SiteError>;
+    fn process(&self, site: &Site, meta: &mut PageMeta) -> Result<Processed, DirectiveError>;
 
-    fn prepare(&self, _site: &mut Site) -> Result<(), SiteError> {
+    fn prepare(&self, _site: &mut Site) -> Result<(), DirectiveError> {
         Ok(())
     }
 }
@@ -49,7 +78,7 @@ pub enum Directive {
 }
 
 impl TryFrom<ParsedDirective> for Directive {
-    type Error = SiteError;
+    type Error = DirectiveError;
 
     fn try_from(p: ParsedDirective) -> Result<Self, Self::Error> {
         Self::try_from(&p)
@@ -57,7 +86,7 @@ impl TryFrom<ParsedDirective> for Directive {
 }
 
 impl TryFrom<&ParsedDirective> for Directive {
-    type Error = SiteError;
+    type Error = DirectiveError;
 
     fn try_from(p: &ParsedDirective) -> Result<Self, Self::Error> {
         let d = match p.name() {
@@ -173,7 +202,7 @@ impl TryFrom<&ParsedDirective> for Directive {
                 )?;
                 Directive::TrailLink(TrailLink::from_parsed(p))
             }
-            _ => return Err(SiteError::UnknownDirective(p.name().into())),
+            _ => return Err(DirectiveError::UnknownDirective(p.name().into())),
         };
         Ok(d)
     }
@@ -185,11 +214,11 @@ impl Directive {
         required: &[&str],
         allowed: &[&str],
         allow_any_unnamed: bool,
-    ) -> Result<(), SiteError> {
+    ) -> Result<(), DirectiveError> {
         let args = p.args();
         for arg in required.iter() {
             if !args.contains_key(arg) {
-                return Err(SiteError::DirectiveMissingArg(
+                return Err(DirectiveError::DirectiveMissingArg(
                     p.name().into(),
                     arg.to_string(),
                 ));
@@ -201,11 +230,11 @@ impl Directive {
         for (arg, value) in p.args().iter() {
             if value.is_empty() {
                 if !allow_any_unnamed {
-                    return Err(SiteError::UnknownArgsNotAllowed(p.name().into()));
+                    return Err(DirectiveError::UnknownArgsNotAllowed(p.name().into()));
                 }
             } else if !allowed.contains(*arg) {
                 debug!("parsed directive {:?}", p);
-                return Err(SiteError::DirectiveUnknownArg(
+                return Err(DirectiveError::DirectiveUnknownArg(
                     p.name().into(),
                     arg.to_string(),
                 ));
@@ -214,7 +243,7 @@ impl Directive {
         Ok(())
     }
 
-    pub fn prepare(&self, site: &mut Site) -> Result<(), SiteError> {
+    pub fn prepare(&self, site: &mut Site) -> Result<(), DirectiveError> {
         trace!("prepare directive {:?}", self);
         if let Self::Shortcut(x) = self {
             x.prepare(site)?;
@@ -222,7 +251,11 @@ impl Directive {
         Ok(())
     }
 
-    pub fn process(&self, site: &mut Site, meta: &mut PageMeta) -> Result<Processed, SiteError> {
+    pub fn process(
+        &self,
+        site: &mut Site,
+        meta: &mut PageMeta,
+    ) -> Result<Processed, DirectiveError> {
         match self {
             Self::Simple
             | Self::UnnamedArg