fix clippy warnings

cartercanedy · cartercanedy · commit f1d7a5d51280 · 2025-06-01T15:17:04.000-07:00
diff --git a/examples/adstool.rs b/examples/adstool.rs
@@ -319,7 +319,7 @@ fn main() {
     let args = Args::from_args();
 
     if let Err(e) = main_inner(args) {
-        eprintln!("Error: {}", e);
+        eprintln!("Error: {e}");
         std::process::exit(1);
     }
 }
@@ -403,7 +403,7 @@ fn main_inner(args: Args) -> Result<(), Error> {
                         let namelen = LE::read_u32(&routeinfo[36..]) as usize;
                         let host = String::from_utf8_lossy(&routeinfo[44..][..hostlen - 1]);
                         let name = String::from_utf8_lossy(&routeinfo[44 + hostlen..][..namelen - 1]);
-                        print!("{:-20} {:-22} {:-18}", name, netid, host);
+                        print!("{name:-20} {netid:-22} {host:-18}");
                         if flags & 0x01 != 0 {
                             print!(" temporary");
                         }
@@ -415,7 +415,7 @@ fn main_inner(args: Args) -> Result<(), Error> {
                         }
                         println!();
                     }
-                    _ => println!("Route entry {} too short", subindex),
+                    _ => println!("Route entry {subindex} too short"),
                 }
             }
         }
@@ -459,7 +459,7 @@ fn main_inner(args: Args) -> Result<(), Error> {
                         }
                     }
                     Ok(Event::Eof) => break,
-                    Err(e) => return Err(Error::Str(format!("error parsing target desc XML: {}", e))),
+                    Err(e) => return Err(Error::Str(format!("error parsing target desc XML: {e}"))),
                     _ => (),
                 }
             }
@@ -507,9 +507,9 @@ fn main_inner(args: Args) -> Result<(), Error> {
             let info = dev.get_info()?;
             println!("Device: {} {}.{}.{}", info.name, info.major, info.minor, info.version);
             let (state, dev_state) = dev.get_state()?;
-            println!("Current state: {:?}", state);
+            println!("Current state: {state:?}");
             if let Some(newstate) = subargs.target_state {
-                println!("Set new state: {:?}", newstate);
+                println!("Set new state: {newstate:?}");
                 dev.write_control(newstate, dev_state)?;
             }
         }
@@ -553,10 +553,10 @@ fn main_inner(args: Args) -> Result<(), Error> {
 
                         println!("ID: {}", format_guid(guid));
                         if let Some(exp) = exp_time {
-                            println!("    Expires: {}", exp);
+                            println!("    Expires: {exp}");
                         }
                         if inst_total != 0 {
-                            println!("    Instances used: {}/{}", inst_used, inst_total);
+                            println!("    Instances used: {inst_used}/{inst_total}");
                         }
                     }
                 }
@@ -748,18 +748,18 @@ fn print_read_value(typ: VarType, buf: &[u8], hex: bool) {
             match buf[0] {
                 0 => println!("FALSE"),
                 1 => println!("TRUE"),
-                n => println!("non-bool ({})", n),
+                n => println!("non-bool ({n})"),
             }
             return;
         }
         VarType::Real => {
             let v = f32::from_le_bytes(buf[..4].try_into().expect("size"));
-            println!("{}", v);
+            println!("{v}");
             return;
         }
         VarType::Lreal => {
             let v = f64::from_le_bytes(buf[..8].try_into().expect("size"));
-            println!("{}", v);
+            println!("{v}");
             return;
         }
         VarType::Byte => buf[0] as i128,
@@ -773,9 +773,9 @@ fn print_read_value(typ: VarType, buf: &[u8], hex: bool) {
     };
     // Only reaches here for integer types
     if hex {
-        println!("{:#x}", value);
+        println!("{value:#x}");
     } else {
-        println!("{}", value);
+        println!("{value}");
     }
 }
 
diff --git a/examples/notify.rs b/examples/notify.rs
@@ -9,7 +9,7 @@ fn main() {
     std::thread::spawn(move || {
         for msg in recv_notify.iter() {
             for sample in msg.samples() {
-                println!("notify: {:?}", sample);
+                println!("notify: {sample:?}");
             }
         }
     });
@@ -39,7 +39,7 @@ fn main() {
             ),
         )
         .unwrap();
-    println!("{} {}", h1, h2);
+    println!("{h1} {h2}");
     loop {
         std::thread::sleep(std::time::Duration::from_secs(1));
     }
diff --git a/src/client.rs b/src/client.rs
@@ -149,12 +149,13 @@ impl Drop for Client {
             .get_mut()
             .expect("notification handle cache lock was poisoned");
 
-        // Remove our port from the router, if necessary.
-        if self.source_port_opened {
-            let mut close_port_msg = [1, 0, 2, 0, 0, 0, 0, 0];
-            LE::write_u16(&mut close_port_msg[6..], self.source.port());
-
-            let _ = self.socket.write().map(|mut socket| socket.write_all(&close_port_msg));
+        if let Ok(ref mut socket) = self.socket.write() {
+            // Remove our port from the router, if necessary.
+            if self.source_port_opened {
+                let mut close_port_msg = [1, 0, 2, 0, 0, 0, 0, 0];
+                LE::write_u16(&mut close_port_msg[6..], self.source.port());
+                let _ = socket.write_all(&close_port_msg);
+            }
         }
 
         self.worker.stop();
@@ -482,14 +483,14 @@ impl ClientWorker {
 
             let _ = socket.shutdown(Shutdown::Both);
 
-            let _ = pending.write().map(|mut pending| {
+            if let Ok(ref mut pending) = pending.write() {
                 let keys = pending.keys().cloned().collect_vec();
                 for key in keys {
                     if let Some(channel) = pending.remove(&key) {
                         let _ = channel.send(None);
                     };
                 }
-            });
+            }
 
             result
         });
diff --git a/src/notif.rs b/src/notif.rs
@@ -61,7 +61,7 @@ impl std::fmt::Debug for Notification {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         writeln!(f, "Notification [")?;
         for sample in self.samples() {
-            writeln!(f, "    {:?}", sample)?;
+            writeln!(f, "    {sample:?}")?;
         }
         write!(f, "]")
     }
diff --git a/src/test/mod.rs b/src/test/mod.rs
@@ -92,7 +92,7 @@ impl Server {
                 }
                 panic!("unexpected receive error: {}", e);
             }
-            println!(">>> {:?}", header);
+            println!(">>> {header:?}");
             let mut data = vec![0; header.data_length.get() as usize];
             socket.read_exact(&mut data).unwrap();
 
@@ -133,7 +133,7 @@ impl Server {
             if !opts.ignore_invokeid {
                 reply_header.invoke_id = header.invoke_id;
             }
-            println!("<<< {:?}", reply_header);
+            println!("<<< {reply_header:?}");
 
             socket.write_all(reply_header.as_bytes()).unwrap();
             socket.write_all(&reply_data).unwrap();
@@ -162,7 +162,7 @@ impl Server {
         ads_header.command.set(crate::client::Command::Notification as u16);
         ads_header.state_flags.set(4);
         ads_header.data_length.set(data_len as u32);
-        println!("not: {:?}", ads_header);
+        println!("not: {ads_header:?}");
 
         socket.write_all(ads_header.as_bytes()).unwrap();
         socket.write_all(notif_header.as_bytes()).unwrap();
diff --git a/src/test/test_client.rs b/src/test/test_client.rs
@@ -182,7 +182,7 @@ fn test_notification() {
         let first = chan.try_recv().unwrap();
         let second = chan.try_recv().unwrap();
 
-        println!("{:?}", first);
+        println!("{first:?}");
 
         let mut samples = first.samples();
         assert_eq!(
@@ -265,7 +265,7 @@ fn test_string_type() {
         assert!(<[u8; 5]>::from(bstr2) == [b'a', b'b', b'c', 0, 0]);
         assert!(bstr == bstr2);
 
-        assert!(format!("{:?}", bstr) == "\"abc\"");
+        assert!(format!("{bstr:?}") == "\"abc\"");
 
         device.write_value(0x4020, 7, &bstr).unwrap();
 
@@ -291,7 +291,7 @@ fn test_wstring_type() {
         assert!(WString5::try_from(&[1, 2, 3, 4, 5, 6][..]).is_err());
         assert!(WString5::try_from("abcdef").is_err());
 
-        assert!(format!("{:?}", wstr) == "\"abc\"");
+        assert!(format!("{wstr:?}") == "\"abc\"");
 
         let wstr2 = WString5::try_from(&[b'a' as u16, b'b' as u16, b'c' as u16][..]).unwrap();
         assert!(<[u16; 5]>::from(wstr2) == [b'a' as u16, b'b' as u16, b'c' as u16, 0, 0]);

Original file line number	Diff line number	Diff line change
`@@ -319,7 +319,7 @@ fn main() {`
`319`	`319`	`let args = Args::from_args();`
`320`	`320`
`321`	`321`	`if let Err(e) = main_inner(args) {`
`322`		`- eprintln!("Error: {}", e);`
	`322`	`+ eprintln!("Error: {e}");`
`323`	`323`	`std::process::exit(1);`
`324`	`324`	`}`
`325`	`325`	`}`
`@@ -403,7 +403,7 @@ fn main_inner(args: Args) -> Result<(), Error> {`
`403`	`403`	`let namelen = LE::read_u32(&routeinfo[36..]) as usize;`
`404`	`404`	`let host = String::from_utf8_lossy(&routeinfo[44..][..hostlen - 1]);`
`405`	`405`	`let name = String::from_utf8_lossy(&routeinfo[44 + hostlen..][..namelen - 1]);`
`406`		`- print!("{:-20} {:-22} {:-18}", name, netid, host);`
	`406`	`+ print!("{name:-20} {netid:-22} {host:-18}");`
`407`	`407`	`if flags & 0x01 != 0 {`
`408`	`408`	`print!(" temporary");`
`409`	`409`	`}`
`@@ -415,7 +415,7 @@ fn main_inner(args: Args) -> Result<(), Error> {`
`415`	`415`	`}`
`416`	`416`	`println!();`
`417`	`417`	`}`
`418`		`- _ => println!("Route entry {} too short", subindex),`
	`418`	`+ _ => println!("Route entry {subindex} too short"),`
`419`	`419`	`}`
`420`	`420`	`}`
`421`	`421`	`}`
`@@ -459,7 +459,7 @@ fn main_inner(args: Args) -> Result<(), Error> {`
`459`	`459`	`}`
`460`	`460`	`}`
`461`	`461`	`Ok(Event::Eof) => break,`
`462`		`- Err(e) => return Err(Error::Str(format!("error parsing target desc XML: {}", e))),`
	`462`	`+ Err(e) => return Err(Error::Str(format!("error parsing target desc XML: {e}"))),`
`463`	`463`	`_ => (),`
`464`	`464`	`}`
`465`	`465`	`}`
`@@ -507,9 +507,9 @@ fn main_inner(args: Args) -> Result<(), Error> {`
`507`	`507`	`let info = dev.get_info()?;`
`508`	`508`	`println!("Device: {} {}.{}.{}", info.name, info.major, info.minor, info.version);`
`509`	`509`	`let (state, dev_state) = dev.get_state()?;`
`510`		`- println!("Current state: {:?}", state);`
	`510`	`+ println!("Current state: {state:?}");`
`511`	`511`	`if let Some(newstate) = subargs.target_state {`
`512`		`- println!("Set new state: {:?}", newstate);`
	`512`	`+ println!("Set new state: {newstate:?}");`
`513`	`513`	`dev.write_control(newstate, dev_state)?;`
`514`	`514`	`}`
`515`	`515`	`}`
`@@ -553,10 +553,10 @@ fn main_inner(args: Args) -> Result<(), Error> {`
`553`	`553`
`554`	`554`	`println!("ID: {}", format_guid(guid));`
`555`	`555`	`if let Some(exp) = exp_time {`
`556`		`- println!(" Expires: {}", exp);`
	`556`	`+ println!(" Expires: {exp}");`
`557`	`557`	`}`
`558`	`558`	`if inst_total != 0 {`
`559`		`- println!(" Instances used: {}/{}", inst_used, inst_total);`
	`559`	`+ println!(" Instances used: {inst_used}/{inst_total}");`
`560`	`560`	`}`
`561`	`561`	`}`
`562`	`562`	`}`
`@@ -748,18 +748,18 @@ fn print_read_value(typ: VarType, buf: &[u8], hex: bool) {`
`748`	`748`	`match buf[0] {`
`749`	`749`	`0 => println!("FALSE"),`
`750`	`750`	`1 => println!("TRUE"),`
`751`		`- n => println!("non-bool ({})", n),`
	`751`	`+ n => println!("non-bool ({n})"),`
`752`	`752`	`}`
`753`	`753`	`return;`
`754`	`754`	`}`
`755`	`755`	`VarType::Real => {`
`756`	`756`	`let v = f32::from_le_bytes(buf[..4].try_into().expect("size"));`
`757`		`- println!("{}", v);`
	`757`	`+ println!("{v}");`
`758`	`758`	`return;`
`759`	`759`	`}`
`760`	`760`	`VarType::Lreal => {`
`761`	`761`	`let v = f64::from_le_bytes(buf[..8].try_into().expect("size"));`
`762`		`- println!("{}", v);`
	`762`	`+ println!("{v}");`
`763`	`763`	`return;`
`764`	`764`	`}`
`765`	`765`	`VarType::Byte => buf[0] as i128,`
`@@ -773,9 +773,9 @@ fn print_read_value(typ: VarType, buf: &[u8], hex: bool) {`
`773`	`773`	`};`
`774`	`774`	`// Only reaches here for integer types`
`775`	`775`	`if hex {`
`776`		`- println!("{:#x}", value);`
	`776`	`+ println!("{value:#x}");`
`777`	`777`	`} else {`
`778`		`- println!("{}", value);`
	`778`	`+ println!("{value}");`
`779`	`779`	`}`
`780`	`780`	`}`
`781`	`781`
Original file line number	Diff line number	Diff line change
`@@ -9,7 +9,7 @@ fn main() {`
`9`	`9`	`std::thread::spawn(move \|\| {`
`10`	`10`	`for msg in recv_notify.iter() {`
`11`	`11`	`for sample in msg.samples() {`
`12`		`- println!("notify: {:?}", sample);`
	`12`	`+ println!("notify: {sample:?}");`
`13`	`13`	`}`
`14`	`14`	`}`
`15`	`15`	`});`
`@@ -39,7 +39,7 @@ fn main() {`
`39`	`39`	`),`
`40`	`40`	`)`
`41`	`41`	`.unwrap();`
`42`		`- println!("{} {}", h1, h2);`
	`42`	`+ println!("{h1} {h2}");`
`43`	`43`	`loop {`
`44`	`44`	`std::thread::sleep(std::time::Duration::from_secs(1));`
`45`	`45`	`}`
Original file line number	Diff line number	Diff line change
`@@ -61,7 +61,7 @@ impl std::fmt::Debug for Notification {`
`61`	`61`	`fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {`
`62`	`62`	`writeln!(f, "Notification [")?;`
`63`	`63`	`for sample in self.samples() {`
`64`		`- writeln!(f, " {:?}", sample)?;`
	`64`	`+ writeln!(f, " {sample:?}")?;`
`65`	`65`	`}`
`66`	`66`	`write!(f, "]")`
`67`	`67`	`}`