Format code using rustfmt

analysis/src/endofgame.rs

@@ -42,7 +42,8 @@ pub fn parse(buf: &[u8]) -> Result<EndOfGame, ()> {
     let header = &output.header;
 
     let mut player_stats = std::collections::HashMap::<_, PlayerStats>::new();
-    let mut pawn_to_player = std::collections::HashMap::<csdemo::structured::pawnid::PawnID, csdemo::UserId>::new();
+    let mut pawn_to_player =
+        std::collections::HashMap::<csdemo::structured::pawnid::PawnID, csdemo::UserId>::new();
 
     let mut track = false;
     let mut player_life = std::collections::HashMap::<_, u8>::new();
@@ -62,7 +63,17 @@ pub fn parse(buf: &[u8]) -> Result<EndOfGame, ()> {
 
                         player_life.insert(userid.clone(), 100);
 
-                        if let Some(pawn) = pspawn.userid_pawn.as_ref().map(|p| match p { csdemo::RawValue::I32(v) => Some(csdemo::structured::pawnid::PawnID::from(*v)), _ => None }).flatten() {
+                        if let Some(pawn) = pspawn
+                            .userid_pawn
+                            .as_ref()
+                            .map(|p| match p {
+                                csdemo::RawValue::I32(v) => {
+                                    Some(csdemo::structured::pawnid::PawnID::from(*v))
+                                }
+                                _ => None,
+                            })
+                            .flatten()
+                        {
                             pawn_to_player.insert(pawn, userid);
                         }
                     }
@@ -101,7 +112,10 @@ pub fn parse(buf: &[u8]) -> Result<EndOfGame, ()> {
             };
 
             let pawns = team.player_pawns();
-            let player_ids = pawns.into_iter().filter_map(|pawn| pawn_to_player.get(&pawn)).collect::<Vec<_>>();
+            let player_ids = pawns
+                .into_iter()
+                .filter_map(|pawn| pawn_to_player.get(&pawn))
+                .collect::<Vec<_>>();
             if player_ids.is_empty() {
                 if let Some(team_number) = entity_to_team.get(&team.entity_id()) {
                     if let Some(score) = team.score() {
@@ -114,15 +128,20 @@ pub fn parse(buf: &[u8]) -> Result<EndOfGame, ()> {
                 continue;
             }
 
-            let team_number = player_ids.iter().filter_map(|p| output.player_info.get(*p).map(|p| p.team)).next().unwrap();
+            let team_number = player_ids
+                .iter()
+                .filter_map(|p| output.player_info.get(*p).map(|p| p.team))
+                .next()
+                .unwrap();
 
             entity_to_team.insert(team.entity_id(), team_number);
 
-            let team_entry = teams.entry(team_number).or_insert_with(|| {
+            let team_entry = teams.entry(team_number).or_insert_with(|| TeamInfo {
-                TeamInfo {
                 end_score: 0,
-                    start_side: team.team_name().map(|t| t.to_owned()).unwrap_or(String::new()),
+                start_side: team
-                }
+                    .team_name()
+                    .map(|t| t.to_owned())
+                    .unwrap_or(String::new()),
             });
             if let Some(score) = team.score() {
                 team_entry.end_score = score as usize;

backend/src/analysis/base.rs

@@ -66,12 +66,19 @@ impl Analysis for BaseAnalysis {
 
         let base_result = BaseInfo {
             map: result.map,
-            teams: result.teams.into_iter().map(|(numb, team)| {
+            teams: result
-                (numb, BaseTeamInfo {
+                .teams
+                .into_iter()
+                .map(|(numb, team)| {
+                    (
+                        numb,
+                        BaseTeamInfo {
                             end_score: team.end_score,
                             start_side: team.start_side,
+                        },
+                    )
                 })
-            }).collect(),
+                .collect(),
             players: result
                 .players
                 .into_iter()
@@ -119,14 +126,16 @@ impl Analysis for BaseAnalysis {
             })
             .unzip();
 
-        let teams = base_result.teams.into_iter().map(|(numb, team)| {
+        let teams = base_result
-            crate::models::DemoTeam {
+            .teams
+            .into_iter()
+            .map(|(numb, team)| crate::models::DemoTeam {
                 demo_id: input.demoid.clone(),
                 team: numb as i16,
                 end_score: team.end_score as i16,
                 start_name: team.start_side,
-            }
+            })
-        }).collect::<Vec<_>>();
+            .collect::<Vec<_>>();
 
         let demo_info = crate::models::DemoInfo {
             demo_id: input.demoid.clone(),
@@ -179,7 +188,8 @@ impl Analysis for BaseAnalysis {
                     crate::schema::demo_teams::dsl::demo_id,
                     crate::schema::demo_teams::dsl::team,
                 ))
-            .do_update().set((
+                .do_update()
+                .set((
                     crate::schema::demo_teams::dsl::start_name.eq(diesel::upsert::excluded(
                         crate::schema::demo_teams::dsl::start_name,
                     )),

backend/src/api/demos.rs

@@ -55,12 +55,17 @@ async fn list(
             crate::models::DemoTeam::as_select(),
         ))
         .filter(crate::schema::demos::dsl::steam_id.eq(steam_id.to_string()));
-    let results: Vec<(crate::models::Demo, crate::models::DemoInfo, crate::models::DemoTeam)> =
+    let results: Vec<(
-        query.load(&mut crate::db_connection().await).await.unwrap();
+        crate::models::Demo,
+        crate::models::DemoInfo,
+        crate::models::DemoTeam,
+    )> = query.load(&mut crate::db_connection().await).await.unwrap();
 
     let mut demos = std::collections::HashMap::new();
     for (demo, info, team) in results.into_iter() {
-        let entry = demos.entry(demo.demo_id.clone()).or_insert(common::BaseDemoInfo {
+        let entry = demos
+            .entry(demo.demo_id.clone())
+            .or_insert(common::BaseDemoInfo {
                 id: demo.demo_id,
                 map: info.map,
                 team2_score: 0,
@@ -278,7 +283,7 @@ async fn scoreboard(
     }
 
     Ok(axum::Json(common::demo_analysis::ScoreBoard {
-        teams: teams.into_iter().collect::<Vec<_>>()
+        teams: teams.into_iter().collect::<Vec<_>>(),
     }))
 }
 
@@ -445,12 +450,13 @@ async fn perround(
         result.push(common::demo_analysis::DemoRound { reason, events });
     }
 
-    let teams = raw_teams.into_iter().map(|dteam| {
+    let teams = raw_teams
-        common::demo_analysis::PerRoundTeam {
+        .into_iter()
+        .map(|dteam| common::demo_analysis::PerRoundTeam {
             name: dteam.start_name,
             number: dteam.team as u32,
-        }
+        })
-    }).collect();
+        .collect();
 
     Ok(axum::Json(common::demo_analysis::PerRoundResult {
         rounds: result,

common/src/demo_analysis.rs

@@ -1,6 +1,6 @@
 #[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
 pub struct ScoreBoard {
-        pub teams: Vec<(u32, Vec<ScoreBoardPlayer>)>
+    pub teams: Vec<(u32, Vec<ScoreBoardPlayer>)>,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
@@ -34,7 +34,7 @@ pub struct PerRoundTeam {
 #[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
 pub struct DemoRound {
     pub reason: RoundWinReason,
-        pub events: Vec<RoundEvent>
+    pub events: Vec<RoundEvent>,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
@@ -66,8 +66,5 @@ pub struct PerRoundTeam {
 pub enum RoundEvent {
     BombPlanted,
     BombDefused,
-        Killed {
+    Killed { attacker: String, died: String },
-            attacker: String,
-            died: String,
-        },
 }