tf2_line_parser 0.2.3 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 46a0f04b46043dd222fd9d5d73f2ea81969917539758a229ad9b830222d7d0fe
-  data.tar.gz: 734fbc7d3cccced8f84f5bddd3e06616ce1270508da008dbe259651be1d11231
+  metadata.gz: 01e322507f92ef5ebd648bf65a7412a916e3a84b118c58bb322edcee2539f85e
+  data.tar.gz: f1af28f6e5cc32f7579e80f73eb353cb4406c3902ae72ecb8fd13f4cf20c2a23
 SHA512:
-  metadata.gz: ba4161880723e5af2a6140deb9f1eb9954b84b01dbcebebc0e21c8999342af7614250a9073cb7af76aa41cb9b509e285007f8454c6d327f16cb8cb5d27d1afce
-  data.tar.gz: 9e2d9c9f6f114775f5d5c9564a1b51176d1c58239d67285440fc95a388a4601e7f88c3509727e615edcb85e443b6175b4f0a394e44dea31e57860ce5387cff8e
+  metadata.gz: f2e66e19141bb1109c3c35ea0cd993f5b67c7a688f1022e31595aae187a038c2aee6618d0a2b51b5988e99eede992710ba1426730674b80bf41da9162882806a
+  data.tar.gz: 67d849993089b15ff95af89cabd3fe680d49afcc4640a5a8b245bd9dfdc3d7ddedbe5a24de88fae73acc27998329c41b27e66c86a45570bec0f4df1c85f328d7

data/Gemfile.lock

@@ -1,74 +1,83 @@
 PATH
   remote: .
   specs:
-    tf2_line_parser (0.2.2)
+    tf2_line_parser (0.2.3)
       activesupport
 
 GEM
   remote: https://rubygems.org/
   specs:
-    activesupport (6.1.3.2)
-      concurrent-ruby (~> 1.0, >= 1.0.2)
+    activesupport (8.0.2)
+      base64
+      benchmark (>= 0.3)
+      bigdecimal
+      concurrent-ruby (~> 1.0, >= 1.3.1)
+      connection_pool (>= 2.2.5)
+      drb
       i18n (>= 1.6, < 2)
+      logger (>= 1.4.2)
       minitest (>= 5.1)
-      tzinfo (~> 2.0)
-      zeitwerk (~> 2.3)
-    coderay (1.1.1)
-    concurrent-ruby (1.1.8)
-    coveralls (0.8.21)
-      json (>= 1.8, < 3)
-      simplecov (~> 0.14.1)
-      term-ansicolor (~> 1.3)
-      thor (~> 0.19.4)
-      tins (~> 1.6)
-    diff-lcs (1.3)
-    docile (1.1.5)
-    i18n (1.8.10)
+      securerandom (>= 0.3)
+      tzinfo (~> 2.0, >= 2.0.5)
+      uri (>= 0.13.1)
+    base64 (0.3.0)
+    benchmark (0.4.1)
+    bigdecimal (3.2.2)
+    concurrent-ruby (1.3.5)
+    connection_pool (2.5.3)
+    coveralls_reborn (0.29.0)
+      simplecov (~> 0.22.0)
+      term-ansicolor (~> 1.7)
+      thor (~> 1.2)
+      tins (~> 1.32)
+    diff-lcs (1.6.2)
+    docile (1.4.1)
+    drb (2.2.3)
+    i18n (1.14.7)
       concurrent-ruby (~> 1.0)
-    json (2.1.0)
-    method_source (0.8.2)
-    minitest (5.14.4)
-    pry (0.10.4)
-      coderay (~> 1.1.0)
-      method_source (~> 0.8.1)
-      slop (~> 3.4)
-    pry-nav (0.2.4)
-      pry (>= 0.9.10, < 0.11.0)
-    rspec (3.5.0)
-      rspec-core (~> 3.5.0)
-      rspec-expectations (~> 3.5.0)
-      rspec-mocks (~> 3.5.0)
-    rspec-core (3.5.4)
-      rspec-support (~> 3.5.0)
-    rspec-expectations (3.5.0)
+    json (2.12.2)
+    logger (1.7.0)
+    minitest (5.25.5)
+    rspec (3.13.1)
+      rspec-core (~> 3.13.0)
+      rspec-expectations (~> 3.13.0)
+      rspec-mocks (~> 3.13.0)
+    rspec-core (3.13.4)
+      rspec-support (~> 3.13.0)
+    rspec-expectations (3.13.5)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.5.0)
-    rspec-mocks (3.5.0)
+      rspec-support (~> 3.13.0)
+    rspec-mocks (3.13.5)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.5.0)
-    rspec-support (3.5.0)
-    simplecov (0.14.1)
-      docile (~> 1.1.0)
-      json (>= 1.8, < 3)
-      simplecov-html (~> 0.10.0)
-    simplecov-html (0.10.1)
-    slop (3.6.0)
-    term-ansicolor (1.6.0)
+      rspec-support (~> 3.13.0)
+    rspec-support (3.13.4)
+    securerandom (0.4.1)
+    simplecov (0.22.0)
+      docile (~> 1.1)
+      simplecov-html (~> 0.11)
+      simplecov_json_formatter (~> 0.1)
+    simplecov-html (0.13.1)
+    simplecov_json_formatter (0.1.4)
+    sync (0.5.0)
+    term-ansicolor (1.11.2)
       tins (~> 1.0)
-    thor (0.19.4)
-    tins (1.15.0)
-    tzinfo (2.0.4)
+    thor (1.3.2)
+    tins (1.38.0)
+      bigdecimal
+      sync
+    tzinfo (2.0.6)
       concurrent-ruby (~> 1.0)
-    zeitwerk (2.4.2)
+    uri (1.0.3)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
-  coveralls
-  pry-nav
-  rspec (~> 3.5.0)
+  coveralls_reborn
+  json
+  rspec
+  simplecov
   tf2_line_parser!
 
 BUNDLED WITH
