australium 1.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6fd3f83b9c9d4e08cb36d103b67037fd12f8d8c3
+  data.tar.gz: 8f942fa3c40bc628ef4582d2ec04a9c64ee148db
+SHA512:
+  metadata.gz: 25969f141083f537faba752bf9916596bce276c87d99557012bf0de6ba91561ac809de48760bc9316158175d2094e805c6877d2a095b3a279cfe11c56a11081e
+  data.tar.gz: ab1a4982f7a2722feea7ab262b466130f1556cb663c8883295ce32df9522bb20547c90bcc8be9b08a26a747d535d71f2f60cabfe2193da8c8fa12227a17ac58b

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+.idea
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+data/

data/.yardopts

@@ -0,0 +1,2 @@
+--title "Australium"
+--exclude data --exclude test --exclude tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in australium.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 awkisopen
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,52 @@
+[![Code Climate](https://codeclimate.com/github/awkisopen/australium.png)](https://codeclimate.com/github/awkisopen/australium)
+# Australium
+
+<img src="http://i.imgur.com/IpOgnjO.png" align="right" />
+Australium is a powerful TF2 game log parser. It allows access to all game events and player data in a hierarchical,
+rubyified manner. The timestamp and state of the game are stored within every event for easy access.
+
+<br clear="all" />
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'australium'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install australium
+
+## Example Usage
+
+```ruby
+require 'australium'
+
+# Load game data from logfile
+games = Australium::parse_file('/tmp/tf2game.log')
+
+# Logfiles may contain multiple games, but chances are good your logfile will only have one.
+game = games.first
+
+# Print the name of each player and the team they were on.
+game.players.each do |player|
+  puts "#{p.nick} - #{p.team.empty? ? 'None' : p.team}"
+end
+
+# Count the number of backstabs that took place during the game.
+puts 'Backstabs: ' + game.kills.select { |e| e.customkill == 'backstab' }.count.to_s
+```
+
+Check [the documentation](http://rubydoc.info/github/awkisopen/australium/master/frames) for more information on how to access game events.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/australium.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'australium/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "australium"
+  spec.version       = Australium::VERSION
+  spec.authors       = %w[awk]
+  spec.email         = %w[awkisopen@shutupandwrite.net]
+  spec.description   = %q[TF2 log parser]
+  spec.summary       = %q[TF2 log parser]
+  spec.homepage      = "http://training.tf"
+  spec.license       = "MIT"
+
+  spec.files                 = `git ls-files -z`.split("\x0")
+  spec.executables           = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files            = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths         = ["lib"]
+  spec.required_ruby_version = "~> 2.1"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+end

data/lib/australium.rb

@@ -0,0 +1,29 @@
+path = File.dirname(__FILE__)
+
+require 'ostruct'
+require 'date'
+
+Dir["#{path}/australium/ref/*.rb"].each { |f| require f }
+
+require "#{path}/australium/event.rb"
+Dir["#{path}/australium/events/*.rb"].each { |f| require f }
+
+Dir["#{path}/australium/*.rb"].each { |f| require f }
+
+module Australium
+
+  # Parses a file located at the given path and returns an array of {Game}s.
+  # @param [String] logfile the location of the logfile.
+  # @return [Array<Game>] the parsed game data.
+  def self.parse_file(logfile)
+    log = File.read(logfile)
+    Parser::parse(log.split("\n"))
+  end
+
+  # Future expansion: #parse should be able to determine the kind of input given and parse accordingly - i.e.
+  # a past logfile vs a logfile currently being written to vs a network stream.
+  class << self
+    alias_method :parse, :parse_file
+  end
+
+end

data/lib/australium/event.rb

@@ -0,0 +1,47 @@
+module Australium
+
+  # Represents a generic Event that occurs during a Game.
+  class Event < OpenStruct
+    using MatchDataToHash
+
+    # @!attribute raw
+    #   @return [String] the raw log message.
+
+    TIMESTAMP_REGEX = %r(L [0-9]{2}/[0-9]{2}/[0-9]{4} - [0-9]{2}:[0-9]{2}:[0-9]{2})
+    PROPERTY_REGEX = /\(([^ ]+) "([^"]+)"\)/
+
+    class << self
+      attr_accessor :event_classes
+      def inherited(by)
+        @event_classes ||= []
+        @event_classes << by
+      end
+    end
+
+    def initialize(data)
+      super(data)
+
+      # Replace anything matching a Player string with a Player object.
+      self.each_pair do |key, value|
+        if value =~ Player::LOG_REGEX && key != :raw
+          player_data = Player::LOG_REGEX.match(value).to_h
+          self[key] = Player.new(player_data)
+        end
+      end
+
+      # If we're being stateful, make sure referenced Players are included in the GameState
+      unless self.state.nil?
+        self.to_h.select { |_, v| v.is_a?(Player) }.each_pair do |key, value|
+          if self.state.players.include?(value)
+            self[key] = self.state.players.find { |p| p == value }
+          else
+            self.state.players << value
+          end
+        end
+      end
+    end
+
+    def to_s ; raw end
+
+  end
+end

data/lib/australium/events/map_load.rb

@@ -0,0 +1,10 @@
+module Australium
+  class MapLoad < Event
+
+    LOG_REGEX = /Loading map "(?<map_name>.+)"/
+
+    # @!attribute map_name
+    #   @return [String] the name of the loaded map.
+
+  end
+end

data/lib/australium/events/map_start.rb

@@ -0,0 +1,13 @@
+module Australium
+  class MapStart < Event
+
+    LOG_REGEX = /Started map "(?<map_name>.+)" \(CRC "(?<crc>.+)"\)/
+
+    # @!attribute map_name
+    #   @return [String] the name of the map that was started.
+
+    # @!attribute crc
+    #   @return [String] CRC of the map.
+
+  end
+end

data/lib/australium/events/player_connect.rb

@@ -0,0 +1,17 @@
+module Australium
+  class PlayerConnect < Event
+
+    LOG_REGEX = /"(?<player>.+)" connected, address "(?<address>.+)"/
+
+    # @!attribute player
+    #   @return [Player] the {Player} who connected to the server.
+    # @!attribute address
+    #   @return [String] the IP address of the connecting player.
+
+    def initialize(data)
+      super(data)
+      player.address = address
+    end
+
+  end
+end

data/lib/australium/events/player_disconnect.rb

@@ -0,0 +1,15 @@
+module Australium
+  class PlayerDisconnect < Event
+
+    LOG_REGEX = /"(?<player>.+)" disconnected"/
+
+    # @!attribute player
+    #   @return [Player] the {Player} who disconnected from the server.
+
+    def initialize(data)
+      super(data)
+      state.players.delete(player) unless state.nil?
+    end
+
+  end
+end

data/lib/australium/events/player_enter_game.rb

@@ -0,0 +1,16 @@
+module Australium
+  class PlayerEnterGame < Event
+
+    LOG_REGEX = /"(?<player>.+)" entered the game/
+
+    # @!attribute player
+    #   @return [Player] the {Player} who entered the game. This event always takes place after a corresponding
+    #     {PlayerConnect} event.
+
+    def initialize(data)
+      super(data)
+      state.players.find { |p| p == player }[:in_game?] = true
+    end
+
+  end
+end

data/lib/australium/events/player_join_team.rb

@@ -0,0 +1,20 @@
+module Australium
+  class PlayerJoinTeam < Event
+
+    LOG_REGEX = /"(?<player>.+)" joined team "(?<team>.+)"/
+
+    # @!attribute player
+    #   @return [Player] the {Player} who joined the team.
+    # @!attribute team
+    #   @return [String] the name of the team the player joined.
+
+    def initialize(data)
+      super(data)
+      unless state.nil?
+        player = state.players.find { |p| p.nick == self.player.nick }
+        player.team = team
+      end
+    end
+
+  end
+end

data/lib/australium/events/player_kill.rb

@@ -0,0 +1,14 @@
+module Australium
+  class PlayerKill < Event
+
+    LOG_REGEX = /"(?<attacker>.+)" killed "(?<victim>.+)" with "(?<weapon>[^"]+)"/
+
+    # @!attribute attacker
+    #   @return [Player] the {player} responsible for the kill.
+    # @!attribute victim
+    #   @return [Player] the {player} who was killed.
+    # @!attribute weapon
+    #   @return [String] the name of the weapon used to kill (can be World).
+
+  end
+end

