antw-dyno 0.1.2

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2008 Anthony Williams
+
+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.markdown

@@ -0,0 +1,68 @@
+dyno
+====
+
+> _A dynamometer or "dyno" for short, is a machine used to measure torque and
+> rotational speed (rpm) from which power produced by an engine, motor or
+> other rotating prime mover can be calculated. ([Wikipedia][dyno-wp])_
+
+In this context, however, Dyno is a pure Ruby library for parsing sim-racing
+result files, soon to be used on the upcoming Torque sim-racing app.
+
+Dyno presently supports files spat out by a number of games:
+
+* **Race07Parser** parses results from RACE 07, GTR: Evolution, and
+  STCC: The Game
+* **GTR2Parser** parses results from GTR2.
+* **RFactorParser** parses results from rFactor (and mods), and ARCA.
+
+Dyno requires the iniparse gem (available via `gem install iniparse` or on
+[GitHub][iniparse]) for the Race 07 and GTR2 parsers, and libxml-ruby for
+the rFactor parser.
+
+Usage
+-----
+
+    Dyno::Parsers::Race07Parser.parse_file( '/path/to/result/file' )
+    # => Dyno::Event
+
+    Dyno::Parsers::GTR2Parser.parse_file( '/path/to/result/file' )
+    # => Dyno::Event
+
+    Dyno::Parsers::RFactorParser.parse_file( '/path/to/result/file' )
+    # => Dyno::Event
+
+Each of these operations will return a Dyno::Event instance. Dyno::Event
+defines `#competitors` containing a collection of all of those who took part
+in the event. See the API docs for Dyno::Event and Dyno::Competitor for more
+details.
+
+If your results file couldn't be parsed, a Dyno::MalformedInputError exception
+will be raised.
+
+License
+-------
+
+Dyno is distributed under the MIT/X11 License.
+
+> Copyright (c) 2008-2009 Anthony Williams
+>
+> 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.
+
+[dyno-wp]:  http://en.wikipedia.org/wiki/Dynamometer "Wikipedia"
+[iniparse]: http://github.com/antw/iniparse "IniParse on GitHub"

data/Rakefile

@@ -0,0 +1,45 @@
+require 'rubygems'
+require 'spec/rake/spectask'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    s.name        = 'dyno'
+    s.platform    = Gem::Platform::RUBY
+    s.has_rdoc    = true
+    s.summary     = 'A rubygem for parsing sim-racing results files.'
+    s.description = s.summary
+    s.author      = 'Anthony Williams'
+    s.email       = 'anthony@ninecraft.com'
+    s.homepage    = 'http://github.com/anthonyw/dyno'
+
+    s.extra_rdoc_files = ['README.markdown', 'LICENSE']
+
+    # Dependencies.
+    s.add_dependency "iniparse", ">= 0.2.0"
+
+    s.files = %w(LICENSE README.markdown Rakefile VERSION.yml) +
+              Dir.glob("{lib,spec}/**/*")
+  end
+rescue LoadError
+  puts 'Jeweler not available. Install it with: sudo gem install ' +
+       'technicalpickles-jeweler -s http://gems.github.com'
+end
+
+##############################################################################
+# rSpec & rcov
+##############################################################################
+
+desc "Run all examples"
+Spec::Rake::SpecTask.new('spec') do |t|
+  t.spec_files = FileList['spec/**/*.rb']
+  t.spec_opts = ['-c -f s']
+end
+
+desc "Run all examples with RCov"
+Spec::Rake::SpecTask.new('spec:rcov') do |t|
+  t.spec_files = FileList['spec/**/*.rb']
+  t.spec_opts = ['-c -f s']
+  t.rcov = true
+  t.rcov_opts = ['--exclude', 'spec']
+end

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:minor: 1
+:patch: 2
+:major: 0

data/lib/dyno.rb

@@ -0,0 +1,22 @@
+require 'rubygems'
+require 'time'
+require 'iniparse'
+require 'libxml'
+
+module Dyno
+  # Base exception class.
+  class DynoError < StandardError; end
+
+  # Raised if an input source couldn't be parsed, or was missing something.
+  class MalformedInputError < DynoError; end
+end
+
+dir = File.join( File.dirname(__FILE__), "dyno" )
+
+require File.join( dir, "competitor" )
+require File.join( dir, "event" )
+
+# Parsers
+require File.join( dir, "parsers", "race07_parser" )
+require File.join( dir, "parsers", "gtr2_parser" )
+require File.join( dir, "parsers", "rfactor_parser" )

data/lib/dyno/competitor.rb

@@ -0,0 +1,55 @@
+module Dyno
+  class Competitor
+    attr_accessor :name, :uid, :position, :vehicle, :laps, :race_time,
+      :best_lap, :lap_times
+
+    ##
+    # @param [String] name The competitor's name.
+    # @param [Hash]   properties Extra information about the competitor.
+    #
+    def initialize(name, properties = {})
+      @name = name
+      @lap_times = properties.fetch(:laps, [])
+      @dnf = false
+
+      [:uid, :position, :vehicle, :laps, :race_time, :best_lap].each do |prop|
+        instance_variable_set "@#{prop}", properties[prop]
+      end
+    end
+
+    ##
+    # Returns true fi the competitor finished the event.
+    #
+    def finished?
+      not dnf? and not dsq?
+    end
+
+    ##
+    # Flags this competitor as having not completed the event.
+    #
+    def dnf!
+      @dnf = :dnf
+    end
+
+    ##
+    # Returns true if the competitor failed to finish.
+    #
+    def dnf?
+      @dnf == :dnf
+    end
+
+    ##
+    # Flags this competitor has having been disqualified from the event.
+    #
+    def dsq!
+      @dnf = :dsq
+    end
+
+    ##
+    # Returns true if the competitor was disqualified.
+    #
+    def dsq?
+      @dnf == :dsq
+    end
+  end
+end

data/lib/dyno/event.rb

@@ -0,0 +1,16 @@
+module Dyno
+  class Event
+    attr_accessor :time, :game, :game_version, :track, :competitors
+
+    ##
+    # @param [Hash] properties Event information.
+    #
+    def initialize(properties = {})
+      @time  = properties.fetch( :time, Time.now )
+      @track = properties[:track]
+      @game  = properties[:game]
+      @game_version = properties[:game_version]
+      @competitors  = properties.fetch( :competitors, [] )
+    end
+  end
+end

data/lib/dyno/parsers/gtr2_parser.rb

@@ -0,0 +1,13 @@
+module Dyno::Parsers
+  ##
+  # Parses a Race 07 results file which are almost identical to Race 07 files.
+  #
+  class GTR2Parser < Race07Parser
+    def self.parse_file( filename )
+      # GTR2 files start with a line which isn't valid INI; remove it.
+      parse( IniParse.parse(
+        File.read( filename ).sub!(/^.*\n/, '')
+      ) )
+    end
+  end
+end

data/lib/dyno/parsers/race07_parser.rb

@@ -0,0 +1,130 @@
+module Dyno::Parsers
+  ##
+  # Parses a Race 07 results file (which appears to be some variation of the
+  # ini format).
+  #
+  class Race07Parser
+    ##
+    # Takes a file path and parses it.
+    #
+    # @param [String] filename The path to the results file.
+    #
+    def self.parse_file( filename )
+      parse( IniParse.open( filename ) )
+    end
+
+    ##
+    # Takes an IniParse::Document instance, parses the contents, and returns a
+    # Dyno::Event containing your results.
+    #
+    # @param  [IniParse::Document] results The results.
+    # @return [Dyno::Event]
+    #
+    def self.parse( results )
+      new( results ).parse
+    end
+
+    ##
+    # Returns your parsed event and competitor information.
+    #
+    def parse
+      parse_event!
+      parse_competitors!
+      @event
+    end
+
+    #######
+    private
+    #######
+
+    ##
+    # Takes an IniParse::Document instance and parses the contents.
+    #
+    # @param [IniParse::Document] results The results.
+    #
+    def initialize( results )
+      @raw = results
+    end
+
+    ##
+    # Extracts the event information from the results.
+    #
+    def parse_event!
+      raise Dyno::MalformedInputError unless @raw.has_section?('Header')
+
+      @event = Dyno::Event.new( :game => @raw['Header']['Game'] )
+      @event.time = Time.parse( @raw['Header']['TimeString'] )
+      @event.game_version = @raw['Header']['Version']
+
+      # Extract the track name from Race/Scene
+      if @raw.has_section?('Race') && @raw['Race']['Scene']
+        @event.track = @raw['Race']['Scene'].split( '\\' )[-2].gsub( /[_-]+/, ' ' )
+      end
+    end
+
+    ##
+    # Extracts information about each of the competitors.
+    #
+    def parse_competitors!
+      finished_competitors = []
+      dnf_competitors      = []
+
+      @raw.each do |section|
+        # Competitor sections are named SlotNNN.
+        next unless section.key =~ /Slot\d\d\d/
+
+        competitor = Dyno::Competitor.new(section['Driver'],
+         :vehicle  => section['Vehicle'],
+         :laps     => section['Laps'].to_i
+        )
+
+        # Some results files have a blank ID.
+        if section['SteamId'] && section['SteamId'].kind_of?(Numeric)
+          competitor.uid = section['SteamId']
+        end
+
+        # Sort out the competitors lap times.
+        competitor.best_lap = lap_time_to_float(section['BestLap'])
+
+        competitor.lap_times = section['Lap'].map do |lap|
+          lap = lap.gsub(/\((.*)\)/, '\1')
+          lap_time_to_float(lap.split(',').last.strip)
+        end
+
+        if section['RaceTime'] =~ /D(NF|S?Q)/
+          $1 == 'NF' ? competitor.dnf! : competitor.dsq!
+          competitor.race_time = 0
+          dnf_competitors << competitor
+        else
+          time = section['RaceTime'].split( /:|\./ )
+
+          competitor.race_time = time[2].to_f + ( time[1].to_i * 60 ) +
+            ( time[0].to_i * 60 * 60 ) + "0.#{time[3]}".to_f
+
+          finished_competitors << competitor
+        end
+      end
+
+      # Sort finished competitors by their race time, lowest (P1) first.
+      finished_competitors = finished_competitors.sort_by do |c|
+        [ - c.laps, c.race_time ]
+      end
+
+      # ... and DNF'ed competitors by how many laps they've done.
+      dnf_competitors = dnf_competitors.sort_by { |c| c.laps }.reverse!
+
+      # Finally let's assign their finishing positions.
+      competitors = finished_competitors + dnf_competitors
+      competitors.each_with_index { |c, i| c.position = i + 1 }
+
+      # All done!
+      @event.competitors = competitors
+    end
+
+    # Converts a lap time (in the format of M:SS:SSS) to a float.
+    def lap_time_to_float(time)
+      time = time.split( /:|\./ )
+      time[1].to_f + ( time[0].to_i * 60 ) + "0.#{time[2]}".to_f
+    end
+  end
+end

data/lib/dyno/parsers/rfactor_parser.rb

@@ -0,0 +1,138 @@
+module Dyno::Parsers
+  ##
+  # Parses a rFactor results files.
+  #
+  class RFactorParser
+    ##
+    # Takes a file path and parses it.
+    #
+    # @param [String] filename The path to the results file.
+    #
+    def self.parse_file( filename )
+      xmlparser = LibXML::XML::Parser.new
+      xmlparser.file = filename
+      parse( xmlparser.parse )
+    end
+
+    ##
+    # Takes a LibXML::XML::Document instance, parses the contents, and returns
+    # a Dyno::Event containing your results.
+    #
+    # @param  [LibXML::XML::Document] results The results.
+    # @return [Dyno::Event]
+    #
+    def self.parse( results )
+      new( results ).parse
+    end
+
+    ##
+    # Returns your parsed event and competitor information.
+    #
+    def parse
+      parse_event!
+      parse_competitors!
+      @event
+    end
+
+    #######
+    private
+    #######
+
+    ##
+    # Takes a LibXML::XML::Document instance and parses the contents.
+    #
+    # @param [LibXML::XML::Document] results The results.
+    #
+    def initialize( results )
+      @doc   = results
+      @stack = []
+    end
+
+    ##
+    # Extracts the event information from the results.
+    #
+    def parse_event!
+      unless results = @doc.find_first('//RaceResults')
+        raise Dyno::MalformedInputError, 'No //RaceResults node.'
+      end
+
+      with_node(results) do
+        @event = Dyno::Event.new(
+          :game         => clean(value('Mod').gsub(/\.rfm$/, '')),
+          :track        => clean(value('TrackCourse')),
+          :game_version => value('GameVersion')
+        )
+
+        # Sort out the event time - the rFactor results format has more than
+        # one TimeString node. The first appears to be when the server was
+        # started - we need the time of the event itself, which is held under
+        # the Race, Qualify or Warmup node.
+        if event_node = \
+              (@doc.find_first('//RaceResults/Race')    ||
+               @doc.find_first('//RaceResults/Qualify') ||
+               @doc.find_first('//RaceResults/Warmup'))
+          with_node(event_node) do
+            @event.time = Time.parse( value('TimeString') )
+          end
+        end
+      end
+    end
+
+    ##
+    # Extracts information about each of the competitors.
+    #
+    def parse_competitors!
+      @doc.find('//Driver').each do |section|
+        with_node(section) do
+          competitor = Dyno::Competitor.new(value('Name'),
+            :vehicle => clean(value('CarType')),
+            :laps    => value('Laps').to_i
+          )
+
+          competitor.position  = value('Position').to_i
+          competitor.best_lap  = lap_time_to_float( value('BestLapTime') )
+          competitor.race_time = lap_time_to_float( value('FinishTime') )
+
+          competitor.lap_times = section.find('Lap').map do |lap|
+            lap_time_to_float( lap.content )
+          end
+
+          if value('FinishStatus') =~ /D(NF|S?Q)/
+            $1 == 'NF' ? competitor.dnf! : competitor.dsq!
+          end
+
+          @event.competitors << competitor
+        end
+      end
+
+      @event.competitors = @event.competitors.sort_by { |c| c.position }
+    end
+
+    # --
+    # Utility stuff
+    # ++
+
+    def value( node ) # :nodoc:
+      if found = @stack.last.find_first( node )
+        found.content
+      else
+        nil
+      end
+    end
+
+    def clean( value ) # :nodoc:
+      value.gsub(/[-_]/, ' ').squeeze(' ') unless value.nil?
+    end
+
+    def with_node( node ) # :nodoc:
+      @stack.push( node )
+      yield
+      @stack.pop
+    end
+
+    # Converts a lap time (in the format of M:SS:SSS) to a float.
+    def lap_time_to_float(time) # :nodoc:
+      (time.nil? || time == '--.----') ? 0.0 : Float(time)
+    end
+  end
+end