clippy fixes

examples/allprops.rs

@@ -25,7 +25,7 @@ fn main() -> Result<(), MainError> {
     let parser = DemoParser::new_with_analyser(demo.get_stream(), PropAnalyzer::default());
     let (_, state) = parser.parse()?;
     for prop in state {
-        println!("{}", prop);
+        println!("{prop}");
     }
     Ok(())
 }
@@ -76,7 +76,7 @@ impl MessageHandler for PropAnalyzer {
             .into_iter()
             .map(|prop| {
                 let (table, name) = names.get(&prop).unwrap();
-                format!("{}.{}", table, name)
+                format!("{table}.{name}")
             })
             .collect::<Vec<_>>();
         props.sort();

src/bin/codegen.rs

@@ -25,6 +25,6 @@ fn main() -> std::result::Result<(), MainError> {
     };
     let file = parse2::<File>(tokens)?;
     let code = unparse(&file);
-    println!("{}", code);
+    println!("{code}");
     Ok(())
 }

src/bin/direct_hits.rs

@@ -55,9 +55,7 @@ fn main() -> Result<(), MainError> {
                 .iter()
                 .find(|player| {
                     player
-                        .weapons
+                        .weapons.contains(&collision.projectile.launcher)
-                        .iter()
-                        .any(|weapon| collision.projectile.launcher == *weapon)
                 })
                 .and_then(|player| player.info.as_ref());
 

src/bin/main.rs

@@ -52,12 +52,12 @@ fn main() -> Result<(), MainError> {
         let parser = DemoParser::new_with_analyser(demo.get_stream(), PlayerSummaryAnalyzer::new());
         let (header, state) = parser.parse()?;
 
-        println!("{:?}", header);
+        println!("{header:?}");
 
         let table_header = "Player                           | Points     | Kills      | Deaths     | Assists    | Destruction | Captures   | Defenses   | Domination | Revenge    | Ubers      | Headshots  | Teleports  | Healing    | Backstabs  | Bonus      | Support    | Damage Dealt";
         let divider      = "---------------------------------|------------|------------|------------|------------|-------------|------------|------------|------------|------------|------------|------------|------------|------------|------------|------------|------------|-------------";
-        println!("{}", table_header);
+        println!("{table_header}");
-        println!("{}", divider);
+        println!("{divider}");
 
         for (user_id, user_data) in state.users {
             let player_name = user_data.name;

src/codegen/gameevent.rs

@@ -308,7 +308,7 @@ pub fn generate_game_events(demo: Demo) -> TokenStream {
     let event_variants = events.iter().map(|event| {
         let name_str = get_event_name(event.event_type.as_str());
         let name = Ident::new(&name_str, span);
-        let struct_name = Ident::new(&format!("{}Event", name_str), span);
+        let struct_name = Ident::new(&format!("{name_str}Event"), span);
 
         if should_box_event(&name_str) {
             quote!(#name(Box<#struct_name>),)
@@ -352,7 +352,7 @@ pub fn generate_game_events(demo: Demo) -> TokenStream {
     let read_events = events.iter().map(|event| {
         let name = get_event_name(event.event_type.as_str());
         let variant_name = Ident::new(&name, span);
-        let struct_name = Ident::new(&format!("{}Event", name), span);
+        let struct_name = Ident::new(&format!("{name}Event"), span);
 
         if should_box_event(&name) {
             quote!(
@@ -380,7 +380,7 @@ pub fn generate_game_events(demo: Demo) -> TokenStream {
 
     let sizes = events.iter().map(|event| {
         let name = get_event_name(event.event_type.as_str());
-        let struct_name = Ident::new(&format!("{}Event", name), span);
+        let struct_name = Ident::new(&format!("{name}Event"), span);
 
         quote!(
             (#name, std::mem::size_of::<#struct_name>())

src/codegen/propnames.rs

@@ -104,7 +104,7 @@ impl MessageHandler for PropAnalyzer {
         }
         for (table, size) in numeric_tables {
             for num in 0..=size {
-                let prop_name = SendPropName::from(format!("{:03}", num));
+                let prop_name = SendPropName::from(format!("{num:03}"));
                 self.prop_names.insert(
                     SendPropIdentifier::new(&table, prop_name.as_str()),
                     (table.clone().into(), prop_name),

src/demo/message/packetentities.rs

@@ -157,7 +157,7 @@ impl fmt::Display for PacketEntity {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         writeln!(f, "{}({}) {{", self.entity_index, self.server_class)?;
         for child in self.props.iter() {
-            writeln!(f, "\t{}", child)?;
+            writeln!(f, "\t{child}")?;
         }
         write!(f, "}}")
     }

src/demo/parser/player_summary_analyzer.rs

@@ -365,7 +365,7 @@ impl PlayerSummaryAnalyzer {
                             ..
                         }) = packet.get_prop_by_name(
                             "m_iUserID",
-                            format!("{:0>3}", i).as_str(),
+                            format!("{i:0>3}").as_str(),
                             parser_state,
                         ) {
                             let entity_id = EntityId::from(i as u32);

src/demo/sendprop.rs

@@ -355,7 +355,7 @@ impl fmt::Display for SendPropFlags {
             .skip_while(|c| *c != '[')
             .take_while(|c| *c != ')')
             .collect();
-        write!(f, "{}", flags)
+        write!(f, "{flags}")
     }
 }
 
@@ -632,7 +632,7 @@ impl fmt::Display for SendPropValue {
             SendPropValue::Array(array) => {
                 write!(f, "[")?;
                 for child in array {
-                    write!(f, "{}", child)?;
+                    write!(f, "{child}")?;
                 }
                 write!(f, "]")
             }
@@ -1169,7 +1169,7 @@ impl From<SendPropIdentifier> for u64 {
 impl Display for SendPropIdentifier {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         match get_prop_names(*self) {
-            Some((table, prop)) => write!(f, "{}.{}", table, prop),
+            Some((table, prop)) => write!(f, "{table}.{prop}"),
             None => write!(f, "Prop name {} not known", self.0),
         }
     }

tests/entity.rs

@@ -63,7 +63,7 @@ impl EntityDump {
                 .props(state)
                 .map(|prop| {
                     let (table_name, prop_name) = &prop_names[&prop.identifier];
-                    (format!("{}.{}", table_name, prop_name), prop.value)
+                    (format!("{table_name}.{prop_name}"), prop.value)
                 })
                 .collect(),
         }

tests/message_reencode.rs

@@ -39,14 +39,14 @@ fn message_reencode(
     setup_packet_files: &[&str],
     setup_message_files: &[&str],
 ) {
-    let data = fs::read(format!("test_data/messages/{}", input_file)).unwrap();
+    let data = fs::read(format!("test_data/messages/{input_file}")).unwrap();
 
     let mut handler = DemoHandler::parse_all_with_analyser(NullHandler);
     for file in setup_packet_files {
-        setup_packet(&mut handler, &format!("test_data/messages/{}", file));
+        setup_packet(&mut handler, &format!("test_data/messages/{file}"));
     }
     for file in setup_message_files {
-        setup_message(&mut handler, &format!("test_data/messages/{}", file));
+        setup_message(&mut handler, &format!("test_data/messages/{file}"));
     }
 
     let state = &handler.state_handler;

tests/sendprops.rs

@@ -72,7 +72,7 @@ fn flatten_test(input_file: &str) {
                     .into_iter()
                     .map(|prop| {
                         let (table_name, prop_name) = &prop_names[&prop.identifier];
-                        format!("{}.{}", table_name, prop_name)
+                        format!("{table_name}.{prop_name}")
                     })
                     .collect(),
             )

tests/tests.rs

@@ -15,7 +15,7 @@ use tf_demo_parser::{Demo, DemoParser};
 #[test_case("emptysaytext.dem")]
 #[test_case("protocol23.dem")]
 fn snapshot_test(input_file: &str) {
-    let file = fs::read(format!("test_data/{}", input_file)).expect("Unable to read file");
+    let file = fs::read(format!("test_data/{input_file}")).expect("Unable to read file");
     let demo = Demo::new(&file);
     let (_, state) = DemoParser::new(demo.get_stream()).parse().unwrap();
 
@@ -28,7 +28,7 @@ fn snapshot_test(input_file: &str) {
 #[test_case("small.dem")]
 #[test_case("gully.dem")]
 fn game_state_test(input_file: &str) {
-    let file = fs::read(format!("test_data/{}", input_file)).expect("Unable to read file");
+    let file = fs::read(format!("test_data/{input_file}")).expect("Unable to read file");
     let demo = Demo::new(&file);
     let (_, mut state) = DemoParser::new_with_analyser(demo.get_stream(), GameStateAnalyser::new())
         .parse()