dont split player subject untill needed

src/common.rs

@@ -1,4 +1,4 @@
-use crate::raw_event::RawSubject;
+use crate::raw_event::{split_player_subject, RawSubject};
 use enum_iterator::IntoEnumIterator;
 use serde::ser::SerializeMap;
 use serde::{Serialize, Serializer};
@@ -182,10 +182,12 @@ impl TryFrom<&RawSubject<'_>> for SubjectId {
 
     fn try_from(raw: &RawSubject) -> Result<Self, Self::Error> {
         Ok(match raw {
-            RawSubject::Player { steam_id, .. } => {
+            RawSubject::Player(raw) => {
-                if let Some(raw_account_id) = steam_id
+                if let Some(raw_account_id) = raw
-                    .strip_prefix("[U:1:")
+                    .rsplit_once(":")
-                    .and_then(|s| s.strip_suffix(']'))
+                    .map(|(_, s)| s)
+                    .and_then(|s| s.split_once(']'))
+                    .map(|(s, _)| s)
                 {
                     SubjectId::Player(
                         raw_account_id
@@ -235,18 +237,17 @@ impl TryFrom<&RawSubject<'_>> for SubjectData {
 
     fn try_from(raw: &RawSubject<'_>) -> Result<Self, Self::Error> {
         Ok(match raw {
-            RawSubject::Player {
+            RawSubject::Player(raw) => {
-                name,
+                let (_, (name, user_id, steam_id, team)) =
-                user_id,
+                    split_player_subject(raw).map_err(|_| SubjectError::InvalidUserId)?;
-                steam_id,
+                SubjectData::Player {
-                team,
+                    name: name.to_string(),
-            } => SubjectData::Player {
+                    user_id: user_id.parse().map_err(|_| SubjectError::InvalidUserId)?,
-                name: name.to_string(),
+                    steam_id: SteamID::from_steam3(steam_id)
-                user_id: user_id.parse().map_err(|_| SubjectError::InvalidUserId)?,
+                        .map_err(|_| SubjectError::InvalidSteamId)?,
-                steam_id: SteamID::from_steam3(steam_id)
+                    team: team.parse().map_err(|_| SubjectError::InvalidTeam)?,
-                    .map_err(|_| SubjectError::InvalidSteamId)?,
+                }
-                team: team.parse().map_err(|_| SubjectError::InvalidTeam)?,
+            }
-            },
             RawSubject::Team(team) => SubjectData::Team(team.parse().unwrap()),
             RawSubject::System(name) => SubjectData::System(name.to_string()),
             RawSubject::Console => SubjectData::Console,

src/raw_event.rs

@@ -2,7 +2,7 @@ use crate::{SubjectError, SubjectId};
 use chrono::{DateTime, TimeZone, Utc};
 use enum_iterator::IntoEnumIterator;
 use nom::branch::alt;
-use nom::bytes::complete::{tag, take_while};
+use nom::bytes::complete::{tag, tag_no_case, take_while};
 use nom::character::complete::{digit1, one_of};
 use nom::error::{make_error, ErrorKind};
 use nom::{Finish, IResult};
@@ -104,12 +104,7 @@ fn date_parser(input: &str) -> IResult<&str, RawDate> {
 
 #[derive(Debug, PartialEq)]
 pub enum RawSubject<'a> {
-    Player {
+    Player(&'a str),
-        name: &'a str,
-        user_id: &'a str,
-        steam_id: &'a str,
-        team: &'a str,
-    },
     Team(&'a str),
     System(&'a str),
     Console,
@@ -117,16 +112,6 @@ pub enum RawSubject<'a> {
 }
 
 impl<'a> RawSubject<'a> {
-    pub fn name(&self) -> &'a str {
-        match self {
-            RawSubject::Player { name, .. } => name,
-            RawSubject::Team(team) => team,
-            RawSubject::System(system) => system,
-            RawSubject::Console => "Console",
-            RawSubject::World => "World",
-        }
-    }
-
     pub fn id(&self) -> Result<SubjectId, SubjectError> {
         self.try_into()
     }
@@ -145,7 +130,7 @@ fn subject_parser_console(input: &str) -> IResult<&str, RawSubject> {
 fn subject_parser_team(input: &str) -> IResult<&str, RawSubject> {
     let (input, _) = tag(r#"Team ""#)(input)?;
 
-    let (input, team) = alt((tag("Red"), tag("Blue")))(input)?;
+    let (input, team) = alt((tag_no_case("red"), tag_no_case("blue")))(input)?;
 
     let (input, _) = one_of("\"")(input)?;
     Ok((input, RawSubject::Team(team)))
@@ -165,9 +150,7 @@ fn subject_parser_system(input: &str) -> IResult<&str, RawSubject> {
     Ok((input, RawSubject::System(name)))
 }
 
-fn subject_parser_player(input: &str) -> IResult<&str, RawSubject> {
+pub fn split_player_subject(input: &str) -> IResult<&str, (&str, &str, &str, &str)> {
-    let (input, _) = one_of("\"")(input)?;
-
     let (input, name) = take_while(|c| c != '<')(input)?;
 
     let (input, _) = one_of("<")(input)?;
@@ -182,25 +165,25 @@ fn subject_parser_player(input: &str) -> IResult<&str, RawSubject> {
     let (input, team) = take_while(|c| c != '>')(input)?;
     let (input, _) = one_of(">")(input)?;
 
+    Ok((input, (name, user_id, steam_id, team)))
+}
+
+fn subject_parser_player(input: &str) -> IResult<&str, RawSubject> {
     let (input, _) = one_of("\"")(input)?;
 
-    Ok((
+    let (input, subject) = take_while(|c| c != '"')(input)?;
-        input,
+
-        RawSubject::Player {
+    let (input, _) = one_of("\"")(input)?;
-            name,
+
-            user_id,
+    Ok((input, RawSubject::Player(subject)))
-            steam_id,
-            team,
-        },
-    ))
 }
 
 pub fn subject_parser(input: &str) -> IResult<&str, RawSubject> {
     alt((
         subject_parser_console,
+        subject_parser_player,
         subject_parser_world,
         subject_parser_team,
-        subject_parser_player,
         subject_parser_system,
     ))(input)
 }
@@ -338,7 +321,6 @@ fn event_type_parser(input: &str) -> IResult<&str, RawEventType> {
             return Ok((input, event_type));
         }
     }
-    dbg!(input);
     Err(nom::Err::Error(make_error(input, ErrorKind::NoneOf)))
 }
 
@@ -357,14 +339,9 @@ fn test_parse_raw() {
                 minutes: "13",
                 seconds: "57",
             },
-            subject: RawSubject::Player {
+            subject: RawSubject::Player("makxbi<27><[U:1:40364391]><Red>"),
-                name: "makxbi",
-                user_id: "27",
-                steam_id: "[U:1:40364391]",
-                team: "Red",
-            },
             ty: RawEventType::ChangedRole,
-            params: r#""sniper""#,
+            params: r#"to "sniper""#,
         },
         raw
     );