use std::path::{Path, PathBuf};
#[non_exhaustive]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum WalkErrorKind {
SourceUnreadable,
NotADirectory,
Service,
Io,
PermissionDenied,
BrokenSymlink,
SymlinkCycle,
}
impl WalkErrorKind {
pub fn is_fatal(&self) -> bool {
matches!(
self,
WalkErrorKind::SourceUnreadable | WalkErrorKind::NotADirectory | WalkErrorKind::Service
)
}
}
#[derive(Debug)]
pub struct WalkError {
path: Option<PathBuf>,
kind: WalkErrorKind,
source: Box<dyn std::error::Error + Send + Sync>,
}
impl WalkError {
pub fn path(&self) -> Option<&Path> {
self.path.as_deref()
}
pub fn kind(&self) -> WalkErrorKind {
self.kind
}
pub fn is_fatal(&self) -> bool {
self.kind.is_fatal()
}
pub(crate) fn new(
path: Option<PathBuf>,
kind: WalkErrorKind,
source: Box<dyn std::error::Error + Send + Sync>,
) -> Self {
Self { path, kind, source }
}
pub(crate) fn into_source(self) -> Box<dyn std::error::Error + Send + Sync> {
self.source
}
pub(crate) fn classify_io(err: &std::io::Error) -> WalkErrorKind {
match err.kind() {
std::io::ErrorKind::PermissionDenied => WalkErrorKind::PermissionDenied,
std::io::ErrorKind::NotADirectory => WalkErrorKind::NotADirectory,
_ => WalkErrorKind::Io,
}
}
}
impl std::fmt::Display for WalkError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match &self.path {
Some(p) => write!(f, "walk error at {}: {}", p.display(), self.source),
None => write!(f, "walk error: {}", self.source),
}
}
}
impl std::error::Error for WalkError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
Some(&*self.source)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_classify_io_permission_denied() {
let err = std::io::Error::from(std::io::ErrorKind::PermissionDenied);
assert_eq!(
WalkError::classify_io(&err),
WalkErrorKind::PermissionDenied
);
}
#[test]
fn test_classify_io_not_a_directory() {
let err = std::io::Error::from(std::io::ErrorKind::NotADirectory);
assert_eq!(WalkError::classify_io(&err), WalkErrorKind::NotADirectory);
}
#[test]
fn test_classify_io_not_found_maps_to_io() {
let err = std::io::Error::from(std::io::ErrorKind::NotFound);
assert_eq!(WalkError::classify_io(&err), WalkErrorKind::Io);
}
#[test]
fn test_classify_io_other_maps_to_io() {
let err = std::io::Error::from(std::io::ErrorKind::ConnectionRefused);
assert_eq!(WalkError::classify_io(&err), WalkErrorKind::Io);
}
#[test]
fn test_is_fatal_by_kind() {
assert!(WalkErrorKind::SourceUnreadable.is_fatal());
assert!(WalkErrorKind::NotADirectory.is_fatal());
assert!(WalkErrorKind::Service.is_fatal());
assert!(!WalkErrorKind::Io.is_fatal());
assert!(!WalkErrorKind::PermissionDenied.is_fatal());
assert!(!WalkErrorKind::BrokenSymlink.is_fatal());
assert!(!WalkErrorKind::SymlinkCycle.is_fatal());
}
}