worm_hole 1.1.3

use std::fmt::Display;

/// List of errors that the program can return.
#[derive(Debug)]
pub enum WHError {
	DatabaseConnectionError(String),
	AliasNotFound(String),
	AliasAlreadyExists(String),
	PathOfAliasNotExist(String, String),
	PatternNotMatch(String),
}

impl Display for WHError {
	#[rustfmt::skip]
	/// Display the error message.
	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
		match self {
			WHError::DatabaseConnectionError(path) => write!(f, "Error connecting to database at {}", path),
			WHError::AliasNotFound(alias) => write!(f, "Alias {} does not exist", alias),
			WHError::AliasAlreadyExists(alias) => write!(f, "Cannot create alias {} because it already exists", alias),
			WHError::PathOfAliasNotExist(alias, path) => write!(f, "The path {} does no longer exist\nRun `wormhole rm {}` to remove the alias or `wormhole edit {} <new_path>` to update the path", path, alias, alias),
			WHError::PatternNotMatch(pattern) => write!(f, "The pattern {} does not match anything", pattern),
		}
	}
}

/// Result type which wither take a type T or a WHError.
pub type WHResult<T> = std::result::Result<T, WHError>;

/// Unwrap the WHResult and print the error message if it is an error.
pub fn unwrap_worm_hole_error<T>(result: WHResult<T>) -> T {
	std::panic::set_hook(Box::new(|_| {
		// Do nothing
	}));
	match result {
		Ok(value) => value,
		Err(error) => {
			eprintln!("{}", error);
			panic!();
		}
	}
}

#[cfg(test)]
mod test {
	use super::*;

	#[test]
	fn format_error() {
		let error = WHError::DatabaseConnectionError("`arg`".to_string());
		assert_eq!(format!("{}", error), "Error connecting to database at `arg`");
		let error = WHError::AliasNotFound("`arg`".to_string());
		assert_eq!(format!("{}", error), "Alias `arg` does not exist");
		let error = WHError::AliasAlreadyExists("`arg`".to_string());
		assert_eq!(format!("{}", error), "Cannot create alias `arg` because it already exists");
		let error = WHError::PathOfAliasNotExist("`arg1`".to_string(), "`arg2`".to_string());
		assert_eq!(format!("{}", error), "The path `arg2` does no longer exist\nRun `wormhole rm `arg1`` to remove the alias or `wormhole edit `arg1` <new_path>` to update the path");
		let error = WHError::PatternNotMatch("`arg`".to_string());
		assert_eq!(format!("{}", error), "The pattern `arg` does not match anything");
	}

	#[test]
	fn get_result_when_unwrapping() {
		let result: WHResult<i32> = Ok(1);
		assert_eq!(unwrap_worm_hole_error(result), 1);
	}

	#[test]
	#[should_panic]
	fn panic_when_unwrapping_error() {
		let result: WHResult<i32> = Err(WHError::DatabaseConnectionError("path".to_string()));
		unwrap_worm_hole_error(result);
	}
}