Merge pull request spicylemonade#14 from 0101coding/anyerror

Anyhow and Thiserror

Author: spicylemonade

Cargo.lock

@@ -11,5 +11,10 @@ clap = {version = "3.2.14", features = ["derive"]}
 home = "0.5.3"
 rusqlite = {version="0.28.0", features = ["chrono","bundled"]}
 chrono = "0.4.19"
+shellexpand = "2.1.0"
+
+anyhow = "1.0"
+thiserror = "1.0"
+
 opener = "0.5.0"
-tabled = "0.8.0"
+tabled = "0.8.0"

Cargo.toml

@@ -1,4 +1,5 @@
 use chrono::prelude::*;
+use anyhow::Result;
 use rusqlite::Connection;
 use std::fs;
 use std::path::Path;
@@ -45,6 +46,7 @@ macro_rules! db_connect {
     }};
 }
 
+use crate::error::PunchError;
 //database struct
 #[derive(Debug, Tabled)]
 struct Files {
@@ -55,7 +57,12 @@ struct Files {
     _action: String,
 }
 
-pub fn push(paths: &Vec<String>, action: &str, current_dir: &Path) {
+pub fn push(paths: &Vec<String>, action: &str, current_dir: &Path) -> Result<()> {
+
+    let _home_path = match home::home_dir() {
+        Some(path) => path,
+        _ => return Err(PunchError::TrashCanError.into()).into(),
+    }; 
     //accessing current date & time
     let conn = db_connect!(".punch/punch.db", conn);
 
@@ -92,16 +99,18 @@ pub fn push(paths: &Vec<String>, action: &str, current_dir: &Path) {
         )
         .expect("sql query failed");
     }
+    Ok(())
 }
 //prints db to screen
-pub fn show() {
+pub fn show() -> Result<()> {
     let table_vector = db_connect!(".punch/punch.db", pull);
 
     println!("{}", Table::new(table_vector).to_string());
+    Ok(())
 }
 
 //if the action preformed on the file was "Trash"
-fn u_trash(name: &Path, path: &Path) {
+fn u_trash(name: &Path, path: &Path) -> Result<()> {
     //systems home dir
     //check if trashed file is a directory
     let home_path = match home::home_dir() {
@@ -114,60 +123,77 @@ fn u_trash(name: &Path, path: &Path) {
         let entries = fs::read_dir(home_path.join(".punch/trash/").join(name))
             .expect("unable to parse directory");
 
-        punch::create_directory(path);
+        if let Err(_) = punch::create_directory(path) {
+             return Err(PunchError::CreateDirectoryError(path.display().to_string()).into()).into()
+        }
 
         for entry in entries {
             if let Ok(entry) = entry {
                 let file_type = entry.file_type().ok().unwrap();
                 if file_type.is_dir() {
-                    u_trash(&name.join(entry.file_name()), &path.join(entry.file_name()))
+                    u_trash(&name.join(entry.file_name()), &path.join(entry.file_name()))?
                 } else {
-                    punch::move_file(
-                        &home_path
+                    let from = &home_path
                             .join(".punch/trash/")
-                            .join(&name.join(entry.file_name())),
-                        &path.join(entry.file_name()),
-                    );
+                            .join(&name.join(entry.file_name()));
+                    let to = &path.join(entry.file_name());
+                   if let Err(_) = punch::move_file(from, to){
+                         return Err(PunchError::MoveFielError(from.display().to_string(), to.display().to_string() ).into()).into();
+                    }
                 }
             }
         }
     } else {
-        punch::move_file(
-            &home_path.join(".punch/trash/").join(name),
-            &path.join(name),
-        );
+        let from = &home_path.join(".punch/trash/").join(name);
+        let to = &path.join(name);
+        if let Err(_) = punch::move_file(from, to){
+             return Err(PunchError::MoveFielError(from.display().to_string(), to.display().to_string() ).into()).into();
+        }
     }
     //delete file in trash after
 
     if trash_file.is_dir() {
-        punch::remove_directory(&trash_file);
+        if let Err(_) = punch::remove_directory(&trash_file) {
+                return Err(PunchError::DeleteDirectoryError(trash_file.display().to_string()).into()).into()
+            }  
+        ;
     } else {
-        fs::remove_file(&trash_file)
-            .expect(format!("error deleting file: {}", &trash_file.display()).as_str());
+        if let Err(_) = punch::remove_file(&trash_file) { 
+            return Err(PunchError::DeleteFileError(trash_file.display().to_string()).into()).into()
+        } 
     }
+    Ok(())
 }
 //if the action preformed on the file was "Create"
-fn u_create(name: &Path, path: &Path) {
+fn u_create(name: &Path, path: &Path) -> Result<()> {
     if (path.join(name)).is_dir() {
-        punch::remove_directory(path.join(name).as_path());
+        if let Err(_) = punch::remove_directory(path.join(name).as_path()){
+             return Err(PunchError::DeleteDirectoryError(path.join(name).display().to_string()).into()).into();
+        }
     } else {
-        punch::remove_file(path.join(name).as_path());
+         if let Err(_) =  punch::remove_file(path.join(name).as_path()){
+             return Err(PunchError::DeleteFileError(path.join(name).display().to_string()).into()).into();
+         }
     }
+
+    Ok(())
 }
-pub fn undo() {
+pub fn undo() -> Result<()> {
     let file_iter = db_connect!(".punch/punch.db", pull);
 
     let latest_file = file_iter.last().unwrap();
 
     if latest_file._action == "Create" {
-        u_create(Path::new(&latest_file._name), Path::new(&latest_file._path));
+        u_create(Path::new(&latest_file._name), Path::new(&latest_file._path))?;
     } else if latest_file._action == "Trash" {
-        u_trash(Path::new(&latest_file._name), Path::new(&latest_file._path));
+        u_trash(Path::new(&latest_file._name), Path::new(&latest_file._path))?;
     }
+    Ok(())
 }
 
-pub fn delete(name: String) {
+pub fn delete(name: String) -> Result<()> {
     let conn = db_connect!(".punch/punch.db", conn);
     conn.execute("DELETE FROM files WHERE name=(?1)", [&name])
         .unwrap();
+        Ok(())
 }

src/db.rs

@@ -0,0 +1,27 @@
+use thiserror::Error;
+
+#[derive(Error, Debug)]
+pub enum PunchError{
+    #[error("Unable to create file {0}")]
+    CreateFileError(String),
+    #[error("Unable to create directory {0}")]
+    CreateDirectoryError(String),
+    #[error("Unable to delete file {0}")]
+    DeleteFileError(String),
+    #[error("Unable to delete directory {0}")]
+    DeleteDirectoryError(String),
+    #[error("Unable to rename file")]
+    RenameFileError,
+    #[error("Unable to copy file {0}")]
+    CopyFileError(String),
+    #[error("Unable to Trash file {0}")]
+    TrashFileError(String),
+    #[error("Unable to Create Trash Can")]
+    TrashCanError,
+    #[error("Can not find trash can in default path")]
+    TrashNotFound,
+    #[error("Can not move file from {0} to {1}")]
+    MoveFielError(String, String),
+    #[error("Some Db Error Occured")]
+    _DbError,
+}