data/lib/australium/events/player_name_change.rb

@@ -0,0 +1,17 @@
+module Australium
+  class PlayerNameChange < Event
+
+    LOG_REGEX = /"(?<player>.+)" changed name to "(?<new_name>.+)"/
+
+    # @!attribute player
+    #   @return [Player] the {Player} whose name changed.
+    # @!attribute new_name
+    #   @return [String] the name the player changed to.
+
+    def initialize(data)
+      super(data)
+      player.nick = new_name
+    end
+
+  end
+end

data/lib/australium/events/player_role_change.rb

@@ -0,0 +1,20 @@
+module Australium
+  class PlayerRoleChange < Event
+
+    LOG_REGEX = /"(?<player>.+)" changed role to "(?<role>.+)"/
+
+    # @!attribute player
+    #   @return [Player] the {Player} who changed role.
+    # @!attribute role
+    #   @return [String] the name of the role the player changed to.
+
+    def initialize(data)
+      super(data)
+      unless state.nil?
+        player = state.players.find { |p| p.nick == self.player.nick }
+        player.role = role
+      end
+    end
+
+  end
+end

data/lib/australium/events/player_say.rb

@@ -0,0 +1,21 @@
+module Australium
+  class PlayerSay < Event
+
+    LOG_REGEX = /"(?<player>.+)" say(?<team>_team)? "(?<message>.+)"/
+
+    # @!attribute player
+    #   @return [Player] the {Player} who spoke in chat.
+    # @!attribute message
+    #   @return [String] the message spoken.
+
+    def initialize(data)
+      super(data)
+      self[:team] = team.eql?('_team')
+    end
+
+    # Checks if the message was a team-only message.
+    # @return [Boolean] true if the message was a team message.
+    def team? ; team end
+
+  end
+end

