update return values for Wikilink checker

Author: JayJayArr

lychee-lib/src/checker/file.rs

@@ -1,5 +1,5 @@
 use http::StatusCode;
-use log::warn;
+use log::{trace, warn};
 use std::borrow::Cow;
 use std::path::{Path, PathBuf};
 
@@ -81,9 +81,12 @@ impl FileChecker {
     ///
     /// Returns a `Status` indicating the result of the check.
     pub(crate) async fn check(&self, uri: &Uri) -> Status {
-        //only populate the wikilink filenames if the feature is enabled
+        // only populate the wikilink filenames if the feature is enabled
         if self.include_wikilinks {
-            self.setup_wikilinks();
+            match self.setup_wikilinks() {
+                Ok(()) => (),
+                Err(e) => return Status::Error(e),
+            }
         }
         let Ok(path) = uri.url.to_file_path() else {
             return ErrorKind::InvalidFilePath(uri.clone()).into();
@@ -331,17 +334,20 @@ impl FileChecker {
     }
 
     // Initializes the index of the wikilink checker
-    fn setup_wikilinks(&self) {
-        self.wikilink_checker.index_files();
+    fn setup_wikilinks(&self) -> Result<(), ErrorKind> {
+        self.wikilink_checker.setup_wikilinks_index()
     }
+
     // Tries to resolve a link by looking up the filename in the wikilink index
     fn apply_wikilink_check(&self, path: &Path, uri: &Uri) -> Result<PathBuf, ErrorKind> {
         let mut path_buf = path.to_path_buf();
         for ext in &self.fallback_extensions {
             path_buf.set_extension(ext);
-            match self.wikilink_checker.check(&path_buf, uri) {
-                Err(_) => { trace!("Tried to find wikilink at {path_buf}") }
-                Ok(resolved_path) => return Ok(resolved_path),
+            match self.wikilink_checker.contains_path(&path_buf) {
+                None => {
+                    trace!("Tried to find wikilink {} at {}", uri, path_buf.display());
+                }
+                Some(resolved_path) => return Ok(resolved_path),
             }
         }
 

lychee-lib/src/extract/markdown.rs

@@ -88,20 +88,20 @@ pub(crate) fn extract_markdown(
                             return None;
                         }
                         inside_wikilink_block = true;
-                        //Ignore gitlab toc notation: https://docs.gitlab.com/user/markdown/#table-of-contents
+                        // Ignore gitlab toc notation: https://docs.gitlab.com/user/markdown/#table-of-contents
                         if ["_TOC_".to_string(), "TOC".to_string()].contains(&dest_url.to_string()) {
                             return None;
                         }
 
-                        //Strip potholes (|) from wikilinks
+                        // Strip potholes (|) from wikilinks
                         let mut stripped_dest_url = if has_pothole {
                             pulldown_cmark::CowStr::Borrowed(&dest_url[0..dest_url.find('|').unwrap_or(dest_url.len())])
                         } else {
                             dest_url.clone()
                         };
 
-                        //Strip fragments (#) from wikilinks, according to the obsidian spec
-                        //fragments come before potholes
+                        // Strip fragments (#) from wikilinks, according to the obsidian spec
+                        // fragments come before potholes
                         if stripped_dest_url.contains('#') {
                             stripped_dest_url = pulldown_cmark::CowStr::Borrowed(&dest_url[0..dest_url.find('#').unwrap_or(dest_url.len())]);
                         }

lychee-lib/src/types/error.rs

@@ -170,6 +170,10 @@ pub enum ErrorKind {
     #[error("Status code range error")]
     StatusCodeSelectorError(#[from] StatusCodeSelectorError),
 
+    /// Error locking a Mutex
+    #[error("Failed to lock a Mutex")]
+    MutexPoisoned,
+
     /// Test-only error variant for formatter tests
     /// Available in both test and debug builds to support cross-crate testing
     #[cfg(any(test, debug_assertions))]
@@ -334,7 +338,10 @@ impl ErrorKind {
                 [] => "No directory links are allowed because index_files is defined and empty".to_string(),
                 [name] => format!("An index file ({name}) is required"),
                 [init @ .., tail] => format!("An index file ({}, or {}) is required", init.join(", "), tail),
-            }.into()
+            }.into(),
+            ErrorKind::MutexPoisoned => Some (
+                "One or more threads failed and poisoned a Mutex".to_string()
+            )
         }
     }
 
@@ -470,6 +477,7 @@ impl Hash for ErrorKind {
             Self::BasicAuthExtractorError(e) => e.to_string().hash(state),
             Self::Cookies(e) => e.to_string().hash(state),
             Self::StatusCodeSelectorError(e) => e.to_string().hash(state),
+            Self::MutexPoisoned => "Mutex Poisoned".to_string().hash(state),
         }
     }
 }

lychee-lib/src/utils/wikilink_checker.rs

@@ -1,14 +1,18 @@
-use crate::{Base, ErrorKind, Uri};
-use log::info;
+use crate::{Base, ErrorKind, Result};
+use log::{info, warn};
 use std::collections::HashMap;
 use std::ffi::OsString;
 use std::path::Path;
 use std::sync::Mutex;
 use std::{path::PathBuf, sync::Arc};
 use walkdir::WalkDir;
 
+/// Indexes a given directory mapping filenames to their corresponding path.
+///
+/// The `WikilinkChecker` Recursively checks all subdirectories of the given
+/// base directory mapping any found files to the path where they can be found.
+/// Symlinks are ignored to prevent it from infinite loops.
 #[derive(Clone, Debug, Default)]
-// Indexes a given directory for filenames and the corresponding path
 pub(crate) struct WikilinkChecker {
     filenames: Arc<Mutex<HashMap<OsString, PathBuf>>>,
     basedir: Option<Base>,
@@ -18,58 +22,73 @@ impl WikilinkChecker {
     pub(crate) fn new(base: Option<Base>) -> Self {
         Self {
             basedir: base,
-            ..default::Default()
+            ..Default::default()
         }
     }
 
-    pub(crate) fn index_files(&self) {
-        //Skip the indexing step in case the filenames are already populated
+    /// Populates the index of the `WikilinkChecker` unless it is already populated.
+    ///
+    /// Recursively walks the base directory mapping each filename to an absolute filepath.
+    /// Errors if no base directory is given or if it is recognized as remote
+    pub(crate) fn setup_wikilinks_index(&self) -> Result<()> {
+        // Skip the indexing step in case the filenames are already populated
         if !self.filenames.lock().unwrap().is_empty() {
-            return;
+            return Ok(());
         }
         match self.basedir {
             None => {
-                info!("File indexing for Wikilinks aborted as no base directory is specified");
+                warn!("File indexing for Wikilinks aborted as no base directory is specified");
+                Ok(())
             }
-            Some(ref basetype) => match basetype {
-                Base::Local(localbasename) => {
-                    //Start file indexing only if the Base is valid and local
+            Some(ref base_type) => match base_type {
+                Base::Local(local_base_name) => {
+                    // Start file indexing only if the Base is valid and local
                     info!(
                         "Starting file indexing for wikilinks in {}",
-                        localbasename.display()
+                        local_base_name.display()
                     );
 
-                    let mut filenameslock = self.filenames.lock().unwrap();
-                    for entry in WalkDir::new::<PathBuf>(localbasename.into())
-                        //actively ignore symlinks
+                    let mut lock = self
+                        .filenames
+                        .lock()
+                        .map_err(|_| ErrorKind::MutexPoisoned)?;
+                    for entry in WalkDir::new::<PathBuf>(local_base_name.into())
+                        // actively ignore symlinks
                         .follow_links(false)
                         .into_iter()
                         .filter_map(std::result::Result::ok)
                     {
                         if let Some(filename) = entry.path().file_name() {
-                            filenameslock
-                                .insert(filename.to_ascii_lowercase(), entry.path().to_path_buf());
+                            lock.insert(filename.to_ascii_lowercase(), entry.path().to_path_buf());
                         }
                     }
+                    Ok(())
                 }
+
                 // A remote base is of no use for the wikilink checker, silently skip over it
-                Base::Remote(_remotebasename) => {}
+                Base::Remote(remote_base_name) => {
+                    warn!("Error using remote base url for checking wililinks: {remote_base_name}");
+                    Ok(())
+                }
             },
         }
     }
-
-    pub(crate) fn check(&self, path: &Path, uri: &Uri) -> Result<PathBuf, ErrorKind> {
+    /// Checks the index for a filename. Returning the absolute path if the name is found,
+    /// otherwise returning None
+    pub(crate) fn contains_path(&self, path: &Path) -> Option<PathBuf> {
         match path.file_name() {
-            None => Err(ErrorKind::InvalidFilePath(uri.clone())),
+            None => None,
             Some(filename) => {
-                let filenamelock = self.filenames.lock().unwrap();
-                if filenamelock.contains_key(&filename.to_ascii_lowercase()) {
-                    Ok(filenamelock
-                        .get(&filename.to_ascii_lowercase())
-                        .expect("Could not retrieve inserted Path for discovered Wikilink-Path"))
+                let filename_lock = self.filenames.lock().unwrap();
+                if filename_lock.contains_key(&filename.to_ascii_lowercase()) {
+                    Some(
+                        filename_lock.get(&filename.to_ascii_lowercase()).expect(
+                            "Could not retrieve inserted Path for discovered Wikilink-Path",
+                        ),
+                    )
                     .cloned()
                 } else {
-                    Err(ErrorKind::InvalidFilePath(uri.clone()))
+                    None
                 }
             }
         }