src/error.rs

   1 //! Error types definitions.
   2 //!
   3 //! All usage errors will pass throught the Error enum, a lot of them in the Error::Custom.
   4
   5 use std::{
   6     borrow::Cow,
   7     fmt::{self, Display},
   8 };
   9
  10 use crate::{accessible::is_running_in_accessible_mode, utils::colors::*};
  11
  12 /// All errors that can be generated by `ouch`
  13 #[derive(Debug)]
  14 pub enum Error {
  15     /// Not every IoError, some of them get filtered by `From<io::Error>` into other variants
  16     IoError { reason: String },
  17     /// From lzzzz::lz4f::Error
  18     Lz4Error { reason: String },
  19     /// Detected from io::Error if .kind() is io::ErrorKind::NotFound
  20     NotFound { error_title: String },
  21     /// NEEDS MORE CONTEXT
  22     AlreadyExists { error_title: String },
  23     /// From zip::result::ZipError::InvalidArchive
  24     InvalidZipArchive(&'static str),
  25     /// Detected from io::Error if .kind() is io::ErrorKind::PermissionDenied
  26     PermissionDenied { error_title: String },
  27     /// From zip::result::ZipError::UnsupportedArchive
  28     UnsupportedZipArchive(&'static str),
  29     /// TO BE REMOVED
  30     CompressingRootFolder,
  31     /// Specialized walkdir's io::Error wrapper with additional information on the error
  32     WalkdirError { reason: String },
  33     /// Custom and unique errors are reported in this variant
  34     Custom { reason: FinalError },
  35 }
  36
  37 /// Alias to std's Result with ouch's Error
  38 pub type Result<T> = std::result::Result<T, Error>;
  39
  40 /// A string either heap-allocated or located in static storage
  41 pub type CowStr = Cow<'static, str>;
  42
  43 /// Pretty final error message for end users, crashing the program after display.
  44 #[derive(Clone, Debug, Default, PartialEq, Eq)]
  45 pub struct FinalError {
  46     /// Should be made of just one line, appears after the "\[ERROR\]" part
  47     title: CowStr,
  48     /// Shown as a unnumbered list in yellow
  49     details: Vec<CowStr>,
  50     /// Shown as green at the end to give hints on how to work around this error, if it's fixable
  51     hints: Vec<CowStr>,
  52 }
  53
  54 impl Display for FinalError {
  55     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  56         // Title
  57         //
  58         // When in ACCESSIBLE mode, the square brackets are suppressed
  59         if is_running_in_accessible_mode() {
  60             write!(f, "{}ERROR{}: {}", *RED, *RESET, self.title)?;
  61         } else {
  62             write!(f, "{}[ERROR]{} {}", *RED, *RESET, self.title)?;
  63         }
  64
  65         // Details
  66         for detail in &self.details {
  67             write!(f, "\n - {}{}{}", *YELLOW, detail, *RESET)?;
  68         }
  69
  70         // Hints
  71         if !self.hints.is_empty() {
  72             // Separate by one blank line.
  73             writeln!(f)?;
  74             // to reduce redundant output for text-to-speach systems, braille
  75             // displays and so on, only print "hints" once in ACCESSIBLE mode
  76             if is_running_in_accessible_mode() {
  77                 write!(f, "\n{}hints:{}", *GREEN, *RESET)?;
  78                 for hint in &self.hints {
  79                     write!(f, "\n{hint}")?;
  80                 }
  81             } else {
  82                 for hint in &self.hints {
  83                     write!(f, "\n{}hint:{} {}", *GREEN, *RESET, hint)?;
  84                 }
  85             }
  86         }
  87
  88         Ok(())
  89     }
  90 }
  91
  92 impl FinalError {
  93     /// Only constructor
  94     #[must_use]
  95     pub fn with_title(title: impl Into<CowStr>) -> Self {
  96         Self {
  97             title: title.into(),
  98             details: vec![],
  99             hints: vec![],
 100         }
 101     }
 102
 103     /// Add one detail line, can have multiple
 104     #[must_use]
 105     pub fn detail(mut self, detail: impl Into<CowStr>) -> Self {
 106         self.details.push(detail.into());
 107         self
 108     }
 109
 110     /// Add one hint line, can have multiple
 111     #[must_use]
 112     pub fn hint(mut self, hint: impl Into<CowStr>) -> Self {
 113         self.hints.push(hint.into());
 114         self
 115     }
 116 }
 117
 118 impl fmt::Display for Error {
 119     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 120         let err = match self {
 121             Error::WalkdirError { reason } => FinalError::with_title(reason.to_string()),
 122             Error::NotFound { error_title } => FinalError::with_title(error_title.to_string()).detail("File not found"),
 123             Error::CompressingRootFolder => {
 124                 FinalError::with_title("It seems you're trying to compress the root folder.")
 125                     .detail("This is unadvisable since ouch does compressions in-memory.")
 126                     .hint("Use a more appropriate tool for this, such as rsync.")
 127             }
 128             Error::IoError { reason } => FinalError::with_title(reason.to_string()),
 129             Error::Lz4Error { reason } => FinalError::with_title(reason.to_string()),
 130             Error::AlreadyExists { error_title } => {
 131                 FinalError::with_title(error_title.to_string()).detail("File already exists")
 132             }
 133             Error::InvalidZipArchive(reason) => FinalError::with_title("Invalid zip archive").detail(*reason),
 134             Error::PermissionDenied { error_title } => {
 135                 FinalError::with_title(error_title.to_string()).detail("Permission denied")
 136             }
 137             Error::UnsupportedZipArchive(reason) => FinalError::with_title("Unsupported zip archive").detail(*reason),
 138             Error::Custom { reason } => reason.clone(),
 139         };
 140
 141         write!(f, "{err}")
 142     }
 143 }
 144
 145 impl From<std::io::Error> for Error {
 146     fn from(err: std::io::Error) -> Self {
 147         match err.kind() {
 148             std::io::ErrorKind::NotFound => Self::NotFound {
 149                 error_title: err.to_string(),
 150             },
 151             std::io::ErrorKind::PermissionDenied => Self::PermissionDenied {
 152                 error_title: err.to_string(),
 153             },
 154             std::io::ErrorKind::AlreadyExists => Self::AlreadyExists {
 155                 error_title: err.to_string(),
 156             },
 157             _other => Self::IoError {
 158                 reason: err.to_string(),
 159             },
 160         }
 161     }
 162 }
 163
 164 impl From<lzzzz::lz4f::Error> for Error {
 165     fn from(err: lzzzz::lz4f::Error) -> Self {
 166         Self::Lz4Error {
 167             reason: err.to_string(),
 168         }
 169     }
 170 }
 171
 172 impl From<zip::result::ZipError> for Error {
 173     fn from(err: zip::result::ZipError) -> Self {
 174         use zip::result::ZipError;
 175         match err {
 176             ZipError::Io(io_err) => Self::from(io_err),
 177             ZipError::InvalidArchive(filename) => Self::InvalidZipArchive(filename),
 178             ZipError::FileNotFound => Self::Custom {
 179                 reason: FinalError::with_title("Unexpected error in zip archive").detail("File not found"),
 180             },
 181             ZipError::UnsupportedArchive(filename) => Self::UnsupportedZipArchive(filename),
 182         }
 183     }
 184 }
 185
 186 impl From<ignore::Error> for Error {
 187     fn from(err: ignore::Error) -> Self {
 188         Self::WalkdirError {
 189             reason: err.to_string(),
 190         }
 191     }
 192 }
 193
 194 impl From<FinalError> for Error {
 195     fn from(err: FinalError) -> Self {
 196         Self::Custom { reason: err }
 197     }
 198 }