data/lib/australium/events/player_suicide.rb

@@ -0,0 +1,12 @@
+module Australium
+  class PlayerSuicide < Event
+
+    LOG_REGEX = /"(?<player>.+)" committed suicide with "(?<weapon>[^"]+)"/
+
+    # @!attribute player
+    #   @return [Player] the {Player} who committed suicide.
+    # @!attribute weapon
+    #   @return [String] the name of the weapon the player committed suicide with (can be World).
+
+  end
+end

data/lib/australium/events/trigger.rb

@@ -0,0 +1,17 @@
+module Australium
+  # A Trigger Event is a very general Event. Triggers occur on point capture, round end, even damage and healing
+  # with plugins installed. Depending on the kind of trigger, it could involve one player, two players, or no
+  # players at all (in the case of 'World' triggering an event, such as a round end).
+  class Trigger < Event
+
+    LOG_REGEX = /: "?(?<initiator>.*(World|>))"? triggered "(?<action>[^"]+)"(?: against "(?<target>.+>)")?/
+
+    # @!attribute initiator
+    #   @return [Player, String] the {Player} who triggered the event, or the string 'World'
+    # @!attribute action
+    #   @return [String] the name of the triggered action.
+    # @!attribute target
+    #   @return [Player, NilClass] the {Player} who received the action, or nil if no {Player} received the action.
+
+  end
+end

data/lib/australium/game.rb

@@ -0,0 +1,61 @@
+module Australium
+
+  # Represents a full game of TF2, comprised of individual {Event}s.
+  class Game
+
+    class << self
+      private
+      # Creates shortcuts for returning events of a certain type.
+      # @param [Symbol] event_name the friendly name of the event category
+      # @param [Class] event_class the class name corresponding to the event
+      # @!macro [attach] event_selector
+      #   @!method $1
+      #   @return [Array<$2>] Returns all {$2 $2} events.
+      def event_selector(event_name, event_class)
+        define_method(event_name) { @events.select { |e| e.is_a?(event_class) } }
+      end
+    end
+
+    # @!attribute [r] events
+    #   @return [Array<Events>] events that took place during the game, in chronological order
+    attr_reader :events
+
+    # @param events [Array<Events>] events that took place during the game
+    def initialize(events)
+      @events = events
+    end
+
+    # Returns an array of all {Player Players} who connected to the server during this game.
+    # Caches the return value after the first call.
+    # @return [Array<Player>] players who participated in the game
+    def players
+      @players ||= @events.reverse.each_with_object([]) do |event, all_players|
+        break all_players if event.state.nil? || event.state.players.nil?
+        all_players.concat event.state.players.reject { |p| all_players.include?(p) }
+      end
+    end
+
+    # Returns the name of the map that was played.
+    # @return [String] map name
+    def map_name
+      @events.select { |e| e.is_a?(MapStart) }.last.map_name
+    end
+
+    # @!group Event filters
+    event_selector :connects,      PlayerConnect
+    event_selector :disconnects,   PlayerDisconnect
+    event_selector :role_changes,  PlayerRoleChange
+    event_selector :team_joins,    PlayerJoinTeam
+    event_selector :kills,         PlayerKill
+    event_selector :name_changes,  PlayerNameChange
+    event_selector :chat_messages, PlayerSay
+    event_selector :suicides,      PlayerSuicide
+    event_selector :triggers,      Trigger
+    # @!endgroup
+
+    # Hide instance variables from #inspect to prevent clutter on interactive terminals.
+    # @return [String]
+    def inspect ; self.to_s end
+
+  end
+end

