Add all leftover public Debug impl, enforce at crate level

Author: orottier

src/capacity.rs

@@ -5,13 +5,14 @@ use crate::context::{BaseAudioContext, ConcreteBaseAudioContext};
 use crate::events::{EventDispatch, EventHandler, EventPayload, EventType};
 use crate::Event;
 
-#[derive(Copy, Clone)]
+#[derive(Copy, Clone, Debug)]
 pub(crate) struct AudioRenderCapacityLoad {
     pub render_timestamp: f64,
     pub load_value: f64,
 }
 
 /// Options for constructing an `AudioRenderCapacity`
+#[derive(Clone, Debug)]
 pub struct AudioRenderCapacityOptions {
     /// An update interval (in seconds) for dispatching [`AudioRenderCapacityEvent`]s
     pub update_interval: f64,
@@ -70,6 +71,17 @@ pub struct AudioRenderCapacity {
     stop_send: Arc<Mutex<Option<Sender<()>>>>,
 }
 
+impl std::fmt::Debug for AudioRenderCapacity {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("AudioRenderCapacity")
+            .field(
+                "context",
+                &format!("BaseAudioContext@{}", self.context.address()),
+            )
+            .finish_non_exhaustive()
+    }
+}
+
 impl AudioRenderCapacity {
     pub(crate) fn new(
         context: ConcreteBaseAudioContext,

src/context/mod.rs

@@ -1,7 +1,5 @@
 //! The `BaseAudioContext` interface and the `AudioContext` and `OfflineAudioContext` types
 
-#![deny(missing_debug_implementations)]
-
 use std::{any::Any, ops::Range};
 
 mod base;

src/lib.rs

@@ -4,6 +4,7 @@
 #![warn(clippy::missing_panics_doc)]
 #![warn(clippy::clone_on_ref_ptr)]
 #![deny(trivial_numeric_casts)]
+#![deny(missing_debug_implementations)]
 
 use std::error::Error;
 use std::sync::atomic::{AtomicU32, AtomicU64, Ordering};

src/media_devices/mod.rs

@@ -127,13 +127,14 @@ impl MediaDeviceInfo {
 
 /// Dictionary used to instruct what sort of tracks to include in the [`MediaStream`] returned by
 /// [`get_user_media_sync`]
+#[derive(Clone, Debug)]
 pub enum MediaStreamConstraints {
     Audio,
     AudioWithConstraints(MediaTrackConstraints),
 }
 
 /// Desired media stream track settings for [`MediaTrackConstraints`]
-#[derive(Default)]
+#[derive(Default, Debug, Clone)]
 #[non_exhaustive]
 pub struct MediaTrackConstraints {
     // ConstrainULong width;

src/media_recorder/mod.rs

@@ -149,6 +149,15 @@ pub struct MediaRecorder {
     inner: Arc<MediaRecorderInner>,
 }
 
+impl std::fmt::Debug for MediaRecorder {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("MediaRecorder")
+            .field("stream", &self.inner.stream)
+            .field("active", &self.inner.active)
+            .finish_non_exhaustive()
+    }
+}
+
 impl MediaRecorder {
     /// Creates a new `MediaRecorder` object, given a [`MediaStream`] to record.
     ///

src/node/mod.rs

@@ -1,7 +1,5 @@
 //! The AudioNode interface and concrete types
 
-#![deny(missing_debug_implementations)]
-
 use std::f32::consts::PI;
 use std::sync::{Arc, Mutex, OnceLock};
 

src/param.rs

@@ -1,4 +1,5 @@
 //! AudioParam interface
+
 use std::any::Any;
 use std::slice::{Iter, IterMut};
 use std::sync::atomic::Ordering;

src/periodic_wave.rs

@@ -1,4 +1,5 @@
 //! PeriodicWave interface
+
 use std::f32::consts::PI;
 use std::sync::Arc;
 

src/render/processor.rs

@@ -26,6 +26,17 @@ pub struct RenderScope {
     pub(crate) event_sender: Option<Sender<EventDispatch>>,
 }
 
+impl std::fmt::Debug for RenderScope {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let mut format = f.debug_struct("RenderScope");
+        format
+            .field("current_frame", &self.current_frame)
+            .field("current_time", &self.current_time)
+            .field("sample_rate", &self.sample_rate)
+            .finish_non_exhaustive()
+    }
+}
+
 impl RenderScope {
     pub(crate) fn send_ended_event(&self) {
         if let Some(sender) = self.event_sender.as_ref() {
@@ -154,6 +165,12 @@ pub struct AudioParamValues<'a> {
     nodes: &'a NodeCollection,
 }
 
+impl<'a> std::fmt::Debug for AudioParamValues<'a> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("AudioParamValues").finish_non_exhaustive()
+    }
+}
+
 impl<'a> AudioParamValues<'a> {
     pub(crate) fn from(nodes: &'a NodeCollection) -> Self {
         Self { nodes }

src/spatial.rs

@@ -28,6 +28,7 @@ pub(crate) const PARAM_OPTS: AudioParamDescriptor = AudioParamDescriptor {
 /// # Usage
 ///
 /// For example usage, check the [`PannerNode`](crate::node::PannerNode) docs.
+#[derive(Debug)]
 pub struct AudioListener {
     pub(crate) position_x: AudioParam,
     pub(crate) position_y: AudioParam,