add unreachable_pub lint and fix debug impl

8 files changed, 73 insertions, 9 deletions

diff --git a/mumd/src/audio.rs b/mumd/src/audio.rs
index 2e20583..fa22188 100644
--- a/mumd/src/audio.rs
+++ b/mumd/src/audio.rs
@@ -112,6 +112,16 @@ impl AudioInput {
     }
 }
 
+impl Debug for AudioInput {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("AudioInput")
+            .field("device", &self.device)
+            .field("channel_receiver", &"receiver")
+            .finish()
+    }
+}
+
+#[derive(Debug)]
 pub struct AudioOutput {
     device: DefaultAudioOutputDevice,
     user_volumes: Arc<Mutex<HashMap<u32, (f32, bool)>>>,
diff --git a/mumd/src/audio/input.rs b/mumd/src/audio/input.rs
index a1227e3..2a904d9 100644
--- a/mumd/src/audio/input.rs
+++ b/mumd/src/audio/input.rs
@@ -1,6 +1,7 @@
 use cpal::traits::{DeviceTrait, HostTrait, StreamTrait};
 use cpal::{InputCallbackInfo, Sample, SampleFormat, SampleRate, StreamConfig};
 use log::*;
+use std::fmt::Debug;
 use tokio::sync::watch;
 
 use crate::audio::SAMPLE_RATE;
@@ -177,3 +178,14 @@ impl AudioInputDevice for DefaultAudioInputDevice {
         self.channels as usize
     }
 }
+
+impl Debug for DefaultAudioInputDevice {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("DefaultAudioInputDevice")
+            .field("sample_receiver", &self.sample_receiver)
+            .field("channels", &self.channels)
+            .field("volume_sender", &self.volume_sender)
+            .field("stream", &"cpal::Stream")
+            .finish()
+    }
+}
diff --git a/mumd/src/audio/output.rs b/mumd/src/audio/output.rs
index a2f6bcc..cdbe336 100644
--- a/mumd/src/audio/output.rs
+++ b/mumd/src/audio/output.rs
@@ -7,12 +7,14 @@ use cpal::{OutputCallbackInfo, Sample, SampleFormat, SampleRate, StreamConfig};
 use log::*;
 use mumble_protocol::voice::VoicePacketPayload;
 use std::collections::{HashMap, VecDeque};
+use std::fmt::Debug;
 use std::ops::AddAssign;
 use std::sync::{Arc, Mutex};
 use tokio::sync::watch;
 
 type ClientStreamKey = (VoiceStreamType, u32);
 
+#[derive(Debug)]
 pub struct ClientStream {
     buffer_clients: HashMap<ClientStreamKey, (VecDeque<f32>, opus::Decoder)>, //TODO ring buffer?
     buffer_effects: VecDeque<f32>,
@@ -242,3 +244,14 @@ pub fn curry_callback<T: Sample + AddAssign + SaturatingAdd + std::fmt::Display>
         }
     }
 }
+
+impl Debug for DefaultAudioOutputDevice {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("DefaultAudioInputDevice")
+            .field("client_streams", &self.client_streams)
+            .field("config", &self.config)
+            .field("volume_sender", &self.volume_sender)
+            .field("stream", &"cpal::Stream")
+            .finish()
+    }
+}
diff --git a/mumd/src/audio/transformers.rs b/mumd/src/audio/transformers.rs
index 25e28b8..74d751a 100644
--- a/mumd/src/audio/transformers.rs
+++ b/mumd/src/audio/transformers.rs
@@ -6,6 +6,7 @@ pub trait Transformer {
 }
 
 /// A struct representing a noise gate transform.
+#[derive(Debug)]
 pub struct NoiseGate {
     alltime_high: f32,
     open: usize,
diff --git a/mumd/src/error.rs b/mumd/src/error.rs
index da1bdd3..4277d7f 100644
--- a/mumd/src/error.rs
+++ b/mumd/src/error.rs
@@ -5,6 +5,7 @@ use tokio::sync::mpsc;
 
 pub type ServerSendError = mpsc::error::SendError<ControlPacket<Serverbound>>;
 
+#[derive(Debug)]
 pub enum TcpError {
     NoConnectionInfoReceived,
     TlsConnectorBuilderError(native_tls::Error),
@@ -40,6 +41,7 @@ impl From<ServerSendError> for TcpError {
     }
 }
 
+#[derive(Debug)]
 pub enum UdpError {
     NoConnectionInfoReceived,
     DisconnectBeforeCryptSetup,
@@ -53,6 +55,7 @@ impl From<std::io::Error> for UdpError {
     }
 }
 
+#[derive(Debug)]
 pub enum ClientError {
     TcpError(TcpError),
 }
@@ -65,6 +68,7 @@ impl fmt::Display for ClientError {
     }
 }
 