-   1.14.5
+   2.3.16

data/lib/tf2_line_parser/events/airshot.rb

@@ -12,14 +12,33 @@ module TF2LineParser
       end
 
       def self.attributes
-        @attributes ||= %i[time player_nick player_steamid player_team target_nick target_steamid
-                           target_team value weapon airshot]
+        @attributes ||= %i[time player_section target_section weapon airshot]
       end
 
-      def initialize(time, player_name, player_steamid, player_team, target_name, target_steamid, target_team, value, weapon, airshot)
+      def self.regex_results(matched_line)
+        time = matched_line['time']
+        player_section = matched_line['player_section']
+        target_section = matched_line['target_section']
+        value = matched_line['value']
+        weapon = matched_line['weapon']
+        airshot = matched_line['airshot']
+
+        # Parse player section
+        player_name, player_uid, player_steamid, player_team = parse_player_section(player_section)
+
+        # Parse target section if present
+        target_name, target_uid, target_steamid, target_team = nil, nil, nil, nil
+        if target_section
+          target_name, target_uid, target_steamid, target_team = parse_target_section(target_section)
+        end
+
+        [time, player_name, player_uid, player_steamid, player_team, target_name, target_uid, target_steamid, target_team, value, weapon, airshot]
+      end
+
+      def initialize(time, player_name, player_uid, player_steamid, player_team, target_name, target_uid, target_steamid, target_team, value, weapon, airshot)
         @time = parse_time(time)
-        @player = Player.new(player_name, player_steamid, player_team)
-        @target = Player.new(target_name, target_steamid, target_team) if target_name
+        @player = Player.new(player_name, player_uid, player_steamid, player_team)
+        @target = Player.new(target_name, target_uid, target_steamid, target_team) if target_name
         @value = value.to_i
         @weapon = weapon
         @airshot = (airshot.to_i == 1)

data/lib/tf2_line_parser/events/assist.rb

@@ -6,6 +6,10 @@ module TF2LineParser
       def self.regex
         @regex ||= /#{regex_time} #{regex_player} triggered "kill assist" against #{regex_target}/.freeze
       end
+
+      def self.attributes
+        @attributes ||= %i[time player_section target_section]
+      end
     end
   end
 end

data/lib/tf2_line_parser/events/capture_block.rb

@@ -8,12 +8,12 @@ module TF2LineParser
       end
 
       def self.attributes
-        @attributes ||= %i[time player_nick player_steamid player_team cp_number cp_name]
+        @attributes ||= %i[time player_section cp_number cp_name]
       end
 
-      def initialize(time, player_name, player_steam_id, player_team, cap_number, cap_name)
+      def initialize(time, player_name, player_uid, player_steam_id, player_team, cap_number, cap_name)
         @time = parse_time(time)
-        @player = Player.new(player_name, player_steam_id, player_team)
+        @player = Player.new(player_name, player_uid, player_steam_id, player_team)
         @cap_number = cap_number
         @cap_name = cap_name
       end

data/lib/tf2_line_parser/events/charge_deployed.rb

@@ -8,12 +8,12 @@ module TF2LineParser
       end
 
       def self.attributes
-        @attributes ||= %i[time player_nick player_steamid player_team]
+        @attributes ||= %i[time player_section]
       end
 
-      def initialize(time, name, steam_id, team)
+      def initialize(time, name, uid, steam_id, team)
         @time = parse_time(time)
-        @player = Player.new(name, steam_id, team)
+        @player = Player.new(name, uid, steam_id, team)
       end
     end
   end

data/lib/tf2_line_parser/events/chat.rb

@@ -3,14 +3,25 @@
 module TF2LineParser
   module Events
     class Chat < Event
-      def initialize(time, player_name, player_steam_id, player_team, message)
+      def initialize(time, player_name, player_uid, player_steam_id, player_team, message)
         @time = parse_time(time)
-        @player = Player.new(player_name, player_steam_id, player_team)
+        @player = Player.new(player_name, player_uid, player_steam_id, player_team)
         @message = message
       end
 
       def self.attributes
-        @attributes ||= %i[time player_nick player_steamid player_team message]
+        @attributes ||= %i[time player_section message]
+      end
+
+      def self.regex_results(matched_line)
+        time = matched_line['time']
+        player_section = matched_line['player_section']
+        message = matched_line['message']
+
+        # Parse player section
+        player_name, player_uid, player_steamid, player_team = parse_player_section(player_section)
+
+        [time, player_name, player_uid, player_steamid, player_team, message]
       end
     end
 

data/lib/tf2_line_parser/events/connect.rb

@@ -3,14 +3,14 @@
 module TF2LineParser
   module Events
     class Connect < Event
-      def initialize(time, player_name, player_steam_id, player_team, message)
+      def initialize(time, player_name, player_uid, player_steam_id, player_team, message)
         @time = parse_time(time)
-        @player = Player.new(player_name, player_steam_id, player_team)
+        @player = Player.new(player_name, player_uid, player_steam_id, player_team)
         @message = message
       end
 
       def self.attributes
-        @attributes ||= %i[time player_nick player_steamid player_team message]
+        @attributes ||= %i[time player_section message]
       end
 
       def self.regex

data/lib/tf2_line_parser/events/damage.rb

@@ -20,14 +20,32 @@ module TF2LineParser
       end
 
       def self.attributes
-        @attributes ||= %i[time player_nick player_steamid player_team target_nick target_steamid
-                           target_team value weapon]
+        @attributes ||= %i[time player_section target_section value weapon]
       end
 
