src/error.rs

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