Add missing fmt::Debug impls (#224)

* Add missing fmt::Debug impls

ntex-util/CHANGES.md

@@ -1,8 +1,12 @@
 # Changes
 
+## [0.3.2] - 2023-09-11
+
+* Add missing fmt::Debug impls
+
 ## [0.3.1] - 2023-06-24
 
-* Changed `BufferService` to maintain order 
+* Changed `BufferService` to maintain order
 
 * Buffer error type changed to indicate cancellation
 

ntex-util/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ntex-util"
-version = "0.3.1"
+version = "0.3.2"
 authors = ["ntex contributors <team@ntex.rs>"]
 description = "Utilities for ntex framework"
 keywords = ["network", "framework", "async", "futures"]
@@ -17,7 +17,7 @@ path = "src/lib.rs"
 
 [dependencies]
 ntex-rt = "0.4.7"
-ntex-service = "1.2.2"
+ntex-service = "1.2.6"
 bitflags = "1.3"
 fxhash = "0.2.1"
 log = "0.4"

ntex-util/src/channel/cell.rs

@@ -46,6 +46,7 @@ impl<T> Cell<T> {
     }
 }
 
+#[derive(Debug)]
 pub(super) struct WeakCell<T> {
     inner: Weak<UnsafeCell<T>>,
 }

ntex-util/src/channel/condition.rs

@@ -5,9 +5,10 @@ use super::cell::Cell;
 use crate::{future::poll_fn, task::LocalWaker};
 
 /// Condition allows to notify multiple waiters at the same time
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub struct Condition(Cell<Inner>);
 
+#[derive(Debug)]
 struct Inner {
     data: Slab<Option<LocalWaker>>,
 }
@@ -50,6 +51,7 @@ impl Drop for Condition {
     }
 }
 
+#[derive(Debug)]
 #[must_use = "Waiter do nothing unless polled"]
 pub struct Waiter {
     token: usize,

ntex-util/src/channel/mpsc.rs

@@ -124,6 +124,7 @@ impl<T> Drop for Sender<T> {
     }
 }
 
+#[derive(Debug)]
 /// Weak sender type
 pub struct WeakSender<T> {
     shared: WeakCell<Shared<T>>,

ntex-util/src/lib.rs

@@ -1,4 +1,6 @@
 //! Utilities for ntex framework
+#![deny(rust_2018_idioms, unreachable_pub, missing_debug_implementations)]
+
 pub mod channel;
 pub mod future;
 pub mod services;

ntex-util/src/services/buffer.rs

@@ -1,7 +1,7 @@
 //! Service that buffers incomming requests.
 use std::cell::{Cell, RefCell};
 use std::task::{ready, Context, Poll};
-use std::{collections::VecDeque, future::Future, marker::PhantomData, pin::Pin};
+use std::{collections::VecDeque, fmt, future::Future, marker::PhantomData, pin::Pin};
 
 use ntex_service::{IntoService, Middleware, Service, ServiceCallToCall, ServiceCtx};
 
@@ -16,16 +16,6 @@ pub struct Buffer<R> {
     _t: PhantomData<R>,
 }
 
-impl<R> Default for Buffer<R> {
-    fn default() -> Self {
-        Self {
-            buf_size: 16,
-            cancel_on_shutdown: false,
-            _t: PhantomData,
-        }
-    }
-}
-
 impl<R> Buffer<R> {
     pub fn buf_size(mut self, size: usize) -> Self {
         self.buf_size = size;
@@ -41,6 +31,25 @@ impl<R> Buffer<R> {
     }
 }
 
+impl<R> Default for Buffer<R> {
+    fn default() -> Self {
+        Self {
+            buf_size: 16,
+            cancel_on_shutdown: false,
+            _t: PhantomData,
+        }
+    }
+}
+
+impl<R> fmt::Debug for Buffer<R> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Buffer")
+            .field("buf_size", &self.buf_size)
+            .field("cancel_on_shutdown", &self.cancel_on_shutdown)
+            .finish()
+    }
+}
+
 impl<R> Clone for Buffer<R> {
     fn clone(&self) -> Self {
         Self {
@@ -127,6 +136,22 @@ where
     }
 }
 
+impl<R, S> fmt::Debug for BufferService<R, S>
+where
+    S: Service<R> + fmt::Debug,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("BufferService")
+            .field("size", &self.size)
+            .field("cancel_on_shutdown", &self.cancel_on_shutdown)
+            .field("ready", &self.ready)
+            .field("service", &self.service)
+            .field("buf", &self.buf)
+            .field("next_call", &self.next_call)
+            .finish()
+    }
+}
+
 impl<R, S> Service<R> for BufferService<R, S>
 where
     S: Service<R>,

ntex-util/src/services/counter.rs

@@ -5,8 +5,10 @@ use crate::task::LocalWaker;
 /// Simple counter with ability to notify task on reaching specific number
 ///
 /// Counter could be cloned, total count is shared across all clones.
+#[derive(Debug)]
 pub struct Counter(Rc<CounterInner>);
 
+#[derive(Debug)]
 struct CounterInner {
     count: Cell<usize>,
     capacity: usize,
@@ -40,6 +42,7 @@ impl Counter {
     }
 }
 
