src/error.rs

   1 use std::{fmt, path::PathBuf};
   2
   3 use colored::Colorize;
   4
   5 #[derive(PartialEq, Eq)]
   6 pub enum Error {
   7     UnknownExtensionError(String),
   8     MissingExtensionError(PathBuf),
   9     // TODO: get rid of this error variant
  10     InvalidUnicode,
  11     InvalidInput,
  12     IoError,
  13     FileNotFound(PathBuf),
  14     AlreadyExists,
  15     InvalidZipArchive(&'static str),
  16     PermissionDenied,
  17     UnsupportedZipArchive(&'static str),
  18     InternalError,
  19     CompressingRootFolder,
  20     MissingArgumentsForCompression,
  21     WalkdirError,
  22 }
  23
  24 pub type Result<T> = std::result::Result<T, Error>;
  25
  26 impl fmt::Debug for Error {
  27     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  28         write!(f, "{}", self)
  29     }
  30 }
  31
  32 impl fmt::Display for Error {
  33     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  34         match self {
  35             Error::MissingExtensionError(filename) => {
  36                 write!(f, "{} ", "[ERROR]".red())?;
  37                 // TODO: show MIME type of the unsupported file
  38                 write!(f, "cannot compress to {:?}, likely because it has an unsupported (or missing) extension.", filename)
  39             }
  40             Error::WalkdirError => {
  41                 // Already printed in the From block
  42                 write!(f, "")
  43             }
  44             Error::FileNotFound(file) => {
  45                 write!(f, "{} ", "[ERROR]".red())?;
  46                 if file == &PathBuf::from("") {
  47                     return write!(f, "file not found!");
  48                 }
  49                 write!(f, "file {:?} not found!", file)
  50             }
  51             Error::CompressingRootFolder => {
  52                 write!(f, "{} ", "[ERROR]".red())?;
  53                 let spacing = "        ";
  54                 writeln!(f, "It seems you're trying to compress the root folder.")?;
  55                 writeln!(
  56                     f,
  57                     "{}This is unadvisable since ouch does compressions in-memory.",
  58                     spacing
  59                 )?;
  60                 write!(
  61                     f,
  62                     "{}Use a more appropriate tool for this, such as {}.",
  63                     spacing,
  64                     "rsync".green()
  65                 )
  66             }
  67             Error::MissingArgumentsForCompression => {
  68                 write!(f, "{} ", "[ERROR]".red())?;
  69                 write!(f,"The compress subcommands demands at least 2 arguments, see usage: <TODO-USAGE>")
  70             }
  71             Error::InternalError => {
  72                 write!(f, "{} ", "[ERROR]".red())?;
  73                 write!(f, "You've reached an internal error! This really should not have happened.\nPlease file an issue at {}", "https://github.com/vrmiguel/ouch".green())
  74             }
  75             _err => {
  76                 // TODO
  77                 write!(f, "")
  78             }
  79         }
  80     }
  81 }
  82
  83 impl From<std::io::Error> for Error {
  84     fn from(err: std::io::Error) -> Self {
  85         match err.kind() {
  86             std::io::ErrorKind::NotFound => panic!("{}", err),
  87             std::io::ErrorKind::PermissionDenied => Self::PermissionDenied,
  88             std::io::ErrorKind::AlreadyExists => Self::AlreadyExists,
  89             _other => {
  90                 println!("{} {}", "[IO error]".red(), err);
  91                 Self::IoError
  92             }
  93         }
  94     }
  95 }
  96
  97 impl From<zip::result::ZipError> for Error {
  98     fn from(err: zip::result::ZipError) -> Self {
  99         use zip::result::ZipError::*;
 100         match err {
 101             Io(io_err) => Self::from(io_err),
 102             InvalidArchive(filename) => Self::InvalidZipArchive(filename),
 103             FileNotFound => Self::FileNotFound("".into()),
 104             UnsupportedArchive(filename) => Self::UnsupportedZipArchive(filename),
 105         }
 106     }
 107 }
 108
 109 impl From<walkdir::Error> for Error {
 110     fn from(err: walkdir::Error) -> Self {
 111         eprintln!("{} {}", "[ERROR]".red(), err);
 112         Self::WalkdirError
 113     }
 114 }
 115
 116 impl From<oof::OofError> for Error {
 117     fn from(_err: oof::OofError) -> Self {
 118         todo!("We need to implement this properly");
 119     }
 120 }