data/lib/australium/game_state.rb

@@ -0,0 +1,20 @@
+module Australium
+
+  # Represents the state of the game at a particular time.
+  class GameState < OpenStruct
+
+    def initialize(*args)
+      super(*args)
+
+      # @!attribute players
+      #   @return [Array<Player>] player data at this state
+      self.players ||= []
+
+      # @!attribute timestamp
+      #   @return [DateTime]
+    end
+
+    def inspect; "<GameState:#{timestamp}>" end
+
+  end
+end

data/lib/australium/parser.rb

@@ -0,0 +1,63 @@
+module Australium
+
+  class Parser
+    using MatchDataToHash
+    using OpenStructDeepClone
+
+    # Parses a full TF2 log.
+    # @param [Array<String>] lines the lines to parse
+    # @return [Array<Game>] the game(s) data
+    def self.parse(lines)
+      games = [] ; state = GameState.new ; events = []
+
+      lines.each_with_index do |line, index|
+        event = parse_line(line, state)
+
+        if event.is_a?(MapLoad) || index == lines.count - 1
+          games << Game.new(events) unless events.empty?
+          events = []
+          event = parse_line(line, GameState.new) # Parse a second time with the correct GameState
+        end
+
+        unless event.nil?
+          events << event
+          state = event.state.deep_clone
+        end
+      end
+
+      games
+    end
+
+    # Parses a single line of TF2 log in the context of a game (if a {GameState} is passed).
+    # @param [String] line the line to be parsed
+    # @param [GameState] the {GameState} containing the game context.
+    # @return [Event, NilClass] event if an event has been recognized; nil otherwise.
+    def self.parse_line(line, state = nil)
+      Event::event_classes.each do |event_class|
+        if event_class::LOG_REGEX =~ line
+          # Get timestamp data & timestamp GameState if we are being stateful
+          timestamp = DateTime.strptime(Event::TIMESTAMP_REGEX.match(line)[0], 'L %m/%d/%Y - %H:%M:%S')
+          state.timestamp = timestamp unless state.nil?
+
+          # Get the meat of the event data
+          data = event_class::LOG_REGEX.match(line).to_h
+
+          # Get supplemental property data, if any exists
+          property_data = line.scan(Event::PROPERTY_REGEX).map { |x| [x.first.to_sym, x.last] }.to_h
+          data.merge!(property_data)
+
+          # Add other useful data
+          data[:state] = state
+          data[:raw] = line
+          data[:timestamp] = timestamp
+
+          # Construct and return the new Event
+          return event_class.new(data)
+        end
+      end
+      nil
+    end
+
+  end
+
+end

data/lib/australium/player.rb