+#[derive(Debug)]
 pub struct CounterGuard(Rc<CounterInner>);
 
 impl CounterGuard {

ntex-util/src/services/inflight.rs

@@ -37,6 +37,7 @@ impl<S> Middleware<S> for InFlight {
     }
 }
 
+#[derive(Debug)]
 pub struct InFlightService<S> {
     count: Counter,
     service: S,

ntex-util/src/services/keepalive.rs

@@ -1,5 +1,5 @@
 use std::task::{Context, Poll};
-use std::{cell::Cell, convert::Infallible, marker, time::Duration, time::Instant};
+use std::{cell::Cell, convert::Infallible, fmt, marker, time::Duration, time::Instant};
 
 use ntex_service::{Service, ServiceCtx, ServiceFactory};
 
@@ -45,6 +45,15 @@ where
     }
 }
 
+impl<R, E, F> fmt::Debug for KeepAlive<R, E, F> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("KeepAlive")
+            .field("ka", &self.ka)
+            .field("f", &std::any::type_name::<F>())
+            .finish()
+    }
+}
+
 impl<R, E, F, C: 'static> ServiceFactory<R, C> for KeepAlive<R, E, F>
 where
     F: Fn() -> E + Clone,
@@ -86,6 +95,16 @@ where
     }
 }
 
+impl<R, E, F> fmt::Debug for KeepAliveService<R, E, F> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("KeepAliveService")
+            .field("dur", &self.dur)
+            .field("expire", &self.expire)
+            .field("f", &std::any::type_name::<F>())
+            .finish()
+    }
+}
+
 impl<R, E, F> Service<R> for KeepAliveService<R, E, F>
 where
     F: Fn() -> E,

ntex-util/src/services/onerequest.rs

@@ -22,6 +22,7 @@ impl<S> Middleware<S> for OneRequest {
     }
 }
 
+#[derive(Clone, Debug)]
 pub struct OneRequestService<S> {
     waker: LocalWaker,
     service: S,

ntex-util/src/services/variant.rs

@@ -1,5 +1,5 @@
 //! Contains `Variant` service and related types and functions.
-use std::{future::Future, marker::PhantomData, pin::Pin, task::Context, task::Poll};
+use std::{fmt, future::Future, marker::PhantomData, pin::Pin, task::Context, task::Poll};
 
 use ntex_service::{IntoServiceFactory, Service, ServiceCall, ServiceCtx, ServiceFactory};
 
@@ -46,6 +46,17 @@ where
     }
 }
 
+impl<A, AR, AC> fmt::Debug for Variant<A, AR, AC>
+where
+    A: fmt::Debug,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Variant")
+            .field("V1", &self.factory)
+            .finish()
+    }
+}
+
 macro_rules! variant_impl_and ({$fac1_type:ident, $fac2_type:ident, $name:ident, $r_name:ident, $m_name:ident, ($($T:ident),+), ($($R:ident),+)} => {
 
     #[allow(non_snake_case)]
@@ -73,7 +84,7 @@ macro_rules! variant_impl_and ({$fac1_type:ident, $fac2_type:ident, $name:ident,
 
 macro_rules! variant_impl ({$mod_name:ident, $enum_type:ident, $srv_type:ident, $fac_type:ident, $(($n:tt, $T:ident, $R:ident)),+} => {
 
-    #[allow(non_snake_case)]
+    #[allow(non_snake_case, missing_debug_implementations)]
     pub enum $enum_type<V1R, $($R),+> {
         V1(V1R),
         $($T($R),)+
@@ -96,6 +107,15 @@ macro_rules! variant_impl ({$mod_name:ident, $enum_type:ident, $srv_type:ident,
         }
     }
 
+    impl<V1: fmt::Debug, $($T: fmt::Debug,)+ V1R, $($R,)+> fmt::Debug for $srv_type<V1, $($T,)+ V1R, $($R,)+> {
+        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+            f.debug_struct(stringify!($srv_type))
+                .field("V1", &self.V1)
+                $(.field(stringify!($T), &self.$T))+
+                .finish()
+        }
+    }
+
     impl<V1, $($T,)+ V1R, $($R,)+> Service<$enum_type<V1R, $($R,)+>> for $srv_type<V1, $($T,)+ V1R, $($R,)+>
     where
         V1: Service<V1R>,
@@ -154,6 +174,15 @@ macro_rules! variant_impl ({$mod_name:ident, $enum_type:ident, $srv_type:ident,
         }
     }
 
+    impl<V1: fmt::Debug, V1C, $($T: fmt::Debug,)+ V1R, $($R,)+> fmt::Debug for $fac_type<V1, V1C, $($T,)+ V1R, $($R,)+> {
+        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+            f.debug_struct(stringify!(fac_type))
+                .field("V1", &self.V1)
+                $(.field(stringify!($T), &self.$T))+
+                .finish()
+        }
+    }
+
     impl<V1, V1C, $($T,)+ V1R, $($R,)+> ServiceFactory<$enum_type<V1R, $($R),+>, V1C> for $fac_type<V1, V1C, $($T,)+ V1R, $($R,)+>
     where
         V1: ServiceFactory<V1R, V1C>,

ntex-util/src/task.rs

@@ -58,6 +58,12 @@ impl LocalWaker {
     }
 }
 
+impl Clone for LocalWaker {
+    fn clone(&self) -> Self {
+        LocalWaker::new()
+    }
+}
+
 impl fmt::Debug for LocalWaker {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "LocalWaker")