From 40ae556ec35db35806a2fc05d504ab4663003c9f Mon Sep 17 00:00:00 2001 From: Otavio Salvador Date: Thu, 12 Mar 2020 00:10:20 -0300 Subject: [PATCH] web: Convert from `derive_more` to `thiserror` The `thiserror` has the advantage of implementing `std::error::Error` and it integrates better with the Rust ecosystem. Signed-off-by: Otavio Salvador --- Cargo.toml | 2 +- src/error.rs | 72 ++++++++++++++++++++++------------------------ src/types/path.rs | 6 ++-- src/types/query.rs | 5 ++-- 4 files changed, 41 insertions(+), 44 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 6bd36279a..4b2ed3bfe 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -75,7 +75,6 @@ actix-http = "2.0.0-alpha.2" awc = { version = "2.0.0-alpha.1", default-features = false } bytes = "0.5.3" -derive_more = "0.99.2" encoding_rs = "0.8" futures = "0.3.1" fxhash = "0.2.1" @@ -88,6 +87,7 @@ serde = { version = "1.0", features=["derive"] } serde_json = "1.0" serde_urlencoded = "0.6.1" time = { version = "0.2.7", default-features = false, features = ["std"] } +thiserror = "1.0.11" url = "2.1" open-ssl = { version="0.10", package = "openssl", optional = true } rust-tls = { version = "0.17.0", package = "rustls", optional = true } diff --git a/src/error.rs b/src/error.rs index 31f6b9c5b..c47ac0497 100644 --- a/src/error.rs +++ b/src/error.rs @@ -1,54 +1,50 @@ //! Error and Result module pub use actix_http::error::*; -use derive_more::{Display, From}; use serde_json::error::Error as JsonError; +use thiserror::Error; use url::ParseError as UrlParseError; use crate::http::StatusCode; use crate::HttpResponse; /// Errors which can occur when attempting to generate resource uri. -#[derive(Debug, PartialEq, Display, From)] +#[derive(Debug, PartialEq, Error)] pub enum UrlGenerationError { /// Resource not found - #[display(fmt = "Resource not found")] + #[error("Resource not found")] ResourceNotFound, /// Not all path pattern covered - #[display(fmt = "Not all path pattern covered")] + #[error("Not all path pattern covered")] NotEnoughElements, /// URL parse error - #[display(fmt = "{}", _0)] - ParseError(UrlParseError), + #[error(transparent)] + ParseError(#[from] UrlParseError), } /// `InternalServerError` for `UrlGeneratorError` impl ResponseError for UrlGenerationError {} /// A set of errors that can occur during parsing urlencoded payloads -#[derive(Debug, Display, From)] +#[derive(Debug, Error)] pub enum UrlencodedError { /// Can not decode chunked transfer encoding - #[display(fmt = "Can not decode chunked transfer encoding")] + #[error("Can not decode chunked transfer encoding")] Chunked, /// Payload size is bigger than allowed. (default: 256kB) - #[display( - fmt = "Urlencoded payload size is bigger ({} bytes) than allowed (default: {} bytes)", - size, - limit - )] + #[error("Urlencoded payload size is bigger ({size} bytes) than allowed (default: {limit} bytes)")] Overflow { size: usize, limit: usize }, /// Payload size is now known - #[display(fmt = "Payload size is now known")] + #[error("Payload size is now known")] UnknownLength, /// Content type error - #[display(fmt = "Content type error")] + #[error("Content type error")] ContentType, /// Parse error - #[display(fmt = "Parse error")] + #[error("Parse error")] Parse, /// Payload error - #[display(fmt = "Error that occur during reading payload: {}", _0)] - Payload(PayloadError), + #[error("Error that occur during reading payload: {0}")] + Payload(#[from] PayloadError), } /// Return `BadRequest` for `UrlencodedError` @@ -63,20 +59,20 @@ impl ResponseError for UrlencodedError { } /// A set of errors that can occur during parsing json payloads -#[derive(Debug, Display, From)] +#[derive(Debug, Error)] pub enum JsonPayloadError { /// Payload size is bigger than allowed. (default: 32kB) - #[display(fmt = "Json payload size is bigger than allowed")] + #[error("Json payload size is bigger than allowed")] Overflow, /// Content type error - #[display(fmt = "Content type error")] + #[error("Content type error")] ContentType, /// Deserialize error - #[display(fmt = "Json deserialize error: {}", _0)] - Deserialize(JsonError), + #[error("Json deserialize error: {0}")] + Deserialize(#[from] JsonError), /// Payload error - #[display(fmt = "Error that occur during reading payload: {}", _0)] - Payload(PayloadError), + #[error("Error that occur during reading payload: {0}")] + Payload(#[from] PayloadError), } /// Return `BadRequest` for `JsonPayloadError` @@ -92,11 +88,11 @@ impl ResponseError for JsonPayloadError { } /// A set of errors that can occur during parsing request paths -#[derive(Debug, Display, From)] +#[derive(Debug, Error)] pub enum PathError { /// Deserialize error - #[display(fmt = "Path deserialize error: {}", _0)] - Deserialize(serde::de::value::Error), + #[error("Path deserialize error: {0}")] + Deserialize(#[from] serde::de::value::Error), } /// Return `BadRequest` for `PathError` @@ -107,11 +103,11 @@ impl ResponseError for PathError { } /// A set of errors that can occur during parsing query strings -#[derive(Debug, Display, From)] +#[derive(Debug, Error)] pub enum QueryPayloadError { /// Deserialize error - #[display(fmt = "Query deserialize error: {}", _0)] - Deserialize(serde::de::value::Error), + #[error("Query deserialize error: {0}")] + Deserialize(#[from] serde::de::value::Error), } /// Return `BadRequest` for `QueryPayloadError` @@ -122,21 +118,21 @@ impl ResponseError for QueryPayloadError { } /// Error type returned when reading body as lines. -#[derive(From, Display, Debug)] +#[derive(Error, Debug)] pub enum ReadlinesError { /// Error when decoding a line. - #[display(fmt = "Encoding error")] + #[error("Encoding error")] /// Payload size is bigger than allowed. (default: 256kB) EncodingError, /// Payload error. - #[display(fmt = "Error that occur during reading payload: {}", _0)] - Payload(PayloadError), + #[error("Error that occur during reading payload: {0}")] + Payload(#[from] PayloadError), /// Line limit exceeded. - #[display(fmt = "Line limit exceeded")] + #[error("Line limit exceeded")] LimitOverflow, /// ContentType error. - #[display(fmt = "Content-type error")] - ContentTypeError(ContentTypeError), + #[error("Content-type error")] + ContentTypeError(#[from] ContentTypeError), } /// Return `BadRequest` for `ReadlinesError` diff --git a/src/types/path.rs b/src/types/path.rs index a37cb8f12..58a8da243 100644 --- a/src/types/path.rs +++ b/src/types/path.rs @@ -250,15 +250,15 @@ impl Default for PathConfig { #[cfg(test)] mod tests { use actix_router::ResourceDef; - use derive_more::Display; use serde_derive::Deserialize; + use thiserror::Error; use super::*; use crate::test::TestRequest; use crate::{error, http, HttpResponse}; - #[derive(Deserialize, Debug, Display)] - #[display(fmt = "MyStruct({}, {})", key, value)] + #[derive(Deserialize, Debug, Error)] + #[error("MyStruct({key}, {value})")] struct MyStruct { key: String, value: String, diff --git a/src/types/query.rs b/src/types/query.rs index 73ea14f17..87a1d980c 100644 --- a/src/types/query.rs +++ b/src/types/query.rs @@ -224,15 +224,16 @@ impl Default for QueryConfig { #[cfg(test)] mod tests { use actix_http::http::StatusCode; - use derive_more::Display; use serde_derive::Deserialize; + use thiserror::Error; use super::*; use crate::error::InternalError; use crate::test::TestRequest; use crate::HttpResponse; - #[derive(Deserialize, Debug, Display)] + #[derive(Deserialize, Debug, Error)] + #[error("{id}")] struct Id { id: String, }