src/error.rs

   1 use std::{fmt, path::PathBuf};
   2
   3 use colored::Colorize;
   4
   5 #[derive(PartialEq, Eq, Debug)]
   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 }
  21
  22 pub type Result<T> = std::result::Result<T, Error>;
  23
  24 impl fmt::Display for Error {
  25     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  26         write!(f, "{} ", "[ERROR]".red())?;
  27         match self {
  28             Error::MissingExtensionError(filename) => {
  29                 write!(f, "cannot compress to \'{}\', likely because it has an unsupported (or missing) extension.", filename)
  30             }
  31             Error::InputsMustHaveBeenDecompressible(file) => {
  32                 write!(f, "file '{:?}' is not decompressible", file)
  33             }
  34             Error::FileNotFound(file) => {
  35                 // TODO: check if file == ""
  36                 write!(f, "file {:?} not found!", file)
  37             }
  38             _err => {
  39                 // TODO
  40                 write!(f, "")
  41             }
  42         }
  43     }
  44 }
  45
  46 impl From<std::io::Error> for Error {
  47     fn from(err: std::io::Error) -> Self {
  48         match err.kind() {
  49             std::io::ErrorKind::NotFound => Self::FileNotFound("".into()),
  50             std::io::ErrorKind::PermissionDenied => Self::PermissionDenied,
  51             std::io::ErrorKind::AlreadyExists => Self::AlreadyExists,
  52             _other => {
  53                 println!("{}: {}", "IO error".red(), err);
  54                 Self::IoError
  55             }
  56         }
  57     }
  58 }
  59
  60 impl From<zip::result::ZipError> for Error {
  61     fn from(err: zip::result::ZipError) -> Self {
  62         use zip::result::ZipError::*;
  63         match err {
  64             Io(io_err) => Self::from(io_err),
  65             InvalidArchive(filename) => Self::InvalidZipArchive(filename),
  66             FileNotFound => Self::FileNotFound("".into()),
  67             UnsupportedArchive(filename) => Self::UnsupportedZipArchive(filename),
  68         }
  69     }
  70 }
  71
  72 impl From<walkdir::Error> for Error {
  73     fn from(err: walkdir::Error) -> Self {
  74         eprintln!("{}: {}", "error".red(), err);
  75         Self::InvalidInput
  76     }
  77 }