clean up error handling

src/error.rs

@@ -0,0 +1,46 @@
+use std::fmt;
+
+#[derive(Debug)]
+pub enum Ærror {
+    IOError(String),
+    ParseError(String),
+    ApplicationError(String),
+}
+
+impl Ærror {
+    pub fn new(message: String) -> Ærror {
+        Ærror::ApplicationError(message)
+    }
+
+    pub fn new_str(message: &str) -> Ærror {
+        Ærror::ApplicationError(String::from(message))
+    }
+}
+
+impl std::error::Error for Ærror {}
+
+impl fmt::Display for Ærror {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            Ærror::IOError(message) => formatter.write_fmt(format_args!("IO Error: {}", message)),
+            Ærror::ParseError(message) => {
+                formatter.write_fmt(format_args!("Parse Error: {}", message))
+            }
+            Ærror::ApplicationError(message) => {
+                formatter.write_fmt(format_args!("Generic Error: {}", message))
+            }
+        }
+    }
+}
+
+impl From<std::io::Error> for Ærror {
+    fn from(error: std::io::Error) -> Self {
+        Ærror::IOError(error.to_string())
+    }
+}
+
+impl From<serde_json::Error> for Ærror {
+    fn from(error: serde_json::Error) -> Self {
+        Ærror::ParseError(error.to_string())
+    }
+}

src/main.rs

@@ -1,60 +1,52 @@
 use clap::Parser;
 use flate2::read::GzDecoder;
 use serde_json;
-use std::{
-    fs,
-    fs::File,
-    io::{ErrorKind, Read},
-    path::Path,
-    str::FromStr,
-};
+use std::{fs, fs::File, io::Read, path::Path, str::FromStr};
 use tar::Archive;
 
 use crate::{
     cli::GeneratorOptions,
     data::{Outbox, Person},
+    error::Ærror,
 };
 
 mod cli;
 mod data;
+mod error;
 
 fn main() {
-    let args = GeneratorOptions::parse();
+    let result = generate();
 
-    if let Err(err) = setup_dirs(&args) {
-        eprintln!("Could not create output directory");
-        eprintln!("Error: {}", err);
+    if let Err(err) = result {
+        eprintln!("{}", err);
         std::process::exit(1);
     }
+}
 
-    let archive_result = read_archive(&args);
-    if let Err(err) = archive_result {
-        eprintln!("Could not open archive file");
-        eprintln!("Error: {}", err);
-        std::process::exit(1);
-    }
+fn generate() -> Result<(), Ærror> {
+    let args = GeneratorOptions::parse();
 
-    let (_outbox_text, actor_text) = archive_result.unwrap();
-    let outbox_text = fs::read_to_string("./temp/outbox-formatted.json").unwrap();
-    let (outbox, author) = parse_json(outbox_text, actor_text);
+    setup_dirs(&args)?;
+    let (outbox_text, actor_text) = read_archive(&args)?;
+    let (outbox, author) = parse_json(outbox_text, actor_text)?;
 
     println!("{:?}\n", outbox.ordered_items.first().unwrap());
+    println!("{:?}", author);
 
-    println!("{:?}", author)
+    Ok(())
 }
 
-fn setup_dirs(args: &GeneratorOptions) -> Result<(), std::io::Error> {
+fn setup_dirs(args: &GeneratorOptions) -> Result<(), crate::error::Ærror> {
     let output_dir = Path::new(&args.output_dir);
 
     // Create output dir
     if !output_dir.exists() {
         fs::create_dir(output_dir)?;
     } else if !output_dir.read_dir()?.next().is_none() && !args.overwrite {
-        eprintln!(
-            "Error: Output directory {} exists but --overwrite not given",
+        return Err(Ærror::new(format!(
+            "Output directory {} exists but --overwrite not given",
             args.output_dir
-        );
-        std::process::exit(1);
+        )));
     } else {
         fs::remove_dir_all(output_dir)?;
         fs::create_dir(output_dir)?;
@@ -63,7 +55,7 @@ fn setup_dirs(args: &GeneratorOptions) -> Result<(), std::io::Error> {
     Ok(())
 }
 
-fn read_archive(args: &GeneratorOptions) -> Result<(String, String), std::io::Error> {
+fn read_archive(args: &GeneratorOptions) -> Result<(String, String), crate::error::Ærror> {
     let path = &args.archive_file;
 
     let tar_gz = File::open(path)?;
@@ -103,44 +95,23 @@ fn read_archive(args: &GeneratorOptions) -> Result<(String, String), std::io::Er
         }
     }
 
-    let test = if 1 > 0 { 'a' } else { 'b' };
-
     if outbox_text.len() < 1 {
-        return Err(std::io::Error::new(
-            ErrorKind::Other,
-            "No outbox.json in archive",
-        ));
+        return Err(Ærror::new_str("No outbox.json in archive"));
     }
 
     if actor_text.len() < 1 {
-        return Err(std::io::Error::new(
-            ErrorKind::Other,
-            "No actor.json in archive",
-        ));
+        return Err(Ærror::new_str("No actor.json in archive"));
     }
 
     Ok((outbox_text, actor_text))
 }
 
-fn parse_json(outbox_text: String, actor_text: String) -> (Outbox, Person) {
-    let outbox_parse: Result<Outbox, serde_json::Error> =
-        serde_json::from_str(outbox_text.as_str());
-    let actor_parse: Result<Person, serde_json::Error> = serde_json::from_str(actor_text.as_str());
-
-    if let Err(err) = outbox_parse {
-        eprintln!("Could not parse outbox file");
-        eprintln!("Error: {}", err);
-        std::process::exit(1);
-    }
-
-    if let Err(err) = actor_parse {
-        eprintln!("Could not parse actor file");
-        eprintln!("Error: {}", err);
-        std::process::exit(1);
-    }
-
-    let outbox = outbox_parse.unwrap();
-    let author = actor_parse.unwrap();
+fn parse_json(
+    outbox_text: String,
+    actor_text: String,
+) -> Result<(Outbox, Person), crate::error::Ærror> {
+    let outbox: Outbox = serde_json::from_str(outbox_text.as_str())?;
+    let actor: Person = serde_json::from_str(actor_text.as_str())?;
 
-    (outbox, author)
+    Ok((outbox, actor))
 }