@@ -0,0 +1,79 @@
+module Australium
+
+  # Represents a Player playing a Game.
+  class Player < OpenStruct
+
+    LOG_REGEX = /(?<nick>.*)<(?<won_id>.*)><(?<steam_id>.*)><(?<team>.*)>/
+
+    # @!attribute nick
+    #   @return [String] the player's in-game nickname.
+    # @!attribute won_id
+    #   @return [String] the player's {http://wiki.hlsw.net/index.php/WONID WONID}.
+    # @!attribute steam_id
+    #   @return [String] the player's unique Steam ID, or 'BOT' if this player is a bot.
+    # @!attribute team
+    #   @return [String] the name of the team the player is on (can be an empty string).
+
+    def initialize(*args)
+      super(*args)
+
+      # @!attribute address
+      #   @return [String, NilClass] the player's IP address, or nil if not known
+      self[:address] = nil
+
+      # @!attribute in_game?
+      #   @return [Boolean] true if the player is in the game (as determined by a triggered {PlayerEnterGame} event).
+      self[:in_game?] = false
+
+      # @!attribute role
+      #   @return [String, NilClass] the name of the role the player is playing, or nil if none yet
+      self[:role] = nil
+
+    end
+
+    # Compares players by steam IDs and bots by nicks.
+    # @param player [Player] the player to compare against
+    # @return [Boolean]
+    def ==(player)
+      if [self, player].all?(&:bot?)
+        self.nick == player.nick
+      else
+        self.steam_id == player.steam_id
+      end
+    end
+
+    # (see #==)
+    def eql?(player)
+      if [self, player].all?(&:bot?)
+        self.nick.eql?(player.nick)
+      else
+        self.steam_id.eql?(player.steam_id)
+      end
+    end
+
+    # Checks if the player is a bot.
+    # @return [Boolean] true if the player is a bot
+    def bot? ; self.steam_id == 'BOT' end
+
+    # Checks if the player is on the BLU team.
+    # @return [Boolean] true if the player is on the BLU team
+    def blu? ; self.team == 'Blue' end
+
+    # Checks if the player is on the RED team.
+    # @return [Boolean] true if the player is on the RED team
+    def red? ; self.team == 'Red' end
+
+    # Checks if the player is a spectator.
+    # @return [Boolean] true if the player is a spectator
+    def spectator? ; self.team == 'Spectator' end
+
+    # Checks if the player is not assigned to any team. (This can be considered a fourth team in some contexts.)
+    # @return [Boolean] true if the player is unassigned
+    def unassigned? ; self.team == 'Unassigned' end
+
+    # Checks if the player is in the game as either a RED or BLU player.
+    # @return [Boolean] true if the player is either on RED or BLU
+    def has_team? ; blu? || red? end
+
+  end
+end

data/lib/australium/ref/match_data_to_hash.rb

@@ -0,0 +1,11 @@
+module Australium
+  module MatchDataToHash
+
+    refine MatchData do
+      def to_h
+        Hash[(self.names.empty? ? 1..self.captures.count : self.names.map { |x| x.to_sym }).zip(self.captures)]
+      end
+    end
+
+  end
+end

data/lib/australium/ref/open_struct_deep_clone.rb

@@ -0,0 +1,15 @@
+module Australium
+  module OpenStructDeepClone
+
+    refine OpenStruct do
+      def deep_clone
+        dup = self.dup
+        dup.each_pair do |key, value|
+          dup[key] = value.deep_clone if value.is_a?(OpenStruct)
+        end
+        dup
+      end
+    end
+
+  end
+end

data/lib/australium/version.rb

@@ -0,0 +1,3 @@
+module Australium
+  VERSION = "1.0.1"
+end

metadata

@@ -0,0 +1,101 @@
+--- !ruby/object:Gem::Specification
+name: australium
+version: !ruby/object:Gem::Version
+  version: 1.0.1
+platform: ruby
+authors:
+- awk
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-06-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  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: TF2 log parser
+email:
+- awkisopen@shutupandwrite.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".yardopts"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- australium.gemspec
+- lib/australium.rb
+- lib/australium/event.rb
+- lib/australium/events/map_load.rb
+- lib/australium/events/map_start.rb
+- lib/australium/events/player_connect.rb
+- lib/australium/events/player_disconnect.rb
+- lib/australium/events/player_enter_game.rb
+- lib/australium/events/player_join_team.rb
+- lib/australium/events/player_kill.rb
+- lib/australium/events/player_name_change.rb
+- lib/australium/events/player_role_change.rb
+- lib/australium/events/player_say.rb
+- lib/australium/events/player_suicide.rb
+- lib/australium/events/trigger.rb
+- lib/australium/game.rb
+- lib/australium/game_state.rb
+- lib/australium/parser.rb
+- lib/australium/player.rb
+- lib/australium/ref/match_data_to_hash.rb
+- lib/australium/ref/open_struct_deep_clone.rb
+- lib/australium/version.rb
+homepage: http://training.tf
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - "~>"
+    - !ruby/object:Gem::Version
+      version: '2.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: TF2 log parser
+test_files: []
+has_rdoc: