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(String),
   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     InputsMustHaveBeenDecompressible(PathBuf),
  19     InternalError,
  20     CompressingRootFolder,
  21     WalkdirError,
  22 }
  23
  24 pub type Result<T> = std::result::Result<T, Error>;
  25
  26 // impl std::error::Error for Error {
  27 //     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
  28 //         // TODO: get rid of PartialEq and Eq in self::Error in order to
  29 //         // correctly use `source`.
  30 //         None
  31 //     }
  32 // }
  33
  34 impl fmt::Debug for Error {
  35     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  36         write!(f, "{}", self)
  37     }
  38 }
  39
  40 impl fmt::Display for Error {
  41     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  42         match self {
  43             Error::MissingExtensionError(filename) => {
  44                 write!(f, "{} ", "[ERROR]".red())?;
  45                 write!(f, "cannot compress to \'{}\', likely because it has an unsupported (or missing) extension.", filename)
  46             }
  47             Error::InputsMustHaveBeenDecompressible(file) => {
  48                 write!(f, "{} ", "[ERROR]".red())?;
  49                 write!(f, "file '{:?}' is not decompressible", file)
  50             }
  51             Error::WalkdirError => {
  52                 // Already printed in the From block
  53                 write!(f, "")
  54             }
  55             Error::FileNotFound(file) => {
  56                 write!(f, "{} ", "[ERROR]".red())?;
  57                 // TODO: check if file == ""
  58                 write!(f, "file {:?} not found!", file)
  59             }
  60             Error::CompressingRootFolder => {
  61                 write!(f, "{} ", "[ERROR]".red())?;
  62                 let spacing = "        ";
  63                 writeln!(f, "It seems you're trying to compress the root folder.")?;
  64                 writeln!(
  65                     f,
  66                     "{}This is unadvisable since ouch does compressions in-memory.",
  67                     spacing
  68                 )?;
  69                 write!(
  70                     f,
  71                     "{}Use a more appropriate tool for this, such as {}.",
  72                     spacing,
  73                     "rsync".green()
  74                 )
  75             }
  76             Error::InternalError => {
  77                 write!(f, "{} ", "[ERROR]".red())?;
  78                 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())
  79             }
  80             _err => {
  81                 // TODO
  82                 write!(f, "")
  83             }
  84         }
  85     }
  86 }
  87
  88 impl From<std::io::Error> for Error {
  89     fn from(err: std::io::Error) -> Self {
  90         match err.kind() {
  91             std::io::ErrorKind::NotFound => Self::FileNotFound("".into()),
  92             std::io::ErrorKind::PermissionDenied => Self::PermissionDenied,
  93             std::io::ErrorKind::AlreadyExists => Self::AlreadyExists,
  94             _other => {
  95                 println!("{} {}", "[IO error]".red(), err);
  96                 Self::IoError
  97             }
  98         }
  99     }
 100 }
 101
 102 impl From<zip::result::ZipError> for Error {
 103     fn from(err: zip::result::ZipError) -> Self {
 104         use zip::result::ZipError::*;
 105         match err {
 106             Io(io_err) => Self::from(io_err),
 107             InvalidArchive(filename) => Self::InvalidZipArchive(filename),
 108             FileNotFound => Self::FileNotFound("".into()),
 109             UnsupportedArchive(filename) => Self::UnsupportedZipArchive(filename),
 110         }
 111     }
 112 }
 113
 114 impl From<walkdir::Error> for Error {
 115     fn from(err: walkdir::Error) -> Self {
 116         eprintln!("{} {}", "[ERROR]".red(), err);
 117         Self::WalkdirError
 118     }
 119 }
 120
 121 impl From<oof::OofError> for Error {
 122     fn from(err: oof::OofError) -> Self {
 123         todo!("We need to implement this properly");
 124     }
 125 }