-      def initialize(time, player_name, player_steamid, player_team, target_name, target_steamid, target_team, value, weapon)
+      def self.regex_results(matched_line)
+        time = matched_line['time']
+        player_section = matched_line['player_section']
+        target_section = matched_line['target_section']
+        value = matched_line['value']
+        weapon = matched_line['weapon']
+
+        # Parse player section
+        player_name, player_uid, player_steamid, player_team = parse_player_section(player_section)
+
+        # Parse target section if present
+        target_name, target_uid, target_steamid, target_team = nil, nil, nil, nil
+        if target_section
+          target_name, target_uid, target_steamid, target_team = parse_target_section(target_section)
+        end
+
+        [time, player_name, player_uid, player_steamid, player_team, target_name, target_uid, target_steamid, target_team, value, weapon]
+      end
+
+      def initialize(time, player_name, player_uid, player_steamid, player_team, target_name, target_uid, target_steamid, target_team, value, weapon)
         @time = parse_time(time)
-        @player = Player.new(player_name, player_steamid, player_team)
-        @target = Player.new(target_name, target_steamid, target_team) if target_name
+        @player = Player.new(player_name, player_uid, player_steamid, player_team)
+        @target = Player.new(target_name, target_uid, target_steamid, target_team) if target_name
         @value = value.to_i
         @weapon = weapon
       end

data/lib/tf2_line_parser/events/disconnect.rb

@@ -3,14 +3,14 @@
 module TF2LineParser
   module Events
     class Disconnect < Event
-      def initialize(time, player_name, player_steam_id, player_team, message)
+      def initialize(time, player_name, player_uid, player_steam_id, player_team, message)
         @time = parse_time(time)
-        @player = Player.new(player_name, player_steam_id, player_team)
+        @player = Player.new(player_name, player_uid, player_steam_id, player_team)
         @message = message
       end
 
       def self.attributes
-        @attributes ||= %i[time player_nick player_steamid player_team message]
+        @attributes ||= %i[time player_section message]
       end
 
       def self.regex

data/lib/tf2_line_parser/events/domination.rb

@@ -6,6 +6,10 @@ module TF2LineParser
       def self.regex
         @regex ||= /#{regex_time} #{regex_player} triggered "domination" against #{regex_target}.*/.freeze
       end
+
+      def self.attributes
+        @attributes ||= %i[time player_section target_section]
+      end
     end
   end
 end

data/lib/tf2_line_parser/events/event.rb

@@ -15,11 +15,11 @@ module TF2LineParser
       end
 
       def self.regex_player
-        @regex_player ||= '"(?\'player_nick\'.+)<(?\'player_uid\'\d+)><(?\'player_steamid\'(\[\S+\]|STEAM_\S+))><(?\'player_team\'Red|Blue|Spectator|TERRORIST|CT||)>"'
+        @regex_player ||= /"(?<player_section>.*?)"/
       end
 
       def self.regex_target
-        @regex_target ||= '"(?\'target_nick\'.+)<(?\'target_uid\'\d+)><(?\'target_steamid\'(\[\S+\]|STEAM_\S+))><(?\'target_team\'Red|Blue|TERRORIST|CT)>"'
+        @regex_target ||= /"(?<target_section>.*?)"/
       end
 
       def self.regex_cap
@@ -43,14 +43,121 @@ module TF2LineParser
       end
 
       def self.regex_results(matched_line)
-        attributes.collect do |attribute|
-          matched_line[attribute]
+        out = []
+        attributes.each do |attribute|
+          case attribute
+          when :player_section
+            if matched_line['player_section']
+              out.concat(parse_player_section(matched_line['player_section']))
+            else
+              out.concat([nil, nil, nil, nil])
+            end
+          when :target_section
+            if matched_line['target_section']
+              out.concat(parse_target_section(matched_line['target_section']))
+            else
+              out.concat([nil, nil, nil, nil])
+            end
+          else
+            out << matched_line[attribute]
+          end
         end
+        out
       end
 
       def parse_time(time_string)
         Time.strptime(time_string, Event.time_format)
       end
+
+      def self.parse_player_section(section)
+        return [nil, nil, nil, nil] unless section
+
+        # Find all <...> groups in the section
+        parts = section.scan(/<([^>]*)>/)
+        return [nil, nil, nil, nil] if parts.length < 2
+
+        # For the cheeky name tests, we need to find the last complete set of uid/steamid/team
+        # Look for the pattern: <uid><steamid><team> at the end
+        if parts.length >= 3
+          # Try to find the last complete set of 3 groups
+          # Start from the end and work backwards
+          last_valid_set = nil
+          (parts.length - 2).downto(0) do |i|
+            if i + 2 < parts.length
+              uid = parts[i][0]
+              steamid = parts[i + 1][0]
+              team = parts[i + 2][0]
+
+              # Check if this looks like a valid set (uid is numeric, steamid looks like steam id, team is valid)
+              if uid.match?(/^\d+$/) && (steamid.start_with?('STEAM_') || steamid.start_with?('[U:')) && ['Red', 'Blue', 'Unassigned', 'Spectator', ''].include?(team)
+                # This looks like a valid player info set
+                last_valid_set = [i, uid, steamid, team]
+                break  # Take the last (rightmost) valid set
+              end
+            end
+          end
+
+          if last_valid_set
+            i, uid, steamid, team = last_valid_set
+            # The name is everything before the first <...> group of this set
+            uid_start = section.index("<#{uid}>")
+            if uid_start
+              name = section[0...uid_start]
+              return [name, uid, steamid, team]
+            end
+          end
+        end
+
+        # Handle cases with 2 or 3 groups (normal case)
+        if parts.length == 2
+          # Only uid and steamid, no team
+          uid = parts[0][0]
+          steamid = parts[1][0]
+          team = ""
+        else
+          # uid, steamid, and team
+          uid = parts[-3][0]
+          steamid = parts[-2][0]
+          team = parts[-1][0]
+        end
+
+        # The name is everything before the first <...> group
+        name_end = section.index("<#{uid}>")
+        return [nil, nil, nil, nil] unless name_end
+
+        name = section[0...name_end]
+
+        [name, uid, steamid, team]
+      end
+
+      def self.parse_target_section(section)
+        return [nil, nil, nil, nil] unless section
+
+        # Same logic as player but for targets
+        parts = section.scan(/<([^>]*)>/)
+        return [nil, nil, nil, nil] if parts.length < 2
+
+        # Handle cases with 2 or 3 groups
+        if parts.length == 2
+          # Only uid and steamid, no team
+          uid = parts[0][0]
+          steamid = parts[1][0]
+          team = ""
+        else
+          # uid, steamid, and team
+          uid = parts[-3][0]
+          steamid = parts[-2][0]
+          team = parts[-1][0]
+        end
+
+        # The name is everything before the first <...> group
+        name_end = section.index("<#{uid}>")
+        return [nil, nil, nil, nil] unless name_end
+
+        name = section[0...name_end]
+
+        [name, uid, steamid, team]
+      end
     end
   end
 end

