Minor cleanup from clippy

oschwald · oschwald · commit dcd35df5bc3d · 2023-02-18T15:10:30.000-08:00
diff --git a/examples/lookup.rs b/examples/lookup.rs
@@ -15,6 +15,6 @@ fn main() -> Result<(), String> {
         .parse()
         .unwrap();
     let city: geoip2::City = reader.lookup(ip).unwrap();
-    println!("{:#?}", city);
+    println!("{city:#?}");
     Ok(())
 }
diff --git a/examples/within.rs b/examples/within.rs
@@ -38,7 +38,7 @@ fn main() -> Result<(), String> {
         }
         n += 1;
     }
-    eprintln!("processed {} items", n);
+    eprintln!("processed {n} items");
 
     Ok(())
 }
diff --git a/src/maxminddb/decoder.rs b/src/maxminddb/decoder.rs
@@ -135,8 +135,7 @@ impl<'de> Decoder<'de> {
             15 => Value::F32(self.decode_float(size)?),
             u => {
                 return Err(MaxMindDBError::InvalidDatabaseError(format!(
-                    "Unknown data type: {:?}",
-                    u
+                    "Unknown data type: {u:?}"
                 )))
             }
         })
@@ -153,8 +152,7 @@ impl<'de> Decoder<'de> {
         match size {
             0 | 1 => Ok(size != 0),
             s => Err(MaxMindDBError::InvalidDatabaseError(format!(
-                "bool of size {:?}",
-                s
+                "bool of size {s:?}"
             ))),
         }
     }
@@ -209,8 +207,7 @@ impl<'de> Decoder<'de> {
                 Ok(value)
             }
             s => Err(MaxMindDBError::InvalidDatabaseError(format!(
-                "u64 of size {:?}",
-                s
+                "u64 of size {s:?}"
             ))),
         }
     }
@@ -231,8 +228,7 @@ impl<'de> Decoder<'de> {
                     Ok(value)
                 }
                 s => Err(MaxMindDBError::InvalidDatabaseError(format!(
-                    "u128 of size {:?}",
-                    s
+                    "u128 of size {s:?}"
                 ))),
             }
         }
@@ -250,8 +246,7 @@ impl<'de> Decoder<'de> {
                 Ok(value)
             }
             s => Err(MaxMindDBError::InvalidDatabaseError(format!(
-                "u32 of size {:?}",
-                s
+                "u32 of size {s:?}"
             ))),
         }
     }
@@ -268,8 +263,7 @@ impl<'de> Decoder<'de> {
                 Ok(value)
             }
             s => Err(MaxMindDBError::InvalidDatabaseError(format!(
-                "u16 of size {:?}",
-                s
+                "u16 of size {s:?}"
             ))),
         }
     }
@@ -286,8 +280,7 @@ impl<'de> Decoder<'de> {
                 Ok(value)
             }
             s => Err(MaxMindDBError::InvalidDatabaseError(format!(
-                "int32 of size {:?}",
-                s
+                "int32 of size {s:?}"
             ))),
         }
     }
diff --git a/src/maxminddb/lib.rs b/src/maxminddb/lib.rs
@@ -39,16 +39,16 @@ impl Display for MaxMindDBError {
     fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), fmt::Error> {
         match self {
             MaxMindDBError::AddressNotFoundError(msg) => {
-                write!(fmt, "AddressNotFoundError: {}", msg)?
+                write!(fmt, "AddressNotFoundError: {msg}")?
             }
             MaxMindDBError::InvalidDatabaseError(msg) => {
-                write!(fmt, "InvalidDatabaseError: {}", msg)?
+                write!(fmt, "InvalidDatabaseError: {msg}")?
             }
-            MaxMindDBError::IoError(msg) => write!(fmt, "IoError: {}", msg)?,
-            MaxMindDBError::MapError(msg) => write!(fmt, "MapError: {}", msg)?,
-            MaxMindDBError::DecodingError(msg) => write!(fmt, "DecodingError: {}", msg)?,
+            MaxMindDBError::IoError(msg) => write!(fmt, "IoError: {msg}")?,
+            MaxMindDBError::MapError(msg) => write!(fmt, "MapError: {msg}")?,
+            MaxMindDBError::DecodingError(msg) => write!(fmt, "DecodingError: {msg}")?,
             MaxMindDBError::InvalidNetworkError(msg) => {
-                write!(fmt, "InvalidNetworkError: {}", msg)?
+                write!(fmt, "InvalidNetworkError: {msg}")?
             }
         }
         Ok(())
@@ -60,7 +60,7 @@ impl std::error::Error for MaxMindDBError {}
 
 impl de::Error for MaxMindDBError {
     fn custom<T: Display>(msg: T) -> Self {
-        MaxMindDBError::DecodingError(format!("{}", msg))
+        MaxMindDBError::DecodingError(format!("{msg}"))
     }
 }
 
@@ -442,8 +442,7 @@ impl<'de, S: AsRef<[u8]>> Reader<S> {
             s => {
                 return Err(MaxMindDBError::InvalidDatabaseError(format!(
                     "unknown record size: \
-                     {:?}",
-                    s
+                     {s:?}"
                 )))
             }
         };
