diff --git a/src/errors.rs b/src/errors/error.rs similarity index 60% rename from src/errors.rs rename to src/errors/error.rs index 4382aae..c2c2a36 100644 --- a/src/errors.rs +++ b/src/errors/error.rs @@ -1,66 +1,16 @@ -use std::{ - backtrace, - error::Error, - fmt::{self, Formatter}, -}; - -/// Result of Type and GDError. -pub type GDResult = Result; - -/// GameDig Error. -#[derive(Debug, Clone, PartialEq, Eq)] -pub enum GDErrorKind { - /// The received packet was bigger than the buffer size. - PacketOverflow, - /// The received packet was shorter than the expected one. - PacketUnderflow, - /// The received packet is badly formatted. - PacketBad, - /// Couldn't send the packet. - PacketSend, - /// Couldn't send the receive. - PacketReceive, - /// Couldn't decompress data. - Decompress, - /// Couldn't create a socket connection. - SocketConnect, - /// Couldn't bind a socket. - SocketBind, - /// Invalid input. - InvalidInput, - /// The server queried is not the queried game server. - BadGame, - /// Couldn't automatically query. - AutoQuery, - /// A protocol-defined expected format was not met. - ProtocolFormat, - /// Couldn't cast a value to an enum. - UnknownEnumCast, - /// Couldn't parse a json string. - JsonParse, - /// Couldn't parse a value. - TypeParse, -} - -impl GDErrorKind { - /// Convert error kind into a full error with a source (and implicit - /// backtrace) - /// - /// ``` - /// use gamedig::{GDErrorKind, GDResult}; - /// let _: GDResult = "thing".parse().map_err(|e| GDErrorKind::TypeParse.context(e)); - /// ``` - pub fn context>>(self, source: E) -> GDError { GDError::from_error(self, source) } -} +use crate::GDErrorKind; +use std::error::Error; +use std::fmt::Formatter; +use std::{backtrace, fmt}; type ErrorSource = Box; -/// Gamedig error type +/// The GameDig error type. /// /// Can be created in three ways (all of which will implicitly generate a /// backtrace): /// -/// Directly from an [error kind](crate::errors::GDErrorKind) (without a +/// Directly from an [error kind](GDErrorKind) (without a /// source). /// /// ``` @@ -68,7 +18,7 @@ type ErrorSource = Box; /// let _: GDError = GDErrorKind::PacketBad.into(); /// ``` /// -/// [From an error kind with a source](crate::errors::GDErrorKind::context) (any +/// [From an error kind with a source](GDErrorKind::context) (any /// type that implements `Into>`). /// /// ``` @@ -76,7 +26,7 @@ type ErrorSource = Box; /// let _: GDError = GDErrorKind::PacketBad.context("Reason the packet was bad"); /// ``` /// -/// Using the [new helper](crate::errors::GDError::new). +/// Using the [new helper](GDError::new). /// /// ``` /// use gamedig::{GDError, GDErrorKind}; @@ -147,38 +97,6 @@ impl GDError { mod tests { use super::*; - // Testing Ok variant of the GDResult type - #[test] - fn test_gdresult_ok() { - let result: GDResult = Ok(42); - assert_eq!(result.unwrap(), 42); - } - - // Testing Err variant of the GDResult type - #[test] - fn test_gdresult_err() { - let result: GDResult = Err(GDErrorKind::InvalidInput.into()); - assert!(result.is_err()); - } - - // Testing cloning the GDErrorKind type - #[test] - fn test_cloning() { - let error = GDErrorKind::BadGame; - let cloned_error = error.clone(); - assert_eq!(error, cloned_error); - } - - // test display GDError - #[test] - fn test_display() { - let err = GDErrorKind::BadGame.context("Rust is not a game"); - assert_eq!( - format!("{err}"), - "GDError{ kind=BadGame\n source=\"Rust is not a game\"\n backtrace=\n}\n" - ); - } - // test error trait GDError #[test] fn test_error_trait() { diff --git a/src/errors/kind.rs b/src/errors/kind.rs new file mode 100644 index 0000000..dff3be7 --- /dev/null +++ b/src/errors/kind.rs @@ -0,0 +1,71 @@ +use crate::GDError; +use std::error::Error; + +/// All GameDig Error kinds. +#[derive(Debug, Clone, PartialEq, Eq)] +pub enum GDErrorKind { + /// The received packet was bigger than the buffer size. + PacketOverflow, + /// The received packet was shorter than the expected one. + PacketUnderflow, + /// The received packet is badly formatted. + PacketBad, + /// Couldn't send the packet. + PacketSend, + /// Couldn't send the receive. + PacketReceive, + /// Couldn't decompress data. + Decompress, + /// Couldn't create a socket connection. + SocketConnect, + /// Couldn't bind a socket. + SocketBind, + /// Invalid input. + InvalidInput, + /// The server queried is not the queried game server. + BadGame, + /// Couldn't automatically query. + AutoQuery, + /// A protocol-defined expected format was not met. + ProtocolFormat, + /// Couldn't cast a value to an enum. + UnknownEnumCast, + /// Couldn't parse a json string. + JsonParse, + /// Couldn't parse a value. + TypeParse, +} + +impl GDErrorKind { + /// Convert error kind into a full error with a source (and implicit + /// backtrace) + /// + /// ``` + /// use gamedig::{GDErrorKind, GDResult}; + /// let _: GDResult = "thing".parse().map_err(|e| GDErrorKind::TypeParse.context(e)); + /// ``` + pub fn context>>(self, source: E) -> GDError { GDError::from_error(self, source) } +} + +#[cfg(test)] +mod tests { + use super::*; + + // Testing cloning the GDErrorKind type + #[test] + fn test_cloning() { + let error = GDErrorKind::BadGame; + let cloned_error = error.clone(); + assert_eq!(error, cloned_error); + } + + // test display GDError + #[test] + fn test_display() { + let err = GDErrorKind::BadGame.context("Rust is not a game"); + assert_eq!( + format!("{err}"), + "GDError{ kind=BadGame\n source=\"Rust is not a game\"\n backtrace=\n}\n" + ); + } +} diff --git a/src/errors/mod.rs b/src/errors/mod.rs new file mode 100644 index 0000000..ecfcc84 --- /dev/null +++ b/src/errors/mod.rs @@ -0,0 +1,12 @@ +//! Every GameDig errors. + +/// The Error with backtrace. +pub mod error; +/// All defined Error kinds. +pub mod kind; +/// `GDResult`, a shorthand of `Result`. +pub mod result; + +pub use error::*; +pub use kind::*; +pub use result::*; diff --git a/src/errors/result.rs b/src/errors/result.rs new file mode 100644 index 0000000..4156e26 --- /dev/null +++ b/src/errors/result.rs @@ -0,0 +1,24 @@ +use crate::GDError; + +/// `Result` of `T` and `GDError`. +pub type GDResult = Result; + +#[cfg(test)] +mod tests { + use super::*; + use crate::GDErrorKind; + + // Testing Ok variant of the GDResult type + #[test] + fn test_gdresult_ok() { + let result: GDResult = Ok(42); + assert_eq!(result.unwrap(), 42); + } + + // Testing Err variant of the GDResult type + #[test] + fn test_gdresult_err() { + let result: GDResult = Err(GDErrorKind::InvalidInput.into()); + assert!(result.is_err()); + } +}