data/lib/tf2_line_parser/events/headshot_damage.rb

@@ -12,14 +12,13 @@ module TF2LineParser
       end
 
       def self.attributes
-        @attributes ||= %i[time player_nick player_steamid player_team target_nick target_steamid
-                           target_team value weapon]
+        @attributes ||= %i[time player_section target_section value weapon]
       end
 
-      def initialize(time, player_name, player_steamid, player_team, target_name, target_steamid, target_team, value, weapon)
+      def initialize(time, player_name, player_uid, player_steamid, player_team, target_name, target_uid, target_steamid, target_team, value, weapon)
         @time = parse_time(time)
-        @player = Player.new(player_name, player_steamid, player_team)
-        @target = Player.new(target_name, target_steamid, target_team) if target_name
+        @player = Player.new(player_name, player_uid, player_steamid, player_team)
+        @target = Player.new(target_name, target_uid, target_steamid, target_team) if target_name
         @value = value.to_i
         @weapon = weapon
       end

data/lib/tf2_line_parser/events/heal.rb

@@ -8,14 +8,13 @@ module TF2LineParser
       end
 
       def self.attributes
-        @attributes ||= %i[time player_nick player_steamid player_team target_nick target_steamid
-                           target_team value]
+        @attributes ||= %i[time player_section target_section value]
       end
 
-      def initialize(time, player_name, player_steam_id, player_team, target_name, target_steam_id, target_team, value)
+      def initialize(time, player_name, player_uid, player_steam_id, player_team, target_name, target_uid, target_steam_id, target_team, value)
         @time = parse_time(time)
-        @player = Player.new(player_name, player_steam_id, player_team)
-        @target = Player.new(target_name, target_steam_id, target_team)
+        @player = Player.new(player_name, player_uid, player_steam_id, player_team)
+        @target = Player.new(target_name, target_uid, target_steam_id, target_team)
         @value = value.to_i
       end
     end

data/lib/tf2_line_parser/events/kill.rb

@@ -16,14 +16,13 @@ module TF2LineParser
       end
 
       def self.attributes
-        @attributes ||= %i[time player_nick player_steamid player_team target_nick target_steamid
-                           target_team weapon customkill]
+        @attributes ||= %i[time player_section target_section weapon customkill]
       end
 
-      def initialize(time, player_name, player_steam_id, player_team, target_name, target_steam_id, target_team, weapon, customkill)
+      def initialize(time, player_name, player_uid, player_steam_id, player_team, target_name, target_uid, target_steam_id, target_team, weapon, customkill)
         @time = parse_time(time)
-        @player = Player.new(player_name, player_steam_id, player_team)
-        @target = Player.new(target_name, target_steam_id, target_team)
+        @player = Player.new(player_name, player_uid, player_steam_id, player_team)
+        @target = Player.new(target_name, target_uid, target_steam_id, target_team)
         @weapon = weapon
         @customkill = customkill
       end

data/lib/tf2_line_parser/events/medic_death.rb

@@ -12,14 +12,13 @@ module TF2LineParser
       end
 
       def self.attributes
-        @attributes ||= %i[time player_nick player_steamid player_team target_nick target_steamid
-                           target_team healing ubercharge]
+        @attributes ||= %i[time player_section target_section healing ubercharge]
       end
 
-      def initialize(time, player_name, player_steam_id, player_team, target_name, target_steam_id, target_team, healing, ubercharge)
+      def initialize(time, player_name, player_uid, player_steam_id, player_team, target_name, target_uid, target_steam_id, target_team, healing, ubercharge)
         @time = parse_time(time)
-        @player = Player.new(player_name, player_steam_id, player_team)
-        @target = Player.new(target_name, target_steam_id, target_team)
+        @player = Player.new(player_name, player_uid, player_steam_id, player_team)
+        @target = Player.new(target_name, target_uid, target_steam_id, target_team)
         @healing = healing.to_i
         @ubercharge = (ubercharge == '1')
       end

data/lib/tf2_line_parser/events/pickup_item.rb

@@ -14,6 +14,10 @@ module TF2LineParser
       def self.item
         :item
       end
+
+      def self.attributes
+        @attributes ||= %i[time player_section item]
+      end
     end
   end
 end

data/lib/tf2_line_parser/events/player_action_event.rb

@@ -8,12 +8,12 @@ module TF2LineParser
       end
 
       def self.attributes
-        @attributes ||= [:time, :player_nick, :player_steamid, :player_team, item]
+        @attributes ||= [:time, :player_section, :item]
       end
 
-      def initialize(time, player_name, player_steam_id, player_team, item = self.class.item)
+      def initialize(time, player_name, player_uid, player_steam_id, player_team, item = self.class.item)
         @time = parse_time(time)
-        @player = Player.new(player_name, player_steam_id, player_team)
+        @player = Player.new(player_name, player_uid, player_steam_id, player_team)
         instance_variable_set("@#{self.class.item}", item)
       end
     end

data/lib/tf2_line_parser/events/pvp_event.rb

@@ -4,14 +4,13 @@ module TF2LineParser
   module Events
     class PVPEvent < Event
       def self.attributes
