build(deps): update derive_more to v1.0 (#3453)

* build(deps): update derive_more to v1.0

* refactor: use from derive module

---------

Co-authored-by: Rob Ede <robjtede@icloud.com>

actix-http/CHANGES.md

@@ -2,6 +2,8 @@
 
 ## Unreleased
 
+- Minimum supported Rust version (MSRV) is now 1.75.
+
 ## 3.9.0
 
 ### Added

actix-http/Cargo.toml

@@ -110,7 +110,7 @@ ahash = "0.8"
 bitflags = "2"
 bytes = "1"
 bytestring = "1"
-derive_more = "0.99.5"
+derive_more = { version = "1", features = ["as_ref", "deref", "deref_mut", "display", "error", "from"] }
 encoding_rs = "0.8"
 futures-core = { version = "0.3.17", default-features = false, features = ["alloc"] }
 http = "0.2.7"
@@ -160,7 +160,7 @@ rcgen = "0.13"
 regex = "1.3"
 rustversion = "1"
 rustls-pemfile = "2"
-serde = { version = "1.0", features = ["derive"] }
+serde = { version = "1", features = ["derive"] }
 serde_json = "1.0"
 static_assertions = "1"
 tls-openssl = { package = "openssl", version = "0.10.55" }

actix-http/src/body/body_stream.rs

@@ -75,7 +75,7 @@ mod tests {
         time::{sleep, Sleep},
     };
     use actix_utils::future::poll_fn;
-    use derive_more::{Display, Error};
+    use derive_more::derive::{Display, Error};
     use futures_core::ready;
     use futures_util::{stream, FutureExt as _};
     use pin_project_lite::pin_project;
@@ -131,7 +131,7 @@ mod tests {
         assert_eq!(to_bytes(body).await.ok(), Some(Bytes::from("12")));
     }
     #[derive(Debug, Display, Error)]
-    #[display(fmt = "stream error")]
+    #[display("stream error")]
     struct StreamErr;
 
     #[actix_rt::test]

actix-http/src/body/utils.rs

@@ -3,7 +3,7 @@ use std::task::Poll;
 use actix_rt::pin;
 use actix_utils::future::poll_fn;
 use bytes::{Bytes, BytesMut};
-use derive_more::{Display, Error};
+use derive_more::derive::{Display, Error};
 use futures_core::ready;
 
 use super::{BodySize, MessageBody};
@@ -38,7 +38,7 @@ pub async fn to_bytes<B: MessageBody>(body: B) -> Result<Bytes, B::Error> {
 
 /// Error type returned from [`to_bytes_limited`] when body produced exceeds limit.
 #[derive(Debug, Display, Error)]
-#[display(fmt = "limit exceeded while collecting body bytes")]
+#[display("limit exceeded while collecting body bytes")]
 #[non_exhaustive]
 pub struct BodyLimitExceeded;
 

actix-http/src/encoding/encoder.rs

@@ -10,7 +10,7 @@ use std::{
 
 use actix_rt::task::{spawn_blocking, JoinHandle};
 use bytes::Bytes;
-use derive_more::Display;
+use derive_more::derive::Display;
 #[cfg(feature = "compress-gzip")]
 use flate2::write::{GzEncoder, ZlibEncoder};
 use futures_core::ready;
@@ -415,11 +415,11 @@ fn new_brotli_compressor() -> Box<brotli::CompressorWriter<Writer>> {
 #[non_exhaustive]
 pub enum EncoderError {
     /// Wrapped body stream error.
-    #[display(fmt = "body")]
+    #[display("body")]
     Body(Box<dyn StdError>),
 
     /// Generic I/O error.
-    #[display(fmt = "io")]
+    #[display("io")]
     Io(io::Error),
 }
 

actix-http/src/error.rs

@@ -2,7 +2,7 @@
 
 use std::{error::Error as StdError, fmt, io, str::Utf8Error, string::FromUtf8Error};
 
-use derive_more::{Display, Error, From};
+use derive_more::derive::{Display, Error, From};
 pub use http::{status::InvalidStatusCode, Error as HttpError};
 use http::{uri::InvalidUri, StatusCode};
 
@@ -80,28 +80,28 @@ impl From<Error> for Response<BoxBody> {
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Display)]
 pub(crate) enum Kind {
-    #[display(fmt = "error processing HTTP")]
+    #[display("error processing HTTP")]
     Http,
 
-    #[display(fmt = "error parsing HTTP message")]
+    #[display("error parsing HTTP message")]
     Parse,
 
-    #[display(fmt = "request payload read error")]
+    #[display("request payload read error")]
     Payload,
 
-    #[display(fmt = "response body write error")]
+    #[display("response body write error")]
     Body,
 
-    #[display(fmt = "send response error")]
+    #[display("send response error")]
     SendResponse,
 
-    #[display(fmt = "error in WebSocket process")]
+    #[display("error in WebSocket process")]
     Ws,
 
-    #[display(fmt = "connection error")]
+    #[display("connection error")]
     Io,
 
-    #[display(fmt = "encoder error")]
+    #[display("encoder error")]
     Encoder,
 }
 
@@ -160,44 +160,44 @@ impl From<crate::ws::ProtocolError> for Error {
 #[non_exhaustive]
 pub enum ParseError {
     /// An invalid `Method`, such as `GE.T`.
-    #[display(fmt = "invalid method specified")]
+    #[display("invalid method specified")]
     Method,
 
     /// An invalid `Uri`, such as `exam ple.domain`.
-    #[display(fmt = "URI error: {}", _0)]
+    #[display("URI error: {}", _0)]
     Uri(InvalidUri),
 
     /// An invalid `HttpVersion`, such as `HTP/1.1`
-    #[display(fmt = "invalid HTTP version specified")]
+    #[display("invalid HTTP version specified")]
     Version,
 
     /// An invalid `Header`.
-    #[display(fmt = "invalid Header provided")]
+    #[display("invalid Header provided")]
     Header,
 
     /// A message head is too large to be reasonable.
-    #[display(fmt = "message head is too large")]
+    #[display("message head is too large")]
     TooLarge,
 
     /// A message reached EOF, but is not complete.
-    #[display(fmt = "message is incomplete")]
+    #[display("message is incomplete")]
     Incomplete,
 
     /// An invalid `Status`, such as `1337 ELITE`.
-    #[display(fmt = "invalid status provided")]
+    #[display("invalid status provided")]
     Status,
 
     /// A timeout occurred waiting for an IO event.
     #[allow(dead_code)]
-    #[display(fmt = "timeout")]
+    #[display("timeout")]
     Timeout,
 
     /// An I/O error that occurred while trying to read or write to a network stream.
-    #[display(fmt = "I/O error: {}", _0)]
+    #[display("I/O error: {}", _0)]
     Io(io::Error),
 
     /// Parsing a field as string failed.
-    #[display(fmt = "UTF-8 error: {}", _0)]
+    #[display("UTF-8 error: {}", _0)]
     Utf8(Utf8Error),
 }
 
@@ -256,28 +256,28 @@ impl From<ParseError> for Response<BoxBody> {
 #[non_exhaustive]
 pub enum PayloadError {
     /// A payload reached EOF, but is not complete.
-    #[display(fmt = "payload reached EOF before completing: {:?}", _0)]
+    #[display("payload reached EOF before completing: {:?}", _0)]
     Incomplete(Option<io::Error>),
 
     /// Content encoding stream corruption.
-    #[display(fmt = "can not decode content-encoding")]
+    #[display("can not decode content-encoding")]
     EncodingCorrupted,
 
     /// Payload reached size limit.
-    #[display(fmt = "payload reached size limit")]
+    #[display("payload reached size limit")]
     Overflow,
 
     /// Payload length is unknown.
-    #[display(fmt = "payload length is unknown")]
+    #[display("payload length is unknown")]
     UnknownLength,
 
     /// HTTP/2 payload error.
     #[cfg(feature = "http2")]
-    #[display(fmt = "{}", _0)]
+    #[display("{}", _0)]
     Http2Payload(::h2::Error),
 
     /// Generic I/O error.
-    #[display(fmt = "{}", _0)]
+    #[display("{}", _0)]
     Io(io::Error),
 }
 
@@ -326,44 +326,44 @@ impl From<PayloadError> for Error {
 #[non_exhaustive]
 pub enum DispatchError {
     /// Service error.
-    #[display(fmt = "service error")]
+    #[display("service error")]
     Service(Response<BoxBody>),
 
     /// Body streaming error.
-    #[display(fmt = "body error: {}", _0)]
+    #[display("body error: {}", _0)]
     Body(Box<dyn StdError>),
 
     /// Upgrade service error.
-    #[display(fmt = "upgrade error")]
+    #[display("upgrade error")]
     Upgrade,
 
     /// An `io::Error` that occurred while trying to read or write to a network stream.
-    #[display(fmt = "I/O error: {}", _0)]
+    #[display("I/O error: {}", _0)]
     Io(io::Error),
 
     /// Request parse error.
-    #[display(fmt = "request parse error: {}", _0)]
+    #[display("request parse error: {}", _0)]
     Parse(ParseError),
 
     /// HTTP/2 error.
-    #[display(fmt = "{}", _0)]
+    #[display("{}", _0)]
     #[cfg(feature = "http2")]
     H2(h2::Error),
 
     /// The first request did not complete within the specified timeout.
-    #[display(fmt = "request did not complete within the specified timeout")]
+    #[display("request did not complete within the specified timeout")]
     SlowRequestTimeout,
 
     /// Disconnect timeout. Makes sense for TLS streams.
-    #[display(fmt = "connection shutdown timeout")]
+    #[display("connection shutdown timeout")]
     DisconnectTimeout,
 
     /// Handler dropped payload before reading EOF.
-    #[display(fmt = "handler dropped payload before reading EOF")]
+    #[display("handler dropped payload before reading EOF")]
     HandlerDroppedPayload,
 
     /// Internal error.
-    #[display(fmt = "internal error")]
+    #[display("internal error")]
     InternalError,
 }
 
@@ -389,11 +389,11 @@ impl StdError for DispatchError {
 #[non_exhaustive]
 pub enum ContentTypeError {
     /// Can not parse content type.
-    #[display(fmt = "could not parse content type")]
+    #[display("could not parse content type")]
     ParseError,
 
     /// Unknown content encoding.
-    #[display(fmt = "unknown content encoding")]
+    #[display("unknown content encoding")]
     UnknownEncoding,
 }
 

actix-http/src/header/shared/content_encoding.rs

@@ -1,6 +1,6 @@
 use std::str::FromStr;
 
-use derive_more::{Display, Error};
+use derive_more::derive::{Display, Error};
 use http::header::InvalidHeaderValue;
 
 use crate::{
@@ -11,7 +11,7 @@ use crate::{
 
 /// Error returned when a content encoding is unknown.
 #[derive(Debug, Display, Error)]
-#[display(fmt = "unsupported content encoding")]
+#[display("unsupported content encoding")]
 pub struct ContentEncodingParseError;
 
 /// Represents a supported content encoding.

actix-http/src/header/shared/quality.rs

@@ -1,6 +1,6 @@
 use std::fmt;
 
-use derive_more::{Display, Error};
+use derive_more::derive::{Display, Error};
 
 const MAX_QUALITY_INT: u16 = 1000;
 const MAX_QUALITY_FLOAT: f32 = 1.0;
@@ -125,7 +125,7 @@ pub fn itoa_fmt<W: fmt::Write, V: itoa::Integer>(mut wr: W, value: V) -> fmt::Re
 }
 
 #[derive(Debug, Clone, Display, Error)]
-#[display(fmt = "quality out of bounds")]
+#[display("quality out of bounds")]
 #[non_exhaustive]
 pub struct QualityOutOfBounds;
 

actix-http/src/ws/mod.rs

@@ -5,7 +5,7 @@
 
 use std::io;
 
-use derive_more::{Display, Error, From};
+use derive_more::derive::{Display, Error, From};
 use http::{header, Method, StatusCode};
 
 use crate::{body::BoxBody, header::HeaderValue, RequestHead, Response, ResponseBuilder};
@@ -27,43 +27,43 @@ pub use self::{
 #[derive(Debug, Display, Error, From)]
 pub enum ProtocolError {
     /// Received an unmasked frame from client.
-    #[display(fmt = "received an unmasked frame from client")]
+    #[display("received an unmasked frame from client")]
     UnmaskedFrame,
 
     /// Received a masked frame from server.
-    #[display(fmt = "received a masked frame from server")]
+    #[display("received a masked frame from server")]
     MaskedFrame,
 
     /// Encountered invalid opcode.
-    #[display(fmt = "invalid opcode ({})", _0)]
+    #[display("invalid opcode ({})", _0)]
     InvalidOpcode(#[error(not(source))] u8),
 
     /// Invalid control frame length
-    #[display(fmt = "invalid control frame length ({})", _0)]
+    #[display("invalid control frame length ({})", _0)]
     InvalidLength(#[error(not(source))] usize),
 
     /// Bad opcode.
-    #[display(fmt = "bad opcode")]
+    #[display("bad opcode")]
     BadOpCode,
 
     /// A payload reached size limit.
-    #[display(fmt = "payload reached size limit")]
+    #[display("payload reached size limit")]
     Overflow,
 
     /// Continuation has not started.
-    #[display(fmt = "continuation has not started")]
+    #[display("continuation has not started")]
     ContinuationNotStarted,
 
     /// Received new continuation but it is already started.
-    #[display(fmt = "received new continuation but it has already started")]
+    #[display("received new continuation but it has already started")]
     ContinuationStarted,
 
     /// Unknown continuation fragment.
-    #[display(fmt = "unknown continuation fragment: {}", _0)]
+    #[display("unknown continuation fragment: {}", _0)]
     ContinuationFragment(#[error(not(source))] OpCode),
 
     /// I/O error.
-    #[display(fmt = "I/O error: {}", _0)]
+    #[display("I/O error: {}", _0)]
     Io(io::Error),
 }
 
@@ -71,27 +71,27 @@ pub enum ProtocolError {
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Display, Error)]
 pub enum HandshakeError {
     /// Only get method is allowed.
-    #[display(fmt = "method not allowed")]
+    #[display("method not allowed")]
     GetMethodRequired,
 
     /// Upgrade header if not set to WebSocket.
-    #[display(fmt = "WebSocket upgrade is expected")]
+    #[display("WebSocket upgrade is expected")]
     NoWebsocketUpgrade,
 
     /// Connection header is not set to upgrade.
-    #[display(fmt = "connection upgrade is expected")]
+    #[display("connection upgrade is expected")]
     NoConnectionUpgrade,
 
     /// WebSocket version header is not set.
-    #[display(fmt = "WebSocket version header is required")]
+    #[display("WebSocket version header is required")]
     NoVersionHeader,
 
     /// Unsupported WebSocket version.
-    #[display(fmt = "unsupported WebSocket version")]
+    #[display("unsupported WebSocket version")]
     UnsupportedVersion,
 
     /// WebSocket key is not set or wrong.
-    #[display(fmt = "unknown WebSocket key")]
+    #[display("unknown WebSocket key")]
     BadWebsocketKey,
 }
 

actix-http/tests/test_client.rs

@@ -5,7 +5,7 @@ use actix_http_test::test_server;
 use actix_service::ServiceFactoryExt;
 use actix_utils::future;
 use bytes::Bytes;
-use derive_more::{Display, Error};
+use derive_more::derive::{Display, Error};
 use futures_util::StreamExt as _;
 
 const STR: &str = "Hello World Hello World Hello World Hello World Hello World \
@@ -94,7 +94,7 @@ async fn with_query_parameter() {
 }
 
 #[derive(Debug, Display, Error)]
-#[display(fmt = "expect failed")]
+#[display("expect failed")]
 struct ExpectFailed;
 
 impl From<ExpectFailed> for Response<BoxBody> {

actix-http/tests/test_openssl.rs

@@ -14,7 +14,7 @@ use actix_http_test::test_server;
 use actix_service::{fn_service, ServiceFactoryExt};
 use actix_utils::future::{err, ok, ready};
 use bytes::{Bytes, BytesMut};
-use derive_more::{Display, Error};
+use derive_more::derive::{Display, Error};
 use futures_core::Stream;
 use futures_util::{stream::once, StreamExt as _};
 use openssl::{
@@ -398,7 +398,7 @@ async fn h2_response_http_error_handling() {
 }
 
 #[derive(Debug, Display, Error)]
-#[display(fmt = "error")]
+#[display("error")]
 struct BadRequest;
 
 impl From<BadRequest> for Response<BoxBody> {

actix-http/tests/test_rustls.rs

@@ -23,7 +23,7 @@ use actix_service::{fn_factory_with_config, fn_service};
 use actix_tls::connect::rustls_0_23::webpki_roots_cert_store;
 use actix_utils::future::{err, ok, poll_fn};
 use bytes::{Bytes, BytesMut};
-use derive_more::{Display, Error};
+use derive_more::derive::{Display, Error};
 use futures_core::{ready, Stream};
 use futures_util::stream::once;
 use rustls::{pki_types::ServerName, ServerConfig as RustlsServerConfig};
@@ -480,7 +480,7 @@ async fn h2_response_http_error_handling() {
 }
 
 #[derive(Debug, Display, Error)]
-#[display(fmt = "error")]
+#[display("error")]
 struct BadRequest;
 
 impl From<BadRequest> for Response<BoxBody> {

actix-http/tests/test_server.rs

@@ -14,7 +14,7 @@ use actix_rt::{net::TcpStream, time::sleep};
 use actix_service::fn_service;
 use actix_utils::future::{err, ok, ready};
 use bytes::Bytes;
-use derive_more::{Display, Error};
+use derive_more::derive::{Display, Error};
 use futures_util::{stream::once, FutureExt as _, StreamExt as _};
 use regex::Regex;
 
@@ -62,7 +62,7 @@ async fn h1_2() {
 }
 
 #[derive(Debug, Display, Error)]
-#[display(fmt = "expect failed")]
+#[display("expect failed")]
 struct ExpectFailed;
 
 impl From<ExpectFailed> for Response<BoxBody> {
@@ -723,7 +723,7 @@ async fn h1_response_http_error_handling() {
 }
 
 #[derive(Debug, Display, Error)]
-#[display(fmt = "error")]
+#[display("error")]
 struct BadRequest;
 
 impl From<BadRequest> for Response<BoxBody> {

actix-http/tests/test_ws.rs

@@ -14,7 +14,7 @@ use actix_http::{
 use actix_http_test::test_server;
 use actix_service::{fn_factory, Service};
 use bytes::Bytes;
-use derive_more::{Display, Error, From};
+use derive_more::derive::{Display, Error, From};
 use futures_core::future::LocalBoxFuture;
 use futures_util::{SinkExt as _, StreamExt as _};
 
@@ -37,16 +37,16 @@ impl WsService {
 
 #[derive(Debug, Display, Error, From)]
 enum WsServiceError {
-    #[display(fmt = "HTTP error")]
+    #[display("HTTP error")]
     Http(actix_http::Error),
 
-    #[display(fmt = "WS handshake error")]
+    #[display("WS handshake error")]
     Ws(actix_http::ws::HandshakeError),
 
-    #[display(fmt = "I/O error")]
+    #[display("I/O error")]
     Io(std::io::Error),
 
-    #[display(fmt = "dispatcher error")]
+    #[display("dispatcher error")]
     Dispatcher,
 }