general: apply clippy lints (webrtc-rs#407)

* general: update crates to 2021 edition.

* general: apply clippy --fix

* general: apply manual clippy lints

* cargo fmt.

Author: jxs

constraints/Cargo.toml

@@ -2,7 +2,7 @@
 name = "webrtc-constraints"
 version = "0.1.0"
 authors = ["Vincent Esche <[email protected]>"]
-edition = "2018"
+edition = "2021"
 description = "A pure Rust implementation of WebRTC Media Constraints API"
 license = "MIT/Apache-2.0"
 documentation = "https://docs.rs/webrtc-constraints"

constraints/src/algorithms/fitness_distance/setting.rs

@@ -345,10 +345,10 @@ mod tests {
 
                     let expected = 0.0;
 
-                    println!("constraint: {:?}", constraint);
-                    println!("setting: {:?}", setting);
-                    println!("actual: {:?}", actual);
-                    println!("expected: {:?}", expected);
+                    println!("constraint: {constraint:?}");
+                    println!("setting: {setting:?}");
+                    println!("actual: {actual:?}");
+                    println!("expected: {expected:?}");
 
                     assert_eq!(actual, expected);
                 }
@@ -434,10 +434,10 @@ mod tests {
 
                 let expected = 0.0;
 
-                println!("constraint: {:?}", constraint);
-                println!("setting: {:?}", setting);
-                println!("actual: {:?}", actual);
-                println!("expected: {:?}", expected);
+                println!("constraint: {constraint:?}");
+                println!("setting: {setting:?}");
+                println!("actual: {actual:?}");
+                println!("expected: {expected:?}");
 
                 assert_eq!(actual, expected);
             }

constraints/src/constraint/value.rs

@@ -197,14 +197,14 @@ where
         let mut is_first = true;
         f.write_str("(")?;
         if let Some(ref exact) = &self.exact {
-            f.write_fmt(format_args!("x == {:?}", exact))?;
+            f.write_fmt(format_args!("x == {exact:?}"))?;
             is_first = false;
         }
         if let Some(ref ideal) = &self.ideal {
             if !is_first {
                 f.write_str(" && ")?;
             }
-            f.write_fmt(format_args!("x ~= {:?}", ideal))?;
+            f.write_fmt(format_args!("x ~= {ideal:?}"))?;
             is_first = false;
         }
         if is_first {

constraints/src/constraint/value_range.rs

@@ -233,23 +233,23 @@ where
         let mut is_first = true;
         f.write_str("(")?;
         if let Some(exact) = &self.exact {
-            f.write_fmt(format_args!("x == {:?}", exact))?;
+            f.write_fmt(format_args!("x == {exact:?}"))?;
             is_first = false;
         } else if let (Some(min), Some(max)) = (&self.min, &self.max) {
-            f.write_fmt(format_args!("{:?} <= x <= {:?}", min, max))?;
+            f.write_fmt(format_args!("{min:?} <= x <= {max:?}"))?;
             is_first = false;
         } else if let Some(min) = &self.min {
-            f.write_fmt(format_args!("{:?} <= x", min))?;
+            f.write_fmt(format_args!("{min:?} <= x"))?;
             is_first = false;
         } else if let Some(max) = &self.max {
-            f.write_fmt(format_args!("x <= {:?}", max))?;
+            f.write_fmt(format_args!("x <= {max:?}"))?;
             is_first = false;
         }
         if let Some(ideal) = &self.ideal {
             if !is_first {
                 f.write_str(" && ")?;
             }
-            f.write_fmt(format_args!("x ~= {:?}", ideal))?;
+            f.write_fmt(format_args!("x ~= {ideal:?}"))?;
             is_first = false;
         }
         if is_first {

constraints/src/constraint/value_sequence.rs

@@ -204,14 +204,14 @@ where
         let mut is_first = true;
         f.write_str("(")?;
         if let Some(ref exact) = &self.exact {
-            f.write_fmt(format_args!("x == {:?}", exact))?;
+            f.write_fmt(format_args!("x == {exact:?}"))?;
             is_first = false;
         }
         if let Some(ref ideal) = &self.ideal {
             if !is_first {
                 f.write_str(" && ")?;
             }
-            f.write_fmt(format_args!("x ~= {:?}", ideal))?;
+            f.write_fmt(format_args!("x ~= {ideal:?}"))?;
             is_first = false;
         }
         if is_first {

constraints/src/errors.rs

@@ -31,7 +31,7 @@ impl std::fmt::Display for OverconstrainedError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(f, "Overconstrained property {:?}", self.constraint)?;
         if let Some(message) = self.message.as_ref() {
-            write!(f, ": {}", message)?;
+            write!(f, ": {message}")?;
         }
         Ok(())
     }
@@ -100,10 +100,10 @@ impl OverconstrainedError {
             [reason] => reason.clone(),
             [reasons @ .., reason] => {
                 let reasons = reasons.join(", ");
-                format!("either {}, or {}", reasons, reason)
+                format!("either {reasons}, or {reason}")
             }
         };
-        let message = Some(format!("Setting was {}.", formatted_reason));
+        let message = Some(format!("Setting was {formatted_reason}."));
 
         Self {
             constraint,

constraints/src/setting.rs

@@ -28,10 +28,10 @@ pub enum MediaTrackSetting {
 impl std::fmt::Display for MediaTrackSetting {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
-            Self::Bool(setting) => f.write_fmt(format_args!("{:?}", setting)),
-            Self::Integer(setting) => f.write_fmt(format_args!("{:?}", setting)),
-            Self::Float(setting) => f.write_fmt(format_args!("{:?}", setting)),
-            Self::String(setting) => f.write_fmt(format_args!("{:?}", setting)),
+            Self::Bool(setting) => f.write_fmt(format_args!("{setting:?}")),
+            Self::Integer(setting) => f.write_fmt(format_args!("{setting:?}")),
+            Self::Float(setting) => f.write_fmt(format_args!("{setting:?}")),
+            Self::String(setting) => f.write_fmt(format_args!("{setting:?}")),
         }
     }
 }

data/Cargo.toml

@@ -2,7 +2,7 @@
 name = "webrtc-data"
 version = "0.6.0"
 authors = ["Rain Liu <[email protected]>"]
-edition = "2018"
+edition = "2021"
 description = "A pure Rust implementation of WebRTC DataChannel API"
 license = "MIT/Apache-2.0"
 documentation = "https://docs.rs/webrtc-data"

dtls/Cargo.toml

@@ -2,7 +2,7 @@
 name = "webrtc-dtls"
 version = "0.7.0"
 authors = ["Rain Liu <[email protected]>"]
-edition = "2018"
+edition = "2021"
 description = "A pure Rust implementation of DTLS"
 license = "MIT/Apache-2.0"
 documentation = "https://docs.rs/webrtc-dtls"

dtls/examples/dial/psk/dial_psk.rs

@@ -57,7 +57,7 @@ async fn main() -> Result<(), Error> {
 
     let conn = Arc::new(UdpSocket::bind("0.0.0.0:0").await?);
     conn.connect(server).await?;
-    println!("connecting {}..", server);
+    println!("connecting {server}..");
 
     let config = Config {
         psk: Some(Arc::new(|hint: &[u8]| -> Result<Vec<u8>, Error> {

dtls/examples/dial/selfsign/dial_selfsign.rs

@@ -56,7 +56,7 @@ async fn main() -> Result<(), Error> {
 
     let conn = Arc::new(UdpSocket::bind("0.0.0.0:0").await?);
     conn.connect(server).await?;
-    println!("connecting {}..", server);
+    println!("connecting {server}..");
 
     // Generate a certificate and private key to secure the connection
     let certificate = Certificate::generate_self_signed(vec!["localhost".to_owned()])?;

dtls/examples/dial/verify/dial_verify.rs

@@ -57,7 +57,7 @@ async fn main() -> Result<(), Error> {
 
     let conn = Arc::new(UdpSocket::bind("0.0.0.0:0").await?);
     conn.connect(server).await?;
-    println!("connecting {}..", server);
+    println!("connecting {server}..");
 
     let certificate = hub::utilities::load_key_and_certificate(
         "examples/certificates/client.pem.private_key.pem".into(),

dtls/examples/hub/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "hub"
 version = "0.1.0"
-edition = "2018"
+edition = "2021"
 
 [dependencies]
 util = { path = "../../../util", package = "webrtc-util", default-features = false, features = [

dtls/examples/hub/src/lib.rs

@@ -50,7 +50,7 @@ impl Hub {
 
         while let Ok(n) = conn.recv(&mut b).await {
             let msg = String::from_utf8(b[..n].to_vec())?;
-            print!("Got message: {}", msg);
+            print!("Got message: {msg}");
         }
 
         Hub::unregister(conns, conn).await
@@ -67,9 +67,9 @@ impl Hub {
             }
 
             if let Err(err) = conn.close().await {
-                println!("Failed to disconnect: {} with err {}", remote_addr, err);
+                println!("Failed to disconnect: {remote_addr} with err {err}");
             } else {
-                println!("Disconnected: {} ", remote_addr);
+                println!("Disconnected: {remote_addr} ");
             }
         }
 
@@ -98,7 +98,7 @@ impl Hub {
             match reader.read_line(&mut msg) {
                 Ok(0) => return,
                 Err(err) => {
-                    println!("stdin read err: {}", err);
+                    println!("stdin read err: {err}");
                     return;
                 }
                 _ => {}

dtls/examples/hub/src/utilities.rs

@@ -45,7 +45,7 @@ pub async fn chat(conn: Arc<dyn Conn + Send + Sync>) -> Result<(), Error> {
 
         while let Ok(n) = conn_rx.recv(&mut b).await {
             let msg = String::from_utf8(b[..n].to_vec()).expect("utf8");
-            print!("Got message: {}", msg);
+            print!("Got message: {msg}");
         }
 
         Result::<(), Error>::Ok(())
@@ -58,7 +58,7 @@ pub async fn chat(conn: Arc<dyn Conn + Send + Sync>) -> Result<(), Error> {
         match reader.read_line(&mut msg) {
             Ok(0) => return Ok(()),
             Err(err) => {
-                println!("stdin read err: {}", err);
+                println!("stdin read err: {err}");
                 return Ok(());
             }
             _ => {}

dtls/examples/listen/psk/listen_psk.rs

@@ -66,7 +66,7 @@ async fn main() -> Result<(), Error> {
         ..Default::default()
     };
 
-    println!("listening {}...\ntype 'exit' to shutdown gracefully", host);
+    println!("listening {host}...\ntype 'exit' to shutdown gracefully");
 
     let listener = Arc::new(listen(host, cfg).await?);
 

dtls/examples/listen/selfsign/listen_selfsign.rs

@@ -63,7 +63,7 @@ async fn main() -> Result<(), Error> {
         ..Default::default()
     };
 
-    println!("listening {}...\ntype 'exit' to shutdown gracefully", host);
+    println!("listening {host}...\ntype 'exit' to shutdown gracefully");
 
     let listener = Arc::new(listen(host, cfg).await?);
 

dtls/examples/listen/verify/listen_verify.rs

@@ -75,7 +75,7 @@ async fn main() -> Result<(), Error> {
         ..Default::default()
     };
 
-    println!("listening {}...\ntype 'exit' to shutdown gracefully", host);
+    println!("listening {host}...\ntype 'exit' to shutdown gracefully");
 
     let listener = Arc::new(listen(host, cfg).await?);
 
@@ -100,7 +100,7 @@ async fn main() -> Result<(), Error> {
                             h2.register(dtls_conn).await;
                         }
                         Err(err) => {
-                            println!("connecting failed with error: {}", err);
+                            println!("connecting failed with error: {err}");
                         }
                     }
                 }

dtls/src/alert/alert_test.rs

@@ -31,26 +31,18 @@ fn test_alert() -> Result<()> {
         let result = Alert::unmarshal(&mut reader);
 
         if let Some(err) = unmarshal_error {
-            assert!(result.is_err(), "{} expected error: {}", name, err);
+            assert!(result.is_err(), "{name} expected error: {err}");
         } else if let Ok(alert) = result {
-            assert_eq!(
-                wanted, alert,
-                "{} expected {}, but got {}",
-                name, wanted, alert
-            );
+            assert_eq!(wanted, alert, "{name} expected {wanted}, but got {alert}");
 
             let mut data2: Vec<u8> = vec![];
             {
                 let mut writer = BufWriter::<&mut Vec<u8>>::new(data2.as_mut());
                 alert.marshal(&mut writer)?;
             }
-            assert_eq!(
-                data, data2,
-                "{} expected {:?}, but got {:?}",
-                name, data, data2
-            );
+            assert_eq!(data, data2, "{name} expected {data:?}, but got {data2:?}");
         } else {
-            assert!(result.is_ok(), "{} expected Ok, but has error", name);
+            assert!(result.is_ok(), "{name} expected Ok, but has error");
         }
     }
 

dtls/src/change_cipher_spec/change_cipher_spec_test.rs

@@ -15,8 +15,7 @@ fn test_change_cipher_spec_round_trip() -> Result<()> {
     let cnew = ChangeCipherSpec::unmarshal(&mut reader)?;
     assert_eq!(
         c, cnew,
-        "ChangeCipherSpec round trip: got {:?}, want {:?}",
-        cnew, c
+        "ChangeCipherSpec round trip: got {cnew:?}, want {c:?}"
     );
 
     Ok(())