@@ -508,14 +507,14 @@ fn bytes_and_prefix_to_net(bytes: &[u8], prefix: u8) -> Result<IpNetwork, MaxMin
                     prefix - 96,
                 )
             } else {
-                let a = (bytes[0] as u16) << 8 | bytes[1] as u16;
-                let b = (bytes[2] as u16) << 8 | bytes[3] as u16;
-                let c = (bytes[4] as u16) << 8 | bytes[5] as u16;
-                let d = (bytes[6] as u16) << 8 | bytes[7] as u16;
-                let e = (bytes[8] as u16) << 8 | bytes[9] as u16;
-                let f = (bytes[10] as u16) << 8 | bytes[11] as u16;
-                let g = (bytes[12] as u16) << 8 | bytes[13] as u16;
-                let h = (bytes[14] as u16) << 8 | bytes[15] as u16;
+                let a = u16::from(bytes[0]) << 8 | u16::from(bytes[1]);
+                let b = u16::from(bytes[2]) << 8 | u16::from(bytes[3]);
+                let c = u16::from(bytes[4]) << 8 | u16::from(bytes[5]);
+                let d = u16::from(bytes[6]) << 8 | u16::from(bytes[7]);
+                let e = u16::from(bytes[8]) << 8 | u16::from(bytes[9]);
+                let f = u16::from(bytes[10]) << 8 | u16::from(bytes[11]);
+                let g = u16::from(bytes[12]) << 8 | u16::from(bytes[13]);
+                let h = u16::from(bytes[14]) << 8 | u16::from(bytes[15]);
                 (IpAddr::V6(Ipv6Addr::new(a, b, c, d, e, f, g, h)), prefix)
             }
         }
