refactor: improve error handling, add custom Error structs (#28)

Author: Trojan295

Cargo.lock

@@ -18,7 +18,6 @@ serde = "1.0"
 serde_derive = "1.0"
 clap = { version = "3.0.0", features = ["derive", "cargo"] }
 dirs = "3.0"
-simple-error = "0.2"
 regex = "1"
 reqwest = { version = "0.10", features = ["blocking"] }
 openssl = { version = "0.10", features = ["vendored"] }

Cargo.toml

@@ -1,14 +1,14 @@
+use crate::errors::{Error, Result};
 use crate::htmlparser;
 
-use super::errors::ErrorChain;
 use html5ever::tendril::TendrilSink;
 use html5ever::{self, tree_builder::TreeBuilderOpts, ParseOpts};
 use markup5ever_rcdom::{Node, NodeData, RcDom};
 use regex::Regex;
 use std::fs::{self, File};
 use std::io::{self, BufRead};
 use std::path::{Path, PathBuf};
-use std::{error::Error, rc::Rc};
+use std::rc::Rc;
 use tempfile::tempfile;
 use walkdir::WalkDir;
 
@@ -20,7 +20,7 @@ pub struct Addon {
 
 pub struct AddonList {
     pub addons: Vec<Addon>,
-    pub errors: Vec<Box<dyn Error>>,
+    pub errors: Vec<Error>,
 }
 
 pub struct Manager {
@@ -39,14 +39,23 @@ impl Manager {
         Manager { addon_dir: path }
     }
 
-    pub fn get_addons(&self) -> Result<AddonList, Box<dyn Error>> {
+    pub fn get_addons(&self) -> Result<AddonList> {
         let mut addon_list = AddonList {
             addons: vec![],
             errors: vec![],
         };
 
+        if let Err(err) = fs::metadata(&self.addon_dir) {
+            return Err(Error::CannotOpenAddonDirectory(
+                self.addon_dir.clone(),
+                Box::new(err),
+            ));
+        }
+
         for entry in WalkDir::new(&self.addon_dir) {
-            let entry_dir = entry?;
+            let entry_dir = entry.map_err(|err| {
+                Error::CannotOpenAddonDirectory(self.addon_dir.clone(), Box::new(err))
+            })?;
             let file_path = entry_dir.path();
 
             let file_name = entry_dir.file_name();
@@ -67,31 +76,25 @@ impl Manager {
 
             match self.read_addon(addon_dir) {
                 Ok(addon) => addon_list.addons.push(addon),
-                Err(err) => addon_list
-                    .errors
-                    .push(format!("while reading addon {:?}: {}", file_path, err).into()),
+                Err(err) => addon_list.errors.push(err),
             }
         }
 
         Ok(addon_list)
     }
 
-    pub fn get_addon(&self, name: &str) -> Result<Option<Addon>, Box<dyn Error>> {
-        let addon_list = self.get_addons().chain_err("while getting addons")?;
+    pub fn get_addon(&self, name: &str) -> Result<Option<Addon>> {
+        let addon_list = self.get_addons()?;
         let found = addon_list.addons.into_iter().find(|x| x.name == name);
         Ok(found)
     }
 
-    fn read_addon(&self, path: &Path) -> Result<Addon, Box<dyn Error>> {
-        let addon_name = path
-            .file_name()
-            .ok_or(simple_error!("cannot get filename"))?;
-
-        let addon_name = addon_name
-            .to_str()
-            .ok_or(simple_error!("failed to get addon name"))?;
+    fn read_addon(&self, path: &Path) -> Result<Addon> {
+        let addon_name = path.file_name().unwrap().to_str().unwrap();
 
-        let file = self.open_addon_metadata_file(path, addon_name)?;
+        let file = self
+            .open_addon_metadata_file(path, addon_name)
+            .map_err(|err| Error::CannotReadAddon(addon_name.to_owned(), Box::new(err)))?;
         let re = Regex::new(r"## (.*): (.*)").unwrap();
 
         let mut addon = Addon {
@@ -124,17 +127,18 @@ impl Manager {
         Ok(addon)
     }
 
-    pub fn delete_addon(&self, addon: &Addon) -> Result<(), Box<dyn Error>> {
+    pub fn delete_addon(&self, addon: &Addon) -> Result<()> {
         let mut addon_path = self.addon_dir.to_owned();
         addon_path.push(&addon.name);
 
-        fs::remove_dir_all(addon_path).chain_err("while removing addon directory")?;
-
+        fs::remove_dir_all(addon_path)
+            .map_err(|err| Error::CannotRemoveAddon(addon.name.to_owned(), Box::new(err)))?;
         Ok(())
     }
 
-    pub fn download_addon(&self, url: &str) -> Result<Addon, Box<dyn Error>> {
-        let mut response = reqwest::blocking::get(url)?;
+    pub fn download_addon(&self, url: &str) -> Result<Addon> {
+        let mut response = reqwest::blocking::get(url)
+            .map_err(|err| Error::CannotDownloadAddon(url.to_owned(), Box::new(err)))?;
 
         let opts = ParseOpts {
             tree_builder: TreeBuilderOpts {
@@ -150,17 +154,25 @@ impl Manager {
 
         let download_link = get_cdn_download_link(&dom);
 
-        let download_link =
-            download_link.ok_or(simple_error!("failed to get CDN download link"))?;
+        let download_link = download_link.ok_or(Error::CannotDownloadAddon(
+            url.to_owned(),
+            "failed to get CDN download link".into(),
+        ))?;
 
-        let mut response = reqwest::blocking::get(&download_link)?;
+        let mut response = reqwest::blocking::get(&download_link)
+            .map_err(|err| Error::CannotDownloadAddon(url.to_owned(), Box::new(err)))?;
 
         let mut tmpfile = tempfile()?;
-        response.copy_to(&mut tmpfile)?;
-        let mut archive = zip::ZipArchive::new(tmpfile)?;
+        response
+            .copy_to(&mut tmpfile)
+            .map_err(|err| Error::CannotDownloadAddon(url.to_owned(), Box::new(err)))?;
+        let mut archive = zip::ZipArchive::new(tmpfile)
+            .map_err(|err| Error::CannotDownloadAddon(url.to_owned(), Box::new(err)))?;
 
         for i in 0..archive.len() {
-            let mut file = archive.by_index(i)?;
+            let mut file = archive
+                .by_index(i)
+                .map_err(|err| Error::CannotDownloadAddon(url.to_owned(), Box::new(err)))?;
             let outpath = match file.enclosed_name() {
                 Some(path) => {
                     let mut p = self.addon_dir.clone();
@@ -171,36 +183,37 @@ impl Manager {
                 None => continue,
             };
 
-            if (&*file.name()).ends_with('/') {
-                fs::create_dir_all(&outpath).unwrap();
+            if (file.name()).ends_with('/') {
+                fs::create_dir_all(&outpath)
+                    .map_err(|err| Error::CannotDownloadAddon(url.to_owned(), Box::new(err)))?;
             } else {
                 if let Some(p) = outpath.parent() {
                     if !p.exists() {
-                        fs::create_dir_all(&p).unwrap();
+                        fs::create_dir_all(&p).map_err(|err| {
+                            Error::CannotDownloadAddon(url.to_owned(), Box::new(err))
+                        })?;
                     }
                 }
-                let mut outfile = fs::File::create(&outpath).unwrap();
-                io::copy(&mut file, &mut outfile).unwrap();
+                let mut outfile = fs::File::create(&outpath)
+                    .map_err(|err| Error::CannotDownloadAddon(url.to_owned(), Box::new(err)))?;
+                io::copy(&mut file, &mut outfile)
+                    .map_err(|err| Error::CannotDownloadAddon(url.to_owned(), Box::new(err)))?;
             }
         }
 
         let mut addon_path = self.addon_dir.to_owned();
-        let addon_name = archive.by_index(0)?;
+        let addon_name = archive
+            .by_index(0)
+            .map_err(|err| Error::CannotDownloadAddon(url.to_owned(), Box::new(err)))?;
         let addon_name = get_root_dir(&addon_name.mangled_name());
         addon_path.push(addon_name);
 
-        let addon = self
-            .read_addon(&addon_path)
-            .chain_err("while reading addon")?;
+        let addon = self.read_addon(&addon_path)?;
 
         Ok(addon)
     }
 
-    fn open_addon_metadata_file(
-        &self,
-        path: &Path,
-        addon_name: &str,
-    ) -> Result<File, Box<dyn Error>> {
+    fn open_addon_metadata_file(&self, path: &Path, addon_name: &str) -> Result<File> {
         let mut filepath = path.to_owned();
         let mut filepath_lowercase = path.to_owned();
 
@@ -211,12 +224,11 @@ impl Manager {
         filepath_lowercase.push(filename_lowercase);
 
         if filepath.exists() {
-            File::open(&filepath).chain_err(&format!("failed to open {:?}", &filepath))
+            File::open(&filepath).map_err(|err| Error::Other(Box::new(err)))
         } else if filepath_lowercase.exists() {
-            File::open(&filepath_lowercase)
-                .chain_err(&format!("failed to open {:?}", &filepath_lowercase))
+            File::open(&filepath_lowercase).map_err(|err| Error::Other(Box::new(err)))
         } else {
-            Err("metadata file is missing".into())
+            Err(Error::Other("missing addon metadata file".into()))
         }
     }
 }
@@ -253,16 +265,13 @@ pub fn get_download_url(addon_url: &str) -> Option<String> {
     let fns: Vec<fn(&str) -> Option<String>> = vec![
         |url: &str| {
             let re = Regex::new(r"^https://.*esoui\.com/downloads/info(\d+)-(.+)$").unwrap();
-            re.captures(url).map(|captures| {
-                captures[1].to_owned()
-            })
+            re.captures(url).map(|captures| captures[1].to_owned())
         },
         |url: &str| {
-            let re = Regex::new(r"^https://.+esoui\.com/downloads/fileinfo\.php\?id=(\d+)$").unwrap();
-            re.captures(url).map(|captures| {
-                captures[1].to_owned()
-            })
-        }
+            let re =
+                Regex::new(r"^https://.+esoui\.com/downloads/fileinfo\.php\?id=(\d+)$").unwrap();
+            re.captures(url).map(|captures| captures[1].to_owned())
+        },
     ];
 
     for f in fns {

src/addons.rs

@@ -3,12 +3,13 @@ use eso_addons::{
     addons,
     addons::Manager,
     config::{self, AddonEntry, Config},
-    errors::ErrorChain,
     htmlparser,
 };
 use html5ever::{tendril::TendrilSink, tree_builder::TreeBuilderOpts, ParseOpts};
 use markup5ever_rcdom::{Node, NodeData, RcDom};
-use std::{error::Error, path::Path, rc::Rc};
+use std::{path::Path, rc::Rc};
+
+use super::{Error, Result};
 
 #[derive(Parser)]
 pub struct AddCommand {
@@ -28,17 +29,15 @@ impl AddCommand {
         cfg: &mut Config,
         config_filepath: &Path,
         addon_manager: &Manager,
-    ) -> Result<(), Box<dyn std::error::Error>> {
+    ) -> Result<()> {
         let mut entry = self.get_entry()?;
 
         if cfg.addons.iter().find(|el| el.url == entry.url).is_some() {
             println!("Addon {} is already installed", &entry.name);
             return Ok(());
         }
 
-        let installed = addon_manager
-            .download_addon(&entry.url.clone().unwrap())
-            .chain_err(&format!("while downloading {}", &entry.name))?;
+        let installed = addon_manager.download_addon(&entry.url.clone().unwrap())?;
 
         if entry.name != installed.name {
             entry.name = installed.name;
@@ -53,16 +52,19 @@ impl AddCommand {
         Ok(())
     }
 
-    pub fn get_entry(&mut self) -> Result<AddonEntry, Box<dyn Error>> {
+    pub fn get_entry(&mut self) -> Result<AddonEntry> {
         if self.addon_url.is_none() {
-            self.ask_for_fields()
-                .chain_err(&format!("failed to get parameters"))?;
+            self.ask_for_fields()?;
         }
 
-        let addon_url = self.addon_url.clone().ok_or("missing addon URL")?;
+        let addon_url = self
+            .addon_url
+            .clone()
+            .ok_or(Error::Other("missing addon URL".into()))?;
         let dependency = self.dependency;
 
-        let mut response = reqwest::blocking::get(&addon_url)?;
+        let mut response =
+            reqwest::blocking::get(&addon_url).map_err(|err| Error::Other(Box::new(err)))?;
 
         let opts = ParseOpts {
             tree_builder: TreeBuilderOpts {
@@ -74,9 +76,11 @@ impl AddCommand {
 
         let dom = html5ever::parse_document(RcDom::default(), opts)
             .from_utf8()
-            .read_from(&mut response)?;
+            .read_from(&mut response)
+            .map_err(|err| Error::Other(Box::new(err)))?;
 
-        let addon_name = get_addon_name(&dom).ok_or(simple_error!("failed to get addon name"))?;
+        let addon_name =
+            get_addon_name(&dom).ok_or(Error::Other("failed to get addon name".into()))?;
         let download_url = addons::get_download_url(&addon_url);
 
         Ok(AddonEntry {
@@ -86,7 +90,7 @@ impl AddCommand {
         })
     }
 
-    fn ask_for_fields(&mut self) -> Result<(), Box<dyn std::error::Error>> {
+    fn ask_for_fields(&mut self) -> Result<()> {
         let questions = vec![
             requestty::Question::input("addon_url")
                 .message("URL of the addon on esoui.com")
@@ -97,7 +101,7 @@ impl AddCommand {
                 .build(),
         ];
 
-        let answers = requestty::prompt(questions)?;
+        let answers = requestty::prompt(questions).map_err(|err| Error::Other(Box::new(err)))?;
 
         if let Some(addon_url) = answers.get("addon_url") {
             self.addon_url = addon_url.as_string().map(|x| x.to_owned());

src/cli/add.rs

@@ -0,0 +1,28 @@
+#[derive(Debug)]
+pub enum Error {
+    AddonNotFound(String),
+    NoAddonsInstalled,
+    AppError(eso_addons::errors::Error),
+    Other(Box<dyn std::error::Error>),
+}
+
+impl std::fmt::Display for Error {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match &self {
+            Self::AddonNotFound(name) => f.write_str(&format!("addon {} not found", &name)),
+            Self::NoAddonsInstalled => f.write_str("no addons installed"),
+            Self::AppError(err) => f.write_str(&format!("app error: {}", err)),
+            Self::Other(err) => f.write_str(&format!("other error: {}", err)),
+        }
+    }
+}
+
+impl std::error::Error for Error {}
+
+impl From<eso_addons::errors::Error> for Error {
+    fn from(err: eso_addons::errors::Error) -> Self {
+        Self::AppError(err)
+    }
+}
+
+pub type Result<T> = std::result::Result<T, Error>;

src/cli/errors.rs

@@ -5,15 +5,13 @@ use eso_addons::addons::Manager;
 use eso_addons::config::Config;
 use prettytable::{format, Table};
 
+use super::Result;
+
 #[derive(Parser)]
 pub struct ListCommand {}
 
 impl ListCommand {
-    pub fn run(
-        &self,
-        addon_manager: &Manager,
-        config: &Config,
-    ) -> Result<(), Box<dyn std::error::Error>> {
+    pub fn run(&self, addon_manager: &Manager, config: &Config) -> Result<()> {
         let mut table = Table::new();
 
         let mut addon_status: BTreeMap<String, Vec<String>> = BTreeMap::new();