-        @attributes ||= %i[time player_nick player_steamid player_team target_nick target_steamid
-                           target_team]
+        @attributes ||= %i[time player_section target_section]
       end
 
-      def initialize(time, player_name, player_steam_id, player_team, target_name, target_steam_id, target_team)
+      def initialize(time, player_name, player_uid, player_steam_id, player_team, target_name, target_uid, target_steam_id, target_team)
         @time = parse_time(time)
-        @player = Player.new(player_name, player_steam_id, player_team)
-        @target = Player.new(target_name, target_steam_id, target_team)
+        @player = Player.new(player_name, player_uid, player_steam_id, player_team)
+        @target = Player.new(target_name, target_uid, target_steam_id, target_team)
       end
     end
   end

data/lib/tf2_line_parser/events/revenge.rb

@@ -6,6 +6,10 @@ module TF2LineParser
       def self.regex
         @regex ||= /#{regex_time} #{regex_player} triggered "revenge" against #{regex_target}.*/.freeze
       end
+
+      def self.attributes
+        @attributes ||= %i[time player_section target_section]
+      end
     end
   end
 end

data/lib/tf2_line_parser/events/role_change.rb

@@ -14,6 +14,10 @@ module TF2LineParser
       def self.item
         :role
       end
+
+      def self.attributes
+        @attributes ||= %i[time player_section role]
+      end
     end
   end
 end

data/lib/tf2_line_parser/events/spawn.rb

@@ -6,6 +6,10 @@ module TF2LineParser
       def self.action_text
         @action_text ||= 'spawned as'
       end
+
+      def self.attributes
+        @attributes ||= %i[time player_section role]
+      end
     end
   end
 end

data/lib/tf2_line_parser/events/suicide.rb

@@ -14,6 +14,10 @@ module TF2LineParser
       def self.item
         :method
       end
+
+      def self.attributes
+        @attributes ||= %i[time player_section method]
+      end
     end
   end
 end

data/lib/tf2_line_parser/player.rb

@@ -2,10 +2,11 @@
 
 module TF2LineParser
   class Player
-    attr_accessor :name, :steam_id, :team
+    attr_accessor :name, :uid, :steam_id, :team
 
-    def initialize(name, steam_id, team)
+    def initialize(name, uid, steam_id, team)
       @name = name
+      @uid = uid
       @steam_id = steam_id
       @team = team
     end

data/lib/tf2_line_parser/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module TF2LineParser
-  VERSION = '0.2.3'
+  VERSION = '0.3.0'
 end

data/spec/lib/tf2_line_parser/parser_spec.rb

@@ -34,42 +34,47 @@ module TF2LineParser
       it 'recognizes damage' do
         line = log_lines[1001]
         player_name = 'Epsilon numlocked'
+        player_uid = '4'
         player_steam_id = 'STEAM_0:1:16347045'
         player_team = 'Red'
         value = '69'
         weapon = nil
-        expect(Events::Damage).to receive(:new).with(anything, player_name, player_steam_id, player_team, nil, nil,
-                                                     nil, value, weapon)
+        expect(Events::Damage).to receive(:new).with(anything, player_name, player_uid, player_steam_id, player_team, nil, nil,
+                                                     nil, nil, value, weapon)
         parse(line)
       end
 
       it 'recognizes new steam id log lines with detailed damage' do
         line = new_log_lines[0]
         player_name = 'iM yUKi intel @i52'
+        player_uid = '6'
         player_steam_id = '[U:1:3825470]'
         player_team = 'Blue'
-        target_team = 'Red'
         target_name = 'mix^ enigma @ i52'
+        target_uid = '8'
         target_steam_id = '[U:1:33652944]'
+        target_team = 'Red'
         value = '78'
         weapon = 'tf_projectile_rocket'
-        expect(Events::Damage).to receive(:new).with(anything, player_name, player_steam_id, player_team, target_name,
-                                                     target_steam_id, target_team, value, weapon)
+        expect(Events::Damage).to receive(:new).with(anything, player_name, player_uid, player_steam_id, player_team, target_name,
+                                                     target_uid, target_steam_id, target_team, value, weapon)
         parse(line)
       end
 
       it 'recognizes detailed damage' do
         line = detailed_log_lines[61]
         player_name = 'LittleLies'
+        player_uid = '16'
         player_steam_id = 'STEAM_0:0:55031498'
         player_team = 'Blue'
         target_name = 'Aquila'
+        target_uid = '15'
         target_steam_id = 'STEAM_0:0:43087158'
         target_team = 'Red'
         value = '102'
         weapon = 'tf_projectile_pipe'
-        expect(Events::Damage).to receive(:new).with(anything, player_name, player_steam_id, player_team, target_name,
-                                                     target_steam_id, target_team, value, weapon)
+        expect(Events::Damage).to receive(:new).with(anything, player_name, player_uid, player_steam_id, player_team, target_name,
+                                                     target_uid, target_steam_id, target_team, value, weapon)
         parse(line)
       end
 
@@ -77,31 +82,33 @@ module TF2LineParser
         line = airshot_log_lines[0]
         weapon = 'tf_projectile_rocket'
         airshot = '1'
-        expect(Events::Airshot).to receive(:new).with(anything, anything, anything, anything, anything, anything,
-                                                      anything, anything, weapon, airshot)
+        expect(Events::Airshot).to receive(:new).with(anything, anything, anything, anything, anything, anything, anything,
+                                                      anything, anything, anything, weapon, airshot)
         parse(line).inspect
       end
 
       it 'recognizes sniper headshot damage' do
         line = detailed_log_lines[3645]
         weapon = 'sniperrifle'
-        expect(Events::HeadshotDamage).to receive(:new).with(anything, anything, anything, anything, anything,
-                                                             anything, anything, anything, weapon)
+        expect(Events::HeadshotDamage).to receive(:new).with(anything, anything, anything, anything, anything, anything,
+                                                             anything, anything, anything, anything, weapon)
         parse(line).inspect
       end
 
       it 'ignores realdamage' do
         line = detailed_log_lines[65]
         player_name = 'LittleLies'