diff --git a/src/maxminddb/reader_test.rs b/src/maxminddb/reader_test.rs
@@ -41,7 +41,7 @@ fn test_decoder() {
 
     let r = Reader::open_readfile("test-data/test-data/MaxMind-DB-test-decoder.mmdb");
     if let Err(err) = r {
-        panic!("error opening mmdb: {:?}", err);
+        panic!("error opening mmdb: {err:?}");
     }
     let r = r.unwrap();
     let ip: IpAddr = FromStr::from_str("1.1.1.0").unwrap();
@@ -84,7 +84,7 @@ fn test_pointers_in_metadata() {
 
     let r = Reader::open_readfile("test-data/test-data/MaxMind-DB-test-metadata-pointers.mmdb");
     if let Err(err) = r {
-        panic!("error opening mmdb: {:?}", err);
+        panic!("error opening mmdb: {err:?}");
     }
 }
 
@@ -150,8 +150,7 @@ fn test_reader() {
         let versions = [4_usize, 6];
         for ip_version in &versions {
             let filename = format!(
-                "test-data/test-data/MaxMind-DB-test-ipv{}-{}.mmdb",
-                ip_version, record_size
+                "test-data/test-data/MaxMind-DB-test-ipv{ip_version}-{record_size}.mmdb"
             );
             let reader = Reader::open_readfile(filename).ok().unwrap();
 
@@ -171,8 +170,7 @@ fn test_reader_readfile() {
         let versions = [4_usize, 6];
         for ip_version in &versions {
             let filename = format!(
-                "test-data/test-data/MaxMind-DB-test-ipv{}-{}.mmdb",
-                ip_version, record_size
+                "test-data/test-data/MaxMind-DB-test-ipv{ip_version}-{record_size}.mmdb"
             );
             let reader = Reader::open_readfile(filename).ok().unwrap();
 
@@ -382,7 +380,7 @@ fn test_within_city() {
     // Make sure the first is what we expect it to be
     let item = iter.next().unwrap().unwrap();
     assert_eq!(item.ip_net, IpNetwork::V4("2.2.3.0/24".parse().unwrap()));
-    assert_eq!(item.info.city.unwrap().geoname_id, Some(2655045));
+    assert_eq!(item.info.city.unwrap().geoname_id, Some(2_655_045));
 
     let mut n = 1;
     for _ in iter {
@@ -480,7 +478,7 @@ fn check_ip<T: AsRef<[u8]>>(reader: &Reader<T>, ip_version: usize) {
     for &address in &no_record {
         let ip: IpAddr = FromStr::from_str(address).unwrap();
         match reader.lookup::<IpType>(ip) {
-            Ok(v) => panic!("received an unexpected value: {:?}", v),
+            Ok(v) => panic!("received an unexpected value: {v:?}"),
             Err(e) => assert_eq!(
                 e,
                 MaxMindDBError::AddressNotFoundError("Address not found in database".to_string())

Original file line number	Diff line number	Diff line change
`@@ -15,6 +15,6 @@ fn main() -> Result<(), String> {`
`15`	`15`	`.parse()`
`16`	`16`	`.unwrap();`
`17`	`17`	`let city: geoip2::City = reader.lookup(ip).unwrap();`
`18`		`- println!("{:#?}", city);`
	`18`	`+ println!("{city:#?}");`
`19`	`19`	`Ok(())`
`20`	`20`	`}`
Original file line number	Diff line number	Diff line change
`@@ -38,7 +38,7 @@ fn main() -> Result<(), String> {`
`38`	`38`	`}`
`39`	`39`	`n += 1;`
`40`	`40`	`}`
`41`		`- eprintln!("processed {} items", n);`
	`41`	`+ eprintln!("processed {n} items");`
`42`	`42`
`43`	`43`	`Ok(())`
`44`	`44`	`}`
Original file line number	Diff line number	Diff line change
`@@ -135,8 +135,7 @@ impl<'de> Decoder<'de> {`
`135`	`135`	`15 => Value::F32(self.decode_float(size)?),`
`136`	`136`	`u => {`
`137`	`137`	`return Err(MaxMindDBError::InvalidDatabaseError(format!(`
`138`		`- "Unknown data type: {:?}",`
`139`		`- u`
	`138`	`+ "Unknown data type: {u:?}"`
`140`	`139`	`)))`
`141`	`140`	`}`
`142`	`141`	`})`
`@@ -153,8 +152,7 @@ impl<'de> Decoder<'de> {`
`153`	`152`	`match size {`
`154`	`153`	`0 \| 1 => Ok(size != 0),`
`155`	`154`	`s => Err(MaxMindDBError::InvalidDatabaseError(format!(`
`156`		`- "bool of size {:?}",`
`157`		`- s`
	`155`	`+ "bool of size {s:?}"`
`158`	`156`	`))),`
`159`	`157`	`}`
`160`	`158`	`}`
`@@ -209,8 +207,7 @@ impl<'de> Decoder<'de> {`
`209`	`207`	`Ok(value)`
`210`	`208`	`}`
`211`	`209`	`s => Err(MaxMindDBError::InvalidDatabaseError(format!(`
`212`		`- "u64 of size {:?}",`
`213`		`- s`
	`210`	`+ "u64 of size {s:?}"`
`214`	`211`	`))),`
`215`	`212`	`}`
`216`	`213`	`}`
`@@ -231,8 +228,7 @@ impl<'de> Decoder<'de> {`
`231`	`228`	`Ok(value)`
`232`	`229`	`}`
`233`	`230`	`s => Err(MaxMindDBError::InvalidDatabaseError(format!(`
`234`		`- "u128 of size {:?}",`
`235`		`- s`
	`231`	`+ "u128 of size {s:?}"`
`236`	`232`	`))),`
`237`	`233`	`}`
`238`	`234`	`}`
`@@ -250,8 +246,7 @@ impl<'de> Decoder<'de> {`
`250`	`246`	`Ok(value)`
`251`	`247`	`}`
`252`	`248`	`s => Err(MaxMindDBError::InvalidDatabaseError(format!(`
`253`		`- "u32 of size {:?}",`
`254`		`- s`
	`249`	`+ "u32 of size {s:?}"`
`255`	`250`	`))),`
`256`	`251`	`}`
`257`	`252`	`}`
`@@ -268,8 +263,7 @@ impl<'de> Decoder<'de> {`
`268`	`263`	`Ok(value)`
`269`	`264`	`}`
`270`	`265`	`s => Err(MaxMindDBError::InvalidDatabaseError(format!(`
`271`		`- "u16 of size {:?}",`
`272`		`- s`
	`266`	`+ "u16 of size {s:?}"`
`273`	`267`	`))),`
`274`	`268`	`}`
`275`	`269`	`}`
`@@ -286,8 +280,7 @@ impl<'de> Decoder<'de> {`
`286`	`280`	`Ok(value)`
`287`	`281`	`}`
`288`	`282`	`s => Err(MaxMindDBError::InvalidDatabaseError(format!(`
`289`		`- "int32 of size {:?}",`
`290`		`- s`
	`283`	`+ "int32 of size {s:?}"`
`291`	`284`	`))),`
`292`	`285`	`}`
`293`	`286`	`}`