icu_tournament 0.8.9

data/lib/icu_tournament/tournament_fcsv.rb

@@ -0,0 +1,310 @@
+module ICU
+  class Tournament
+    
+=begin rdoc
+
+== Foreign CSV
+
+This is a format ({specification}[http://www.icu.ie/articles/display.php?id=172]) used by the ICU[http://icu.ie]
+for players to submit their individual results in foreign tournaments for domestic rating.
+
+Suppose, for example, that the following data is the file <em>tournament.csv</em>:
+
+  Event,"Isle of Man Masters, 2007"
+  Start,2007-09-22
+  Rounds,9
+  Website,http://www.bcmchess.co.uk/monarch2007/
+
+  Player,456,Fox,Anthony
+  1,0,B,Taylor,Peter P.,2209,,ENG
+  2,=,W,Nadav,Egozi,2205,,ISR
+  3,=,B,Cafolla,Peter,2048,,IRL
+  4,1,W,Spanton,Tim R.,1982,,ENG
+  5,1,B,Grant,Alan,2223,,SCO
+  6,0,-
+  7,=,W,Walton,Alan J.,2223,,ENG
+  8,0,B,Bannink,Bernard,2271,FM,NED
+  9,=,W,Phillips,Roy,2271,,MAU
+  Total,4
+
+This file can be parsed as follows.
+
+  data = open('tournament.csv') { |f| f.read }
+  parser = ICU::Tournament::ForeignCSV.new
+  tournament = parser.parse(data)
+
+If the file is correctly specified, the return value from the <em>parse</em> method is an instance of
+ICU::Tournament (rather than <em>nil</em>, which indicates an error). In this example the file is valid, so:
+  
+  tournament.name                                     # => "Isle of Man Masters, 2007"
+  tournament.start                                    # => "2007-09-22"
+  tournament.rounds                                   # => 9
+  tournament.website                                  # => "http://www.bcmchess.co.uk/monarch2007/"
+
+The main player (the player whose results are being reported for rating) played 9 rounds
+but only 8 other players (he had a bye in round 6), so the total number of players is 9.
+
+  tournament.players.size                             # => 9
+  
+Each player has a unique number for the tournament. The main player always occurs first in this type of file, so his number is 1.
+
+  player = tournament.player(1)
+  player.name                                         # => "Fox, Anthony"
+
+This player has 4 points from 9 rounds but only 8 of his results are are rateable (because of the bye).
+
+  player.points                                       # => 4.0
+  player.results.size                                 # => 9
+  player.results.find_all{ |r| r.rateable }.size      # => 8
+
+The other players all have numbers greater than 1.
+
+  opponents = tournamnet.players.reject { |o| o.num == 1 }
+
+There are 8 opponents (of the main player) each with exactly one game.
+
+  opponents.size                                      # => 8
+  opponents.find_all{ |o| o.results.size == 1 }.size  # => 8
+
+However, none of the opponents' results are rateable because they are foreign to the domestic rating list
+to which the main player belongs. For example:
+
+  opponent = tournament.players(2)
+  opponent.name                                       # => "Taylor, Peter P."
+  opponent.results[0].rateable                        # => false
+
+A tournament can be serialized back to CSV format (the reverse of parsing) with the _serialize_ method
+of the parser object.
+
+  csv = parser.serialize(tournament)
+
+Or equivalently, the _serialize_ instance method of the tournament, if the appropriate parser name is supplied.
+
+  csv = tournament.serialize('ForeignCSV')
+
+You can also build the tournament object from scratch using your own data and then serialize it.
+For example, here are the commands to reproduce the example above.
+
+  t = ICU::Tournament.new("Isle of Man Masters, 2007", '2007-09-22', :rounds => 9)
+  t.site = 'http://www.bcmchess.co.uk/monarch2007/'
+  t.add_player(ICU::Player.new('Anthony',  'Fox',      1, :rating => 2100, :fed => 'IRL', :id => 456))
+  t.add_player(ICU::Player.new('Peter P.', 'Taylor',   2, :rating => 2209, :fed => 'ENG'))
+  t.add_player(ICU::Player.new('Egozi',    'Nadav',    3, :rating => 2205, :fed => 'ISR'))
+  t.add_player(ICU::Player.new('Peter',    'Cafolla',  4, :rating => 2048, :fed => 'IRL'))
+  t.add_player(ICU::Player.new('Tim R.',   'Spanton',  5, :rating => 1982, :fed => 'ENG'))
+  t.add_player(ICU::Player.new('Alan',     'Grant',    6, :rating => 2223, :fed => 'SCO'))
+  t.add_player(ICU::Player.new('Alan J.',  'Walton',   7, :rating => 2223, :fed => 'ENG'))
+  t.add_player(ICU::Player.new('Bernard',  'Bannink',  8, :rating => 2271, :fed => 'NED', :title => 'FM'))
+  t.add_player(ICU::Player.new('Roy',      'Phillips', 9, :rating => 2271, :fed => 'MAU'))
+  t.add_result(ICU::Result.new(1, 1, 'L', :opponent => 2, :colour => 'B'))
+  t.add_result(ICU::Result.new(2, 1, 'D', :opponent => 3, :colour => 'W'))
+  t.add_result(ICU::Result.new(3, 1, 'D', :opponent => 4, :colour => 'B'))
+  t.add_result(ICU::Result.new(4, 1, 'W', :opponent => 5, :colour => 'W'))
+  t.add_result(ICU::Result.new(5, 1, 'W', :opponent => 6, :colour => 'B'))
+  t.add_result(ICU::Result.new(6, 1, 'L'))                 
+  t.add_result(ICU::Result.new(7, 1, 'D', :opponent => 7, :colour => 'W'))
+  t.add_result(ICU::Result.new(8, 1, 'L', :opponent => 8, :colour => 'B'))
+  t.add_result(ICU::Result.new(9, 1, 'D', :opponent => 9, :colour => 'W'))
+  t.validate!
+  puts t.serialize('ForeignCSV')
+  
+=end
+
+    class ForeignCSV
+      attr_reader :error
+      
+      # Parse CSV data returning a Tournament on success or a nil on failure.
+      # In the case of failure, an error message can be retrived via the <em>error</em> method.
+      def parse(csv)
+        begin
+          parse!(csv)
+        rescue => ex
+          @error = ex.message
+          nil
+        end
+      end
+      
+      # Parse CSV data returning a Tournament on success or raising an exception on error.
+      def parse!(csv)
+        @state, @line, @round, @sum, @error = 0, 0, nil, nil, nil
+        @tournament = Tournament.new('Dummy', '2000-01-01')
+        
+        Util::CSV.parse(csv, :row_sep => :auto) do |r|
+          @line += 1                            # increment line number
+          next if r.size == 0                   # skip empty lines
+          r = r.map{|c| c.nil? ? '' : c.strip}  # trim all spaces, turn nils to blanks
+          next if r[0] == ''                    # skip blanks in column 1
+          @r = r                                # remember this record for later
+          
+          begin
+            case @state
+              when 0 then event
+              when 1 then start
+              when 2 then rounds
+              when 3 then website
+              when 4 then player
+              when 5 then result
+              when 6 then total
+              else raise "internal error - state #{@state} does not exist"
+            end
+          rescue => err
+            raise err.class, "line #{@line}: #{err.message}", err.backtrace unless err.message.match(/^line [1-9]/)
+            raise
+          end
+        end
+        
+        unless @state == 4
+          exp = case @state
+                when 0 then "the event name"
+                when 1 then "the start date"
+                when 2 then "the number of rounds"
+                when 3 then "the website address"
+                when 5 then "a result for round #{@round+1}"
+                when 6 then "a total score"
+                end
+          raise "line #{@line}: premature termination - expected #{exp}"
+        end
+        raise "line #{@line}: no players found in file" if @tournament.players.size == 0
+        
+        @tournament.validate!
+
+        @tournament
+      end
+      
+      # Serialise a tournament back into CSV format.
+      def serialize(t)
+        return nil unless t.class == ICU::Tournament;
+        Util::CSV.generate do |csv|
+          csv << ["Event", t.name]
+          csv << ["Start", t.start]
+          csv << ["Rounds", t.rounds]
+          csv << ["Website", t.site]
+          t.players.each do |p|
+            next unless p.id
+            csv << []
+            csv << ["Player", p.id, p.last_name, p.first_name]
+            (1..t.rounds).each do |n|
+              data = []
+              data << n
+              r = p.find_result(n)
+              data << case r.score; when 'W' then '1'; when 'L' then '0'; else '='; end
+              if r.rateable
+                data << r.colour
+                o = t.player(r.opponent)
+                data << o.last_name
+                data << o.first_name
+                data << o.rating
+                data << o.title
+                data << o.fed
+              else
+                data << '-'
+              end
+              csv << data
+            end
+            csv << ["Total", p.points]
+          end
+        end
+      end
+
+      private
+      
+      def event
+        abort "the 'Event' keyword", 0 unless @r[0].match(/^(Event|Tournament)$/i)
+        abort "the event name",      1 unless @r.size > 1 && @r[1] != ''
+        @tournament.name = @r[1]
+        @state = 1
+      end
+      
+      def start
+        abort "the 'Start' keyword", 0 unless @r[0].match(/^(Start(\s+Date)?|Date)$/i)
+        abort "the start date",      1 unless @r.size > 1 && @r[1] != ''
+        @tournament.start = @r[1]
+        @state = 2
+      end
+      
+      def rounds
+        abort "the 'Rounds' keyword", 0 unless @r[0].match(/(Number of )?Rounds$/)
+        abort "the number of rounds", 1 unless @r.size > 1 && @r[1].match(/^[1-9]\d*/)
+        @tournament.rounds = @r[1]
+        @state = 3
+      end
+      
+      def website
+        abort "the 'Website' keyword", 0 unless @r[0].match(/^(Web(\s?site)?|Site)$/i)
+        abort "the event website",     1 unless @r.size > 1 && @r[1] != ''
+        @tournament.site = @r[1]
+        @state = 4
+      end
+      
+      def player
+        abort "the 'Player' keyword",  0 unless @r[0].match(/^Player$/i)
+        abort "a player's ICU number", 1 unless @r.size > 1 && @r[1].match(/^[1-9]/i)
+        abort "a player's last name",  2 unless @r.size > 2 && @r[2].match(/[a-z]/i)
+        abort "a player's first name", 3 unless @r.size > 3 && @r[3].match(/[a-z]/i)
+        @player = Player.new(@r[3], @r[2], @tournament.players.size + 1, :id => @r[1])
+        old_player = @tournament.find_player(@player)
+        if old_player
+          raise "two players with the same name (#{@player.name}) have conflicting details" unless old_player.eql?(@player)
+          raise "same player (#{@player.name}) has more than one set of results" if old_player.id
+          old_player.merge(@player)
+          @player = old_player
+        else
+          @tournament.add_player(@player)
+        end
+        @round = 0
+        @state = 5
+      end
+      
+      def result
+        @round+= 1
+        abort "round number #{round}",              0 unless @r[0].to_i == @round
+        abort "a colour (W/B) or dash (for a bye)", 2 unless @r.size > 2 && @r[2].match(/^(W|B|-)/i)
+        result = Result.new(@round, @player.num, @r[1])
+        if @r[2] == '-'
+          @tournament.add_result(result)
+        else
+          result.colour = @r[2]
+          opponent = Player.new(@r[4], @r[3], @tournament.players.size + 1, :rating => @r[5], :title => @r[6], :fed => @r[7])
+          raise "opponent must have a federation" unless opponent.fed
+          old_player = @tournament.find_player(opponent)
+          if old_player
+            raise "two players with the same name (#{opponent.name}) have conflicting details" unless old_player.eql?(opponent)
+            result.opponent = old_player.num
+            if old_player.id
+              old_player.merge(opponent)
+              old_result = @player.find_result(@round)
+              raise "missing result for player (#{@player.name}) in round #{@round}" unless old_result
+              raise "mismatched results for player (#{old_player.name}) in round #{@round}" unless result == old_result
+              old_result.rateable = true
+            else
+              old_result = old_player.find_result(@round)
+              raise "a player (#{old_player.name}) has more than one game in the same round (#{@round})" if old_result
+              @tournament.add_result(result, false)
+            end
+          else
+            @tournament.add_player(opponent)
+            result.opponent = opponent.num
+            @tournament.add_result(result, false)
+          end
+        end
+        @state = 6 if @round == @tournament.rounds
+      end
+      
+      def total
+        points = @player.points
+        abort "the 'Total' keyword", 0 unless @r[0].match(/^Total$/i)
+        abort "the player's (#{@player.object_id}, #{@player.results.size}) total points to be #{points}", 1 unless @r[1].to_f == points
+        @state = 4
+      end
+      
+      def abort(expected, cell)
+        got = @r[cell]
+        error = "line #{@line}"
+        error << ", cell #{cell+1}"
+        error << ": expected #{expected}"
+        error << " but got #{got == '' ? 'a blank cell' : "'#{got}'"}"
+        raise error
+      end
+    end
+  end
+end

data/lib/icu_tournament/tournament_krause.rb

@@ -0,0 +1,329 @@
+module ICU
+  class Tournament
+    
+=begin rdoc
+
+== Krause
+
+This is the {format}[http://www.fide.com/component/content/article/5-whats-news/2245-736-general-data-exchange-format-for-tournament-results]
+used to submit tournament results to FIDE[http://www.fide.com] for rating.
+
+Suppose, for example, that the following data is the file <em>tournament.tab</em>:
+
+  012 Fantasy Tournament
+  032 IRL
+  042 2009.09.09
+  0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890
+  132                                                                                        09.09.09  09.09.10  09.09.11
+  001    1 w    Mouse,Minerva                     1900 USA     1234567 1928.05.15  1.0    2     2 b 0     3 w 1          
+  001    2 m  m Duck,Daffy                        2200 IRL     7654321 1937.04.17  2.0    1     1 w 1               3 b 1
+  001    3 m  g Mouse,Mickey                      2600 USA     1726354 1928.05.15  0.0    3               1 b 0     2 w 0
+
+This file can be parsed as follows.
+
+  data = open('tournament.tab') { |f| f.read }
+  parser = ICU::Tournament::Krause.new
+  tournament = parser.parse(data)
+
+If the file is correctly specified, the return value from the <em>parse</em> method is an instance of
+ICU::Tournament (rather than <em>nil</em>, which indicates an error). In this example the file is valid, so:
+  
+  tournament.name                   # => "Fantasy Tournament"
+  tournament.start                  # => "2009-09-09"
+  tournament.fed                    # => "IRL"
+  tournament.players.size           # => 9
+
+Some values, not explicitly set in the file, are deduced:
+  
+  tournament.rounds                 # => 3
+  tournament.finish                 # => "2009-09-11"
+  
+A player can be retrieved from the tournament via the _players_ array or by sending a valid player number to the _player_ method.
+
+  minnie = tournament.player(1)
+  minnie.name                       # => "Mouse, Minerva"
+  minnie.points                     # => 1.0
+  minnie.results.size               # => 2
+  
+  daffy = tournament.player(2)
+  daffy.title                       # => "IM"
+  daffy.rating                      # => 2200
+  daffy.fed                         # => "IRL"
+  daffy.id                          # => 7654321
+  daffy.dob                         # => "1937-04-17"
+
+If the ranking numbers are missing from the file or inconsistent (e.g. player A is ranked above player B
+but has less points than player B) they are recalculated as a side effect of the parse.
+
+  daffy.rank                        # => 1
+  minnie.rank                       # => 2
+  mickey.rank                       # => 3
+
+Comments in the input file (lines that do not start with a valid data identification number) are available from the parser
+instance via its _comments_ method (returning a string). Note that these comments are reset evry time the instance is used
+to parse another file.
+
+  parser.comments                   # => "0123456789..."
+
+A tournament can be serialized back to Krause format (the reverse of parsing) with the _serialize_ method of the parser.
+
+  krause = parser.serialize(tournament)
+
+Or alternatively, by the _serialize_ method of the tournament object if the name of the serializer is supplied.
+
+  krause = tournament.serialize('Krause')
+
+The following lists Krause data identification numbers, their description and, where available, their corresponding
+attributes in an ICU::Tournament instance.
+
+[001 Player record]           Use _players_ to get all players or _player_ with a player number to get a single instance.
+[012 Name]                    Get or set with _name_. Free text. A tounament name is mandatory.
+[013 Teams]                   Create an ICU::Team, add player numbers to it, use _add_team_ to add to tournament, _get_team_/_teams_ to retrive it/them.
+[022 City]                    Get or set with _city_. Free text.
+[032 Federation]              Get or set with _fed_. Getter returns either _nil_ or a three letter code. Setter can take various formats (see ICU::Federation).
+[042 Start date]              Get or set with _start_. Getter returns <em>yyyy-mm-dd</em> format, but setter can use any reasonable date format. Start date is mandadory.
+[052 End date]                Get or set with _finish_. Returns either <em>yyyy-mm-dd</em> format or _nil_ if not set. Like _start_, can be set with various date formats.
+[062 Number of players]       Not used. Treated as comment in parsed files. Can be determined from the size of the _players_ array.
+[072 Number of rated players] Not used. Treated as comment in parsed files. Can be determined by analysing the array returned by _players_.
+[082 Number of teams]         Not used. Treated as comment in parsed files.
+[092 Type of tournament]      Get or set with _type_. Free text.
+[102 Arbiter(s)]              Get or set with -arbiter_. Free text.
+[112 Deputy(ies)]             Get or set with _deputy_. Free text.
+[122 Time control]            Get or set with _time_control_. Free text.
+[132 Round dates]             Get an array of dates using _round_dates_ or one specific round date by calling _round_date_ with a round number.
+
+=end
+
+    class Krause
+      attr_reader :error, :comments
+      
+      # Parse Krause data returning a Tournament on success or a nil on failure.
+      # In the case of failure, an error message can be retrived via the <em>error</em> method.
+      def parse(krs)
+        begin
+          parse!(krs)
+        rescue => ex
+          @error = ex.message
+          nil
+        end
+      end
+      
+      # Parse Krause data returning a Tournament on success or raising an exception on error.
+      def parse!(krs)
+        @lineno = 0
+        @tournament = Tournament.new('Dummy', '2000-01-01')
+        @name_set, @start_set = false, false
+        @comments = ''
+        @results = Array.new
+        
+        # Process all lines.
+        krs.each_line do |line|
+          @lineno += 1         # increment line number
+          line.strip!          # remove leading and trailing white space
+          next if line == ''   # skip blank lines
+          @line = line         # remember this line for later
+          
+          # Does it havea DIN or is it just a comment?
+          if @line.match(/^(\d{3}) (.*)$/)
+            din = $1           # data identification number (DIN)
+            @data = $2         # the data after the DIN
+          else
+            add_comment
+            next
+          end
+          
+          # Process the line given the DIN.
+          begin
+            case din
+              when '001' then add_player                        # player and results record
+              when '012' then set_name                          # name (mandatory)
+              when '013' then add_team                          # team name and members
+              when '022' then @tournament.city = @data          # city
+              when '032' then @tournament.fed = @data           # federation
+              when '042' then set_start                         # start date (mandatory)
+              when '052' then @tournament.finish = @data        # end date
+              when '062' then add_comment                       # number of players (calculated from 001 records)
+              when '072' then add_comment                       # number of rated players (calculated from 001 records)
+              when '082' then add_comment                       # number of teams (calculated from 013 records)
+              when '092' then @tournament.type = @data          # type of tournament
+              when '102' then @tournament.arbiter = @data       # arbiter(s)
+              when '112' then @tournament.deputy = @data        # deputy(ies)
+              when '122' then @tournament.time_control = @data  # time control
+              when '132' then add_round_dates                   # round dates
+              else raise "invalid DIN #{din}"
+            end
+          rescue => err
+            raise err.class, "line #{@lineno}: #{err.message}", err.backtrace
+          end
+        end
+        
+        # Now that all players are present, add the results to the tournament.
+        @results.each do |r|
+          lineno, player, data, result = r
+          begin
+            @tournament.add_result(result)
+          rescue => err
+            raise "line #{lineno}, player #{player}, result '#{data}': #{err.message}"
+          end
+        end
+        
+        # Certain attributes are mandatory and should have been specifically set.
+        raise "tournament name missing"       unless @name_set
+        raise "tournament start date missing" unless @start_set
+        
+        # Finally, exercise the tournament object's internal validation, reranking if neccessary.
+        @tournament.validate!(:rerank => true)
+        
+        @tournament
+      end
+      
+      # Serialise a tournament back into Krause format.
+      def serialize(t)
+        return nil unless t.class == ICU::Tournament;
+        krause = ''
+        krause << "012 #{t.name}\n"
+        krause << "022 #{t.city}\n"         if t.city
+        krause << "032 #{t.fed}\n"          if t.fed
+        krause << "042 #{t.start}\n"
+        krause << "052 #{t.finish}\n"       if t.finish
+        krause << "092 #{t.type}\n"         if t.type
+        krause << "102 #{t.arbiter}\n"      if t.arbiter
+        krause << "112 #{t.deputy}\n"       if t.deputy
+        krause << "122 #{t.time_control}\n" if t.time_control
+        t.teams.each do |team|
+          krause << sprintf('013 %-31s', team.name)
+          team.members.each{ |m| krause << sprintf(' %4d', m) }
+          krause << "\n"
+        end
+        rounds = t.last_round
+        if t.round_dates.size == rounds && rounds > 0
+          krause << "132 #{' ' * 85}"
+          t.round_dates.each{ |d| krause << d.sub(/^../, '  ') }
+          krause << "\n"
+        end
+        t.players.each{ |p| krause << p.to_krause(rounds) }
+        krause
+      end
+
+      private
+      
+      def set_name
+        @tournament.name = @data
+        @name_set = true
+      end
+      
+      def set_start
+        @tournament.start = @data
+        @start_set = true
+      end
+      
+      def add_player
+        raise "player record less than minimum length" if @line.length < 99
+        
+        # Player details.
+        num = @data[0, 4]
+        nam = Name.new(@data[10, 32])
+        opt =
+        {
+          :gender => @data[5, 1],
+          :title  => @data[6, 3],
+          :rating => @data[44, 4],
+          :fed    => @data[49, 3],
+          :id     => @data[53, 11],
+          :dob    => @data[65, 10],
+          :rank   => @data[81, 4],
+        }
+        player = Player.new(nam.first, nam.last, num, opt)
+        @tournament.add_player(player)
+        
+        # Results.
+        points = @data[77, 4].strip
+        points = points == '' ? nil : points.to_f
+        index  = 87
+        round  = 1
+        total  = 0.0
+        while @data.length >= index + 8
+          total+= add_result(round, player.num, @data[index, 8])
+          index+= 10
+          round+= 1
+        end
+        raise "declared points total (#{points}) does not agree with total from summed results (#{total})" if points && points != total
+      end
+      
+      def add_result(round, player, data)
+        return 0.0 if data.strip! == ''  # no result for this round
+        raise "invalid result '#{data}'" unless data.match(/^(0{1,4}|[1-9]\d{0,3}) (w|b|-) (1|0|=|\+|-)$/)
+        opponent = $1.to_i
+        colour   = $2
+        score    = $3
+        options  = Hash.new
+        options[:opponent] = opponent unless opponent == 0
+        options[:colour]   = colour   unless colour == '-'
+        options[:rateable] = false    unless score.match(/^(1|0|=)$/)
+        result   = Result.new(round, player, score, options)
+        @results << [@lineno, player, data, result]
+        result.points
+      end
+      
+      def add_team
+        raise error "team record less than minimum length" if @line.length < 40
+        team = Team.new(@data[0, 31])
+        index = 32
+        while @data.length >= index + 4
+          team.add_member(@data[index, 4])
+          index+= 5
+        end
+        @tournament.add_team(team)
+      end
+      
+      def add_round_dates
+        raise "round dates record less than minimum length" if @line.length < 99
+        index  = 87
+        while @data.length >= index + 8
+          date = @data[index, 8].strip
+          @tournament.add_round_date("20#{date}") unless date == ''
+          index+= 10
+        end
+      end
+
+      def add_comment
+        @comments << @line
+        @comments << "\n"
+      end
+    end
+  end
+  
+  class Player
+    # Format a player's 001 record as it would appear in a Krause formatted file (including the final newline).
+    def to_krause(rounds)
+      krause = '001'
+      krause << sprintf(' %4d', @num)
+      krause << sprintf(' %1s', case @gender; when 'M' then 'm'; when 'F' then 'w'; else ''; end)
+      krause << sprintf(' %2s', case @title; when nil then ''; when 'IM' then 'm'; when 'WIM' then 'wm'; else @title[0, @title.length-1].downcase; end)
+      krause << sprintf(' %-33s', "#{@last_name},#{@first_name}")
+      krause << sprintf(' %4s', @rating)
+      krause << sprintf(' %3s', @fed)
+      krause << sprintf(' %11s', @id)
+      krause << sprintf(' %10s', @dob)
+      krause << sprintf(' %4.1f', points)
+      krause << sprintf(' %4s', @rank)
+      (1..rounds).each do |r|
+        result = find_result(r)
+        krause << sprintf('  %8s', result ? result.to_krause : '')
+      end
+      krause << "\n"
+    end
+  end
+  
+  class Result
+    # Format a player's result as it would appear in a Krause formatted file (exactly 8 characters long, including leading whitespace).
+    def to_krause
+      return ' ' * 8 if !@opponent && !@colour && @score == 'L'
+      krause = sprintf('%4s ', @opponent || '0000')
+      krause << sprintf('%1s ', @colour ? @colour.downcase : '-')
+      krause << case @score; when 'W' then '1'; when 'L' then '0'; else '='; end if  @rateable
+      krause << case @score; when 'W' then '+'; when 'L' then '-'; else '='; end if !@rateable
+      krause
+    end
+  end
+end