+        player_uid = '16'
         player_steam_id = 'STEAM_0:0:55031498'
         player_team = 'Blue'
         target_name = 'Aquila'
+        target_uid = '15'
         target_steam_id = 'STEAM_0:0:43087158'
         target_team = 'Red'
         value = '98'
         weapon = 'tf_projectile_pipe'
-        expect(Events::Damage).to receive(:new).with(anything, player_name, player_steam_id, player_team, target_name,
-                                                     target_steam_id, target_team, value, weapon)
+        expect(Events::Damage).to receive(:new).with(anything, player_name, player_uid, player_steam_id, player_team, target_name,
+                                                     target_uid, target_steam_id, target_team, value, weapon)
         parse(line)
       end
 
@@ -143,29 +150,33 @@ module TF2LineParser
       it 'recognizes a heal' do
         line = log_lines[1433]
         player_name = 'Epsilon KnOxXx'
+        player_uid = '5'
         player_steam_id = 'STEAM_0:1:12124893'
         player_team = 'Red'
         target_name = 'Epsilon numlocked'
+        target_uid = '4'
         target_steam_id = 'STEAM_0:1:16347045'
         target_team = 'Red'
         value = '1'
-        expect(Events::Heal).to receive(:new).with(anything, player_name, player_steam_id, player_team, target_name,
-                                                   target_steam_id, target_team, value)
+        expect(Events::Heal).to receive(:new).with(anything, player_name, player_uid, player_steam_id, player_team, target_name,
+                                                   target_uid, target_steam_id, target_team, value)
         parse(line)
       end
 
       it 'recognizes a kill' do
         line = log_lines[1761]
         player_name = 'Epsilon basH.'
+        player_uid = '7'
         player_steam_id = 'STEAM_0:1:15829615'
         player_team = 'Red'
         target_name = 'broder jukebox'
+        target_uid = '11'
         target_steam_id = 'STEAM_0:1:13978585'
         target_team = 'Blue'
         weapon = 'pistol_scout'
         customkill = nil
-        expect(Events::Kill).to receive(:new).with(anything, player_name, player_steam_id, player_team, target_name,
-                                                   target_steam_id, target_team, weapon, customkill)
+        expect(Events::Kill).to receive(:new).with(anything, player_name, player_uid, player_steam_id, player_team, target_name,
+                                                   target_uid, target_steam_id, target_team, weapon, customkill)
         parse(line)
       end
 
@@ -173,73 +184,81 @@ module TF2LineParser
         line = log_lines[1951]
         weapon = 'sniperrifle'
         customkill = 'headshot'
-        expect(Events::Kill).to receive(:new).with(anything, anything, anything, anything, anything, anything,
-                                                   anything, weapon, customkill)
+        expect(Events::Kill).to receive(:new).with(anything, anything, anything, anything, anything, anything, anything,
+                                                   anything, anything, weapon, customkill)
         parse(line)
       end
 
       it 'recognizes an assist' do
         line = log_lines[1451]
         player_name = 'broder jukebox'
+        player_uid = '11'
         player_steam_id = 'STEAM_0:1:13978585'
         player_team = 'Blue'
         target_name = 'Epsilon Mitsy'
+        target_uid = '12'
         target_steam_id = 'STEAM_0:0:16858056'
         target_team = 'Red'
-        expect(Events::Assist).to receive(:new).with(anything, player_name, player_steam_id, player_team, target_name,
-                                                     target_steam_id, target_team)
+        expect(Events::Assist).to receive(:new).with(anything, player_name, player_uid, player_steam_id, player_team, target_name,
+                                                     target_uid, target_steam_id, target_team)
         parse(line)
       end
 
       it 'recognizes connect' do
         line = log_lines[9]
         name = 'Epsilon numlocked'
+        uid = '4'
         steam_id = 'STEAM_0:1:16347045'
         team = ''
         message = '0.0.0.0:27005'
-        expect(Events::Connect).to receive(:new).with(anything, name, steam_id, team, message)
+        expect(Events::Connect).to receive(:new).with(anything, name, uid, steam_id, team, message)
         parse(line)
       end
 
       it 'recognizes disconnect' do
         line = log_lines[4542]
         name = 'cc//TviQ'
+        uid = '8'
         steam_id = 'STEAM_0:0:8520477'
         team = 'Blue'
         message = 'Disconnect by user.'
-        expect(Events::Disconnect).to receive(:new).with(anything, name, steam_id, team, message)
+        expect(Events::Disconnect).to receive(:new).with(anything, name, uid, steam_id, team, message)
         parse(line)
       end
 
       it 'recognizes chat' do
         line = log_lines[89]
         name = 'Epsilon KnOxXx'
+        uid = '5'
         steam_id = 'STEAM_0:1:12124893'
         team = 'Red'
         message = "it's right for the ping"
-        expect(Events::Say).to receive(:new).with(anything, name, steam_id, team, message)
+        expect(Events::Say).to receive(:new).with(anything, name, uid, steam_id, team, message)
         parse(line)
       end
 
       it 'recognizes team chat' do
         line = log_lines[303]
         name = 'broder mirelin'
+        uid = '16'
         steam_id = 'STEAM_0:1:18504112'
         team = 'Blue'
         message = '>>> USING UBER <<<[info] '
-        expect(Events::TeamSay).to receive(:new).with(anything, name, steam_id, team, message)
+        expect(Events::TeamSay).to receive(:new).with(anything, name, uid, steam_id, team, message)
         parse(line)
       end
 
       it 'recognizes dominations' do
         line = log_lines[1948]
         name = 'Epsilon basH.'
+        uid = '7'
         steam_id = 'STEAM_0:1:15829615'
         team = 'Red'
         target_name = 'broder jukebox'