+#[derive(Debug)]
 pub enum AudioStream {
     Input,
     Output,
@@ -79,6 +83,7 @@ impl fmt::Display for AudioStream {
     }
 }
 
+#[derive(Debug)]
 pub enum AudioError {
     NoDevice(AudioStream),
     NoConfigs(AudioStream, cpal::SupportedStreamConfigsError),
@@ -105,6 +110,7 @@ impl fmt::Display for AudioError {
     }
 }
 
+#[derive(Debug)]
 pub enum StateError {
     AudioError(AudioError),
     ConfigError(ConfigError),
diff --git a/mumd/src/main.rs b/mumd/src/main.rs
index 29ea77f..6b863c1 100644
--- a/mumd/src/main.rs
+++ b/mumd/src/main.rs
@@ -1,18 +1,19 @@
 #![warn(elided_lifetimes_in_paths)]
 #![warn(meta_variable_misuse)]
-#![warn(missing_debug_implementations)] //doesn't seem to work
+#![warn(missing_debug_implementations)]
 #![warn(single_use_lifetimes)]
+#![warn(unreachable_pub)]
 #![deny(keyword_idents)]
 #![deny(macro_use_extern_crate)]
 #![deny(missing_abi)]
 
-mod audio;
-mod client;
-mod command;
-mod error;
-mod network;
-mod notifications;
-mod state;
+pub mod audio;
+pub mod client;
+pub mod command;
+pub mod error;
+pub mod network;
+pub mod notifications;
+pub mod state;
 
 use crate::state::State;
 
diff --git a/mumd/src/network/tcp.rs b/mumd/src/network/tcp.rs
index a76814c..f68dd31 100644
--- a/mumd/src/network/tcp.rs
+++ b/mumd/src/network/tcp.rs
@@ -14,6 +14,7 @@ use mumble_protocol::{Clientbound, Serverbound};
 use mumlib::command::MumbleEventKind;
 use std::collections::HashMap;
 use std::convert::{Into, TryInto};
+use std::fmt::Debug;
 use std::net::SocketAddr;
 use std::sync::{Arc, RwLock};
 use tokio::net::TcpStream;
@@ -57,7 +58,7 @@ pub enum TcpEvent {
 /// Having two different types might feel a bit confusing. Essentially, a
 /// callback _registers_ to a [TcpEvent] but _takes_ a [TcpEventData] as
 /// parameter.
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub enum TcpEventData<'a> {
     Connected(Result<&'a msgs::ServerSync, mumlib::Error>),
     Disconnected(DisconnectedReason),
@@ -139,6 +140,13 @@ impl TcpEventQueue {
     }
 }
 
+impl Debug for TcpEventQueue {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("TcpEventQueue")
+            .finish()
+    }
+}
+
 pub async fn handle(
     state: Arc<RwLock<State>>,
     mut connection_info_receiver: watch::Receiver<Option<ConnectionInfo>>,
diff --git a/mumd/src/state.rs b/mumd/src/state.rs
index 38d54d3..82810de 100644
--- a/mumd/src/state.rs
+++ b/mumd/src/state.rs
@@ -20,6 +20,7 @@ use mumlib::command::{ChannelTarget, Command, CommandResponse, MessageTarget, Mu
 use mumlib::config::Config;
 use mumlib::Error;
 use std::{
+    fmt::Debug,
     iter,
     net::{SocketAddr, ToSocketAddrs},
     sync::{Arc, RwLock},
@@ -63,6 +64,17 @@ pub enum ExecutionContext {
     ),
 }
 
+impl Debug for ExecutionContext {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_tuple(match self {
+            ExecutionContext::TcpEventCallback(_) => "TcpEventCallback",
+            ExecutionContext::TcpEventSubscriber(_, _) => "TcpEventSubscriber",
+            ExecutionContext::Now(_) => "Now",
+            ExecutionContext::Ping(_, _) => "Ping",
+        }).finish()
+    }
+}
+
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 pub enum StatePhase {
     Disconnected,
@@ -70,6 +82,7 @@ pub enum StatePhase {
     Connected(VoiceStreamType),
 }
 
+#[derive(Debug)]
 pub struct State {
     config: Config,
     server: Option<Server>,