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                 let spacing = "        ";
  70                 writeln!(f,"The compress subcommands demands at least 2 arguments, an input file and an output file.")?;
  71                 writeln!(f,"{}Example: `ouch compress img.jpeg img.zip", spacing)?;
  72                 write!(f,"{}For more information, run `ouch --help`", spacing)
  73             }
  74             Error::InternalError => {
  75                 write!(f, "{} ", "[ERROR]".red())?;
  76                 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())
  77             }
  78             _err => {
  79                 // TODO
  80                 write!(f, "")
  81             }
  82         }
  83     }
  84 }
  85
  86 impl From<std::io::Error> for Error {
  87     fn from(err: std::io::Error) -> Self {
  88         match err.kind() {
  89             std::io::ErrorKind::NotFound => panic!("{}", err),
  90             std::io::ErrorKind::PermissionDenied => Self::PermissionDenied,
  91             std::io::ErrorKind::AlreadyExists => Self::AlreadyExists,
  92             _other => {
  93                 println!("{} {}", "[IO error]".red(), err);
  94                 Self::IoError
  95             }
  96         }
  97     }
  98 }
  99
 100 impl From<zip::result::ZipError> for Error {
 101     fn from(err: zip::result::ZipError) -> Self {
 102         use zip::result::ZipError::*;
 103         match err {
 104             Io(io_err) => Self::from(io_err),
 105             InvalidArchive(filename) => Self::InvalidZipArchive(filename),
 106             FileNotFound => Self::FileNotFound("".into()),
 107             UnsupportedArchive(filename) => Self::UnsupportedZipArchive(filename),
 108         }
 109     }
 110 }
 111
 112 impl From<walkdir::Error> for Error {
 113     fn from(err: walkdir::Error) -> Self {
 114         eprintln!("{} {}", "[ERROR]".red(), err);
 115         Self::WalkdirError
 116     }
 117 }
 118
 119 impl From<oof::OofError> for Error {
 120     fn from(_err: oof::OofError) -> Self {
 121         todo!("We need to implement this properly");
 122     }
 123 }