feat: better debug impls

Author: dignifiedquire

src/client.rs

@@ -1825,32 +1825,28 @@ mod tests {
 
     #[async_attributes::test]
     async fn store() {
-        generic_store(" ", |c, set, query| {
-            async move {
-                c.lock()
-                    .await
-                    .store(set, query)
-                    .await?
-                    .collect::<Vec<_>>()
-                    .await;
-                Ok(())
-            }
+        generic_store(" ", |c, set, query| async move {
+            c.lock()
+                .await
+                .store(set, query)
+                .await?
+                .collect::<Vec<_>>()
+                .await;
+            Ok(())
         })
         .await;
     }
 
     #[async_attributes::test]
     async fn uid_store() {
-        generic_store(" UID ", |c, set, query| {
-            async move {
-                c.lock()
-                    .await
-                    .uid_store(set, query)
-                    .await?
-                    .collect::<Vec<_>>()
-                    .await;
-                Ok(())
-            }
+        generic_store(" UID ", |c, set, query| async move {
+            c.lock()
+                .await
+                .uid_store(set, query)
+                .await?
+                .collect::<Vec<_>>()
+                .await;
+            Ok(())
         })
         .await;
     }
@@ -1870,22 +1866,18 @@ mod tests {
 
     #[async_attributes::test]
     async fn copy() {
-        generic_copy(" ", |c, set, query| {
-            async move {
-                c.lock().await.copy(set, query).await?;
-                Ok(())
-            }
+        generic_copy(" ", |c, set, query| async move {
+            c.lock().await.copy(set, query).await?;
+            Ok(())
         })
         .await;
     }
 
     #[async_attributes::test]
     async fn uid_copy() {
-        generic_copy(" UID ", |c, set, query| {
-            async move {
-                c.lock().await.uid_copy(set, query).await?;
-                Ok(())
-            }
+        generic_copy(" UID ", |c, set, query| async move {
+            c.lock().await.uid_copy(set, query).await?;
+            Ok(())
         })
         .await;
     }
@@ -1944,33 +1936,29 @@ mod tests {
 
     #[async_attributes::test]
     async fn fetch() {
-        generic_fetch(" ", |c, seq, query| {
-            async move {
-                c.lock()
-                    .await
-                    .fetch(seq, query)
-                    .await?
-                    .collect::<Vec<_>>()
-                    .await;
-
-                Ok(())
-            }
+        generic_fetch(" ", |c, seq, query| async move {
+            c.lock()
+                .await
+                .fetch(seq, query)
+                .await?
+                .collect::<Vec<_>>()
+                .await;
+
+            Ok(())
         })
         .await;
     }
 
     #[async_attributes::test]
     async fn uid_fetch() {
-        generic_fetch(" UID ", |c, seq, query| {
-            async move {
-                c.lock()
-                    .await
-                    .uid_fetch(seq, query)
-                    .await?
-                    .collect::<Vec<_>>()
-                    .await;
-                Ok(())
-            }
+        generic_fetch(" UID ", |c, seq, query| async move {
+            c.lock()
+                .await
+                .uid_fetch(seq, query)
+                .await?
+                .collect::<Vec<_>>()
+                .await;
+            Ok(())
         })
         .await;
     }

src/imap_stream.rs

@@ -1,3 +1,4 @@
+use std::fmt;
 use std::pin::Pin;
 
 use async_std::io::{self, Read, Write};
@@ -45,6 +46,24 @@ enum DecodeResult {
     None(Block<'static>),
 }
 
+impl fmt::Debug for DecodeResult {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            DecodeResult::Some {
+                response,
+                buffer,
+                used,
+            } => f
+                .debug_struct("DecodeResult::Some")
+                .field("response", response)
+                .field("block", &buffer.len())
+                .field("used", used)
+                .finish(),
+            DecodeResult::None(block) => write!(f, "DecodeResult::None({})", block.len()),
+        }
+    }
+}
+
 impl<R: Read + Write + Unpin> ImapStream<R> {
     /// Creates a new `ImapStream` based on the given `Read`er.
     pub fn new(inner: R) -> Self {

src/types/response_data.rs

@@ -1,11 +1,13 @@
+use std::fmt;
+
 use byte_pool::Block;
 use imap_proto::{RequestId, Response};
 
 rental! {
     pub mod rents {
         use super::*;
 
-        #[rental(debug, covariant)]
+        #[rental(covariant)]
         pub struct ResponseData {
             raw: Block<'static>,
             response: Response<'raw>,
@@ -23,6 +25,15 @@ impl std::cmp::PartialEq for ResponseData {
 
 impl std::cmp::Eq for ResponseData {}
 
+impl fmt::Debug for ResponseData {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("ResponseData")
+            .field("raw", &self.head().len())
+            .field("response", self.suffix())
+            .finish()
+    }
+}
+
 impl ResponseData {
     pub fn request_id(&self) -> Option<&RequestId> {
         match self.suffix() {