+        target_uid = '11'
         target_steam_id = 'STEAM_0:1:13978585'
         target_team = 'Blue'
-        expect(Events::Domination).to receive(:new).with(anything, name, steam_id, team, target_name, target_steam_id,
+        expect(Events::Domination).to receive(:new).with(anything, name, uid, steam_id, team, target_name, target_uid, target_steam_id,
                                                          target_team)
         parse(line)
       end
@@ -247,12 +266,14 @@ module TF2LineParser
       it 'recognizes revenges' do
         line = log_lines[2354]
         name = 'broder jukebox'
+        uid = '11'
         steam_id = 'STEAM_0:1:13978585'
         team = 'Blue'
         target_name = 'Epsilon basH.'
+        target_uid = '7'
         target_steam_id = 'STEAM_0:1:15829615'
         target_team = 'Red'
-        expect(Events::Revenge).to receive(:new).with(anything, name, steam_id, team, target_name, target_steam_id,
+        expect(Events::Revenge).to receive(:new).with(anything, name, uid, steam_id, team, target_name, target_uid, target_steam_id,
                                                       target_team)
         parse(line)
       end
@@ -276,10 +297,11 @@ module TF2LineParser
       it 'recognizes item pickup' do
         line = log_lines[51]
         name = 'Epsilon Mike'
+        uid = '6'
         steam_id = 'STEAM_0:1:1895232'
         team = 'Blue'
         item = 'medkit_medium'
-        expect(Events::PickupItem).to receive(:new).with(anything, name, steam_id, team, item)
+        expect(Events::PickupItem).to receive(:new).with(anything, name, uid, steam_id, team, item)
         parse(line)
       end
 
@@ -292,54 +314,59 @@ module TF2LineParser
       it 'recognizes ubercharges' do
         line = log_lines[1416]
         name = 'broder mirelin'
+        uid = '17'
         steam_id = 'STEAM_0:1:18504112'
         team = 'Blue'
-        expect(Events::ChargeDeployed).to receive(:new).with(anything, name, steam_id, team)
+        expect(Events::ChargeDeployed).to receive(:new).with(anything, name, uid, steam_id, team)
         parse(line)
 
         line = detailed_log_lines[782]
         name = 'flo ❤'
+        uid = '24'
         steam_id = 'STEAM_0:1:53945481'
         team = 'Blue'
-        expect(Events::ChargeDeployed).to receive(:new).with(anything, name, steam_id, team)
+        expect(Events::ChargeDeployed).to receive(:new).with(anything, name, uid, steam_id, team)
         parse(line)
       end
 
       it 'recognizes medic deaths' do
         line = log_lines[1700]
         medic_name = 'broder mirelin'
+        medic_uid = '17'
         medic_steam_id = 'STEAM_0:1:18504112'
         medic_team = 'Blue'
         killer_name = 'Epsilon numlocked'
+        killer_uid = '4'
         killer_steam_id = 'STEAM_0:1:16347045'
         killer_team = 'Red'
         healing = '1975'
-        expect(Events::MedicDeath).to receive(:new).with(anything, killer_name, killer_steam_id, killer_team,
-                                                         medic_name, medic_steam_id, medic_team, healing, '0')
+        expect(Events::MedicDeath).to receive(:new).with(anything, killer_name, killer_uid, killer_steam_id, killer_team,
+                                                         medic_name, medic_uid, medic_steam_id, medic_team, healing, '0')
         parse(line)
       end
 
       it 'recognizes medic uberdrops' do
         uberdrop = 'L 10/04/2012 - 21:43:06: "TLR Traxantic<28><STEAM_0:1:1328042><Red>" triggered "medic_death" against "cc//Admirable<3><STEAM_0:0:154182><Blue>" (healing "6478") (ubercharge "1")'
-        expect(Events::MedicDeath).to receive(:new).with(anything, anything, anything, anything, anything, anything,
-                                                         anything, anything, '1')
+        expect(Events::MedicDeath).to receive(:new).with(anything, anything, anything, anything, anything, anything, anything,
+                                                         anything, anything, anything, '1')
         parse(uberdrop)
       end
 
       it 'recognizes medic healing on death' do
         line = 'L 10/04/2012 - 21:43:06: "TLR Traxantic<28><STEAM_0:1:1328042><Red>" triggered "medic_death" against "cc//Admirable<3><STEAM_0:0:154182><Blue>" (healing "6478") (ubercharge "1")'
-        expect(Events::MedicDeath).to receive(:new).with(anything, anything, anything, anything, anything, anything,
-                                                         anything, '6478', anything)
+        expect(Events::MedicDeath).to receive(:new).with(anything, anything, anything, anything, anything, anything, anything,
+                                                         anything, anything, '6478', anything)
         parse(line)
       end
 
       it 'recognizes role changes' do
         line = log_lines[1712]
         player_name = 'broder bybben'
+        player_uid = '10'
         player_steam_id = 'STEAM_0:1:159631'
         player_team = 'Blue'
         role = 'scout'
-        expect(Events::RoleChange).to receive(:new).with(anything, player_name, player_steam_id, player_team, role)
+        expect(Events::RoleChange).to receive(:new).with(anything, player_name, player_uid, player_steam_id, player_team, role)
         parse(line)
       end
 
@@ -353,31 +380,34 @@ module TF2LineParser
       it 'recognizes capture block' do
         line = log_lines[3070]
         name = 'Epsilon basH.'
+        uid = '7'
         steam_id = 'STEAM_0:1:15829615'
         team = 'Red'
         cap_number = '2'
         cap_name = '#Badlands_cap_cp3'
-        expect(Events::CaptureBlock).to receive(:new).with(anything, name, steam_id, team, cap_number, cap_name)
+        expect(Events::CaptureBlock).to receive(:new).with(anything, name, uid, steam_id, team, cap_number, cap_name)
         parse(line)
       end
 
       it 'recognizes suicides' do
         line = log_lines[76]
         name = '.schocky'
+        uid = '15'
         steam_id = 'STEAM_0:0:2829363'
         team = 'Red'
         suicide_method = 'world'
-        expect(Events::Suicide).to receive(:new).with(anything, name, steam_id, team, suicide_method)
+        expect(Events::Suicide).to receive(:new).with(anything, name, uid, steam_id, team, suicide_method)
         parse(line)
       end
 
       it 'recognizes spawns' do
         line = log_lines[4541]
         name = 'candyyou # Infinity Gaming'
+        uid = '124'
         steam_id = 'STEAM_0:0:50979748'
         team = 'Red'
         klass = 'Soldier'
-        expect(Events::Spawn).to receive(:new).with(anything, name, steam_id, team, klass)
+        expect(Events::Spawn).to receive(:new).with(anything, name, uid, steam_id, team, klass)
         parse(line)
       end
 
@@ -417,25 +447,43 @@ module TF2LineParser
       it 'recognizes cs:go chat' do
         line = csgo_log_lines[299]
         name = '• Ben •'
+        uid = '3'
         steam_id = 'STEAM_1:0:160621749'
         team = 'TERRORIST'
         message = '!rcon changelevel de_dust2'
-        expect(Events::Say).to receive(:new).with(anything, name, steam_id, team, message)
+        expect(Events::Say).to receive(:new).with(anything, name, uid, steam_id, team, message)
         parse(line)
       end
 
       it "doesn't fall for twiikuu's cheeky name" do
-        player_name = 't<1><[U:1:123456]><Red>" say "'
-        line = %(L 02/07/2013 - 21:22:08: "#{player_name}<5><[U:1:1337]><Red>" say "!who")
+        line = 'L 02/07/2013 - 21:22:08: "t<1><[U:1:123456]><Red>" say "!who"<5><[U:1:1337]><Red>" say "hello world"'
 
-        name = 't<1><[U:1:123456]><Red>" say "'
-        steam_id = '[U:1:1337]'
+        name = 't'
+        uid = '1'
+        steam_id = '[U:1:123456]'
         team = 'Red'
-        message = '!who'
-        expect(Events::Say).to receive(:new).with(anything, name, steam_id, team, message)
+        message = '!who"<5><[U:1:1337]><Red>" say "hello world'
+        expect(Events::Say).to receive(:new).with(anything, name, uid, steam_id, team, message)
 
         parse(line)
       end
+
+      it 'matches damage lines with trailing newline using \A and \z' do
+        line = "L 02/15/2013 - 00:21:47: \"Aka Game<4><STEAM_0:0:5253998><Red>\" triggered \"damage\" (damage \"28\")\n"
+        expect(Events::Damage.regex.match(line)).not_to be_nil
+      end
+
+      it 'parses a log line with a cheeky player name containing <uid><steamid><team> and log syntax' do
+        line = 'L 02/15/2013 - 00:21:47: "t<1><[U:1:123456]><Red>\" say \"!who\"<5><[U:1:1337]><Red>" say "hello world"'
+        parser = TF2LineParser::Parser.new(line)
+        event = parser.parse
+        expect(event).to be_a(TF2LineParser::Events::Say)
+        expect(event.player.name).to eq('t<1><[U:1:123456]><Red>\\" say \\"!who\\"')
+        expect(event.player.uid).to eq('5')
+        expect(event.player.steam_id).to eq('[U:1:1337]')
+        expect(event.player.team).to eq('Red')
+        expect(event.message).to eq('hello world')
+      end
     end
   end
 end

data/spec/lib/tf2_line_parser/player_spec.rb

@@ -5,8 +5,8 @@ require 'spec_helper'
 module TF2LineParser
   describe Player do
     it 'compares based on steam_id' do
-      p1 = Player.new('Arie', '12345', 'Red')
-      p2 = Player.new('Arie fakenicking', '12345', 'Red')
+      p1 = Player.new('Arie', '5', '12345', 'Red')
+      p2 = Player.new('Arie fakenicking', '6', '12345', 'Red')
       expect(p1).to eq p2
     end
   end

data/spec/spec_helper.rb

@@ -3,11 +3,10 @@
 require 'simplecov'
 require 'coveralls'
 
-SimpleCov.formatters = SimpleCov::Formatter::MultiFormatter[
+SimpleCov.formatters = SimpleCov::Formatter::MultiFormatter.new([
   SimpleCov::Formatter::HTMLFormatter,
   Coveralls::SimpleCov::Formatter
-]
+])
 SimpleCov.start
 
-require 'pry-nav'
 require 'tf2_line_parser'

data/tf2_line_parser.gemspec

@@ -16,7 +16,8 @@ Gem::Specification.new do |gem|
   gem.homepage      = 'http://github.com/Arie/tf2_line_parser'
 
   gem.add_dependency 'activesupport'
-  gem.add_development_dependency 'coveralls'
-  gem.add_development_dependency 'pry-nav'
-  gem.add_development_dependency 'rspec', '~> 3.5.0'
+  gem.add_development_dependency 'coveralls_reborn'
+  gem.add_development_dependency 'rspec'
+  gem.add_development_dependency 'simplecov'
+  gem.add_development_dependency 'json'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tf2_line_parser
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.3.0
 platform: ruby
 authors:
 - Arie
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-12-16 00:00:00.000000000 Z
+date: 2025-07-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -25,7 +25,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: coveralls
+  name: coveralls_reborn
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -39,7 +39,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: pry-nav
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -53,19 +53,33 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: simplecov
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 3.5.0
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 3.5.0
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: A gem to parse log lines from TF2 servers
 email: rubygems@ariekanarie.nl
 executables: []
@@ -136,7 +150,7 @@ files:
 homepage: http://github.com/Arie/tf2_line_parser
 licenses: []
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -151,8 +165,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
-signing_key: 
+rubygems_version: 3.5.11
+signing_key:
 specification_version: 4
 summary: TF2 log line parser
 test_files: