icu_tournament 0.9.6 → 1.0.0

data/lib/icu_tournament.rb

@@ -3,6 +3,6 @@
 icu_tournament_files = Array.new
 icu_tournament_files.concat %w{util name federation}
 icu_tournament_files.concat %w{player result team tournament}
-icu_tournament_files.concat %w{fcsv krause}.map{ |f| "tournament_#{f}"}
+icu_tournament_files.concat %w{fcsv krause sp}.map{ |f| "tournament_#{f}"}
 
 icu_tournament_files.each { |file| require "icu_tournament/#{file}" }

data/lib/icu_tournament/player.rb

@@ -25,7 +25,7 @@ _fed_ (federation), _title_, _rating_, _rank_ and _dob_ (date of birth).
 Some of these values will also be canonicalised to some extent. For example,
 the date of birth conforms to a _yyyy-mm-dd_ format, the chess title will be two
 to three capital letters always ending in _M_ and the federation, if it's three
-letters long, will be upcased.
+letters long, will be upper-cased.
 
   peter.dob                        # => 1976-07-17
   peter.title                      # => 'GM'
@@ -40,6 +40,11 @@ Total scores is available via the _points_ method.
 
   peter.points                     # => 5.5
 
+A player's _id_ is their ID number in some external database (typically either ICU or FIDE).
+
+  peter.id = 16790                 # ICU, or
+  peter.id = 4102142               # FIDE
+
 Players can be compared to see if they're roughly or exactly the same, which may be useful in detecting duplicates.
 If the names match and the federations don't disagree then two players are equal according to the _==_ operator.
 The player number is irrelevant.
@@ -152,7 +157,12 @@ All other attributes are unaffected.
       already = @results.find_all { |r| r.round == result.round }
       return if already.size == 1 && already[0].eql?(result)
       raise "round number (#{result.round}) of new result is not unique and new result is not the same as existing one" unless already.size == 0
-      @results << result
+      if @results.size == 0 || @results.last.round <= result.round
+        @results << result
+      else
+        i = (0..@results.size-1).find { |n| @results[n].round > result.round }
+        @results.insert(i, result)
+      end
     end
     
     # Lookup a result by round number.

data/lib/icu_tournament/result.rb

@@ -168,7 +168,9 @@ The _points_ read-only accessor always returns a floating point number: either 0
       self.player = map[@player]
       if @opponent
         raise "result opponent number #{@opponent} not found in renumbering hash" unless map[@opponent]
+        old_rateable = @rateable
         self.opponent = map[@opponent]
+        self.rateable = old_rateable  # because setting the opponent has a side-effect which is undesirable in this context
       end
       self
     end

data/lib/icu_tournament/tournament.rb

@@ -25,7 +25,7 @@ For example:
   t.add_result(ICU::Result.new(1, 10, 'D', :opponent => 30, :colour => 'W'))
   t.add_result(ICU::Result.new(2, 20, 'W', :opponent => 30, :colour => 'B'))
   t.add_result(ICU::Result.new(3, 20, 'L', :opponent => 10, :colour => 'W'))
-  
+
   t.validate!(:rerank => true)
 
 and then:
@@ -43,7 +43,7 @@ would result in the following output:
   042 2009-11-09
   001   10      Fischer,Bobby                                                      1.5    1    30 w =              20 b 1
   001   20      Kasparov,Garry                                                     1.0    2              30 b 1    10 w 0
-  001   30      Orr,Mark                                                           0.5    3    10 b =    20 w 0          
+  001   30      Orr,Mark                                                           0.5    3    10 b =    20 w 0
 
 Note that the players should be added first because the _add_result_ method will
 raise an exception if the players it references through their tournament numbers
@@ -75,7 +75,7 @@ Side effects of calling _validate!_ or _invalid_ include:
 
 == Ranking
 
-They players in a tournament can be ranked by calling the _rerank_ method directly.
+The players in a tournament can be ranked by calling the _rerank_ method directly.
 
   t.rerank
 
@@ -89,14 +89,11 @@ have a rank but some are ranked higher than others on lower scores.
 
 To rank the players requires a tie break method to be specified to order players on the same score.
 The default is alphabetical (by last name then first name). Other methods can be specified by supplying
-a list of methods (strings or symbols) in order of precedence to the _rerank_ method or for the _rerank_
-option of the _validate_ method. Examples:
+an array of methods (strings or symbols) in order of precedence to the _tie_breaks_ setter. Examples:
 
-  t.rerank('Sonneborn-Berger')
-  t.rerank(:buchholz, :neustadtl, :blacks, :wins)
-  
-  t.validate(:rerank => :sonneborn_berger)
-  t.validate(:rerank => ['Modified Median', 'Neustadtl', 'Buchholz', 'wins'])
+  t.tie_breaks = ['Sonneborn-Berger']
+  t.tie_breaks = [:buchholz, :neustadtl, :blacks, :wins]
+  t.tie_breaks = []  # reset to the default
 
 The full list of supported methods is:
 
@@ -106,28 +103,31 @@ The full list of supported methods is:
 * _Neustadtl_ (or _Sonneborn-Berger_): sum of scores of players defeated plus half sum of scores of players drawn against
 * _blacks_: number of blacks
 * _wins_: number of wins
-* _name_: alphabetical by name is the default and is the same as calling _rerank_ with no options or setting the _rerank_ option to true
+* _name_: alphabetical by name (if _tie_breaks_ is set to an empty array, as it is initially, then this will be used as the back-up tie breaker)
+
+The return value from _rerank_ is the tournament object itself, to allow chaining, for example:
 
-The return value from _rerank_ is the tournament object itself.
+  t.rerank.renumber
 
 
 == Renumbering
 
 The numbers used to uniquely identify each player in a tournament can be any set of unique integers
 (including zero and negative numbers). To renumber the players so that these numbers start at 1 and
-go up to the total number of players use the _renumber_ method. This method takes one optional
+end with the total number of players, use the _renumber_ method. This method takes one optional
 argument to specify how the renumbering is done.
 
   t.renumber(:rank)       # renumber by rank (if there are consistent rankings), otherwise by name alphabetically
   t.renumber              # the same, as renumbering by rank is the default
   t.renumber(:name)       # renumber by name alphabetically
-  
+  t.renumber(:order)      # renumber maintaining the order of the original numbers
+
 The return value from _renumber_ is the tournament object itself.
 
 =end
 
   class Tournament
-    
+
     extend ICU::Accessor
     attr_date :start
     attr_date_or_nil :finish
@@ -135,9 +135,9 @@ The return value from _renumber_ is the tournament object itself.
     attr_string %r%[a-z]%i, :name
     attr_string_or_nil %r%[a-z]%i, :city, :type, :arbiter, :deputy
     attr_string_or_nil %r%[1-9]%i, :time_control
-    
-    attr_reader :round_dates, :site, :fed, :teams
-    
+
+    attr_reader :round_dates, :site, :fed, :teams, :tie_breaks
+
     # Constructor. Name and start date must be supplied. Other attributes are optional.
     def initialize(name, start, opt={})
       self.name  = name
@@ -146,15 +146,16 @@ The return value from _renumber_ is the tournament object itself.
       @player = {}
       @teams = []
       @round_dates = []
+      @tie_breaks = []
     end
-    
+
     # Set the tournament federation. Can be _nil_.
     def fed=(fed)
       obj = Federation.find(fed)
       @fed = obj ? obj.code : nil
       raise "invalid tournament federation (#{fed})" if @fed.nil? && fed.to_s.strip.length > 0
     end
-    
+
     # Add a round date.
     def add_round_date(round_date)
       round_date = round_date.to_s.strip
@@ -163,12 +164,12 @@ The return value from _renumber_ is the tournament object itself.
       @round_dates << parsed_date
       @round_dates.sort!
     end
-    
+
     # Return the date of a given round, or nil if unavailable.
     def round_date(round)
       @round_dates[round-1]
     end
-    
+
     # Return the greatest round number according to the players results (which may not be the same as the set number of rounds).
     def last_round
       last_round = 0
@@ -187,7 +188,7 @@ The return value from _renumber_ is the tournament object itself.
       @site = "http://#{@site}" if @site && !@site.match(/^https?:\/\//)
       raise "invalid site (#{site})" unless @site.nil? || @site.match(/^https?:\/\/[-\w]+(\.[-\w]+)+(\/[^\s]*)?$/i)
     end
-    
+
     # Add a new team. The argument is either a team (possibly already with members) or the name of a new team.
     # The team's name must be unique in the tournament. Returns the the team instance.
     def add_team(team)
@@ -196,34 +197,57 @@ The return value from _renumber_ is the tournament object itself.
       @teams << team
       team
     end
-    
+
     # Return the team object that matches a given name, or nil if not found.
     def get_team(name)
       @teams.find{ |t| t.matches(name) }
     end
-    
+
+    # Set the tie break methods.
+    def tie_breaks=(tie_breaks)
+      raise "argument error - always set tie breaks to an array" unless tie_breaks.class == Array
+      # Canonicalise the tie break method names.
+      tie_breaks.map! do |m|
+        m = m.to_s if m.class == Symbol
+        m = m.downcase.gsub(/[-\s]/, '_') if m.class == String
+        case m
+          when true                then 'name'
+          when 'sonneborn_berger'  then 'neustadtl'
+          when 'modified_median'   then 'modified'
+          when 'median'            then 'harkness'
+          else m
+        end
+      end
+
+      # Check they're all valid.
+      tie_breaks.each { |m| raise "invalid tie break method '#{m}'" unless m.to_s.match(/^(blacks|buchholz|harkness|modified|name|neustadtl|wins)$/) }
+
+      # Finally set them.
+      @tie_breaks = tie_breaks;
+    end
+
     # Add a new player to the tournament. Must have a unique player number.
     def add_player(player)
       raise "invalid player" unless player.class == ICU::Player
       raise "player number (#{player.num}) should be unique" if @player[player.num]
       @player[player.num] = player
     end
-    
+
     # Get a player by their number.
     def player(num)
       @player[num]
     end
-    
+
     # Return an array of all players in order of their player number.
     def players
       @player.values.sort_by{ |p| p.num }
     end
-    
+
     # Lookup a player in the tournament by player number, returning _nil_ if the player number does not exist.
     def find_player(player)
       players.find { |p| p == player }
     end
-    
+
     # Add a result to a tournament. An exception is raised if the players referenced in the result (by number)
     # do not exist in the tournament. The result, which remember is from the perspective of one of the players,
     # is added to that player's results. Additionally, the reverse of the result is automatically added to the player's
@@ -242,10 +266,10 @@ The return value from _renumber_ is the tournament object itself.
         @player[result.opponent].add_result(reverse)
       end
     end
-        
+
     # Rerank the tournament by score first and if necessary using a configurable tie breaker method.
-    def rerank(*tie_break_methods)
-      tie_break_methods, tie_break_order, tie_break_hash = tie_break_data(tie_break_methods.flatten)
+    def rerank
+      tie_break_methods, tie_break_order, tie_break_hash = tie_break_data
       @player.values.sort do |a,b|
         cmp = 0
         tie_break_methods.each do |m|
@@ -257,10 +281,10 @@ The return value from _renumber_ is the tournament object itself.
       end
       self
     end
-    
-    # Return a hash of tie break scores (player number to value).
-    def tie_break_scores(*tie_break_methods)
-      tie_break_methods, tie_break_order, tie_break_hash = tie_break_data(tie_break_methods)
+
+    # Return a hash (player number to value) of tie break scores for the main method.
+    def tie_break_scores
+      tie_break_methods, tie_break_order, tie_break_hash = tie_break_data
       main_method = tie_break_methods[1]
       scores = Hash.new
       @player.values.each { |p| scores[p.num] = tie_break_hash[main_method][p.num] }
@@ -269,18 +293,30 @@ The return value from _renumber_ is the tournament object itself.
 
     # Renumber the players according to a given criterion.
     def renumber(criterion = :rank)
-      map = Hash.new
-      
-      # Decide how to renumber.
-      criterion = criterion.to_s.downcase
-      if criterion.match('rank')
-        # Renumber by rank if possible.
-        begin check_ranks rescue criterion = 'name' end
-        @player.values.each{ |p| map[p.num] = p.rank }
-      end
-      if !criterion.match('rank')
-        # Renumber by name alphabetically.
-        @player.values.sort_by{ |p| p.name }.each_with_index{ |p, i| map[p.num] = i + 1 }
+      if (criterion.class == Hash)
+        # Undocumentted feature - supply your own hash.
+        map = criterion
+      else
+        # Official way of reordering.
+        map = Hash.new
+
+        # Renumber by rank only if possible.
+        criterion = criterion.to_s.downcase
+        if criterion == 'rank'
+          begin check_ranks rescue criterion = 'name' end
+        end
+
+        # Decide how to renumber.
+        if criterion == 'rank'
+          # Renumber by rank.
+          @player.values.each{ |p| map[p.num] = p.rank }
+        elsif criterion == 'order'
+          # Just keep the existing numbers in order.
+          @player.values.sort_by{ |p| p.num }.each_with_index{ |p, i| map[p.num] = i + 1 }
+        else
+          # Renumber by name alphabetically.
+          @player.values.sort_by{ |p| p.name }.each_with_index{ |p, i| map[p.num] = i + 1 }
+        end
       end
 
       # Apply renumbering.
@@ -290,7 +326,8 @@ The return value from _renumber_ is the tournament object itself.
         hash[player.num] = player
         hash
       end
-      
+
+      # Return self for chaining.
       self
     end
 
@@ -306,10 +343,9 @@ The return value from _renumber_ is the tournament object itself.
     end
 
     # Raise an exception if a tournament is not valid.
-    # The _rerank_ option can be set to _true_ or one of the valid tie-break
-    # methods to rerank the tournament if ranking is missing or inconsistent.
+    # The _rerank_ option can be set to _true_ rerank the tournament if ranking is missing or inconsistent.
     def validate!(options={})
-      begin check_ranks rescue rerank(options[:rerank]) end if options[:rerank]
+      begin check_ranks rescue rerank end if options[:rerank]
       check_players
       check_rounds
       check_dates
@@ -317,20 +353,21 @@ The return value from _renumber_ is the tournament object itself.
       check_ranks(:allow_none => true)
       true
     end
-    
+
     # Convenience method to serialise the tournament into a supported format.
     # Throws and exception unless the name of a supported format is supplied (e.g. _Krause_).
     def serialize(format)
       serializer = case format.to_s.downcase
-        when 'krause'     then ICU::Tournament::Krause.new
-        when 'foreigncsv' then ICU::Tournament::ForeignCSV.new
+        when 'krause'       then ICU::Tournament::Krause.new
+        when 'foreigncsv'   then ICU::Tournament::ForeignCSV.new
+        when 'swissperfect' then ICU::Tournament::SwissPerfect.new
         else raise "unsupported serialisation format: '#{format}'"
       end
       serializer.serialize(self)
     end
 
     private
-    
+
     # Check players.
     def check_players
       raise "the number of players (#{@player.size}) must be at least 2" if @player.size < 2
@@ -342,7 +379,7 @@ The return value from _renumber_ is the tournament object itself.
         end
       end
     end
-    
+
     # Round should go from 1 to a maximum, there should be at least one result in every round and,
     # if the number of rounds has been set, it should agree with the largest round from the results.
     def check_rounds
@@ -372,7 +409,7 @@ The return value from _renumber_ is the tournament object itself.
         @finish = @round_dates[-1] unless @finish
       end
     end
-    
+
     # Check teams. Either there are none or:
     # * every team member is a valid player, and
     # * every player is a member of exactly one team.
@@ -417,48 +454,33 @@ The return value from _renumber_ is the tournament object itself.
         end
       end
     end
-    
+
     # Return an array of tie break methods and an array of tie break orders (+1 for asc, -1 for desc).
     # The first and most important method is always "score", the last and least important is always "name".
-    def tie_break_data(tie_break_methods)
-      # Canonicalise the tie break method names.
-      tie_break_methods.map! do |m|
-        m = m.to_s if m.class == Symbol
-        m = m.downcase.gsub(/[-\s]/, '_') if m.class == String
-        case m
-          when true                then 'name'
-          when 'sonneborn_berger'  then 'neustadtl'
-          when 'modified_median'   then 'modified'
-          when 'median'            then 'harkness'
-          else m
-        end
-      end
-      
-      # Check they're all valid.
-      tie_break_methods.each { |m| raise "invalid tie break method '#{m}'" unless m.match(/^(blacks|buchholz|harkness|modified|name|neustadtl|wins)$/) }     
-      
+    def tie_break_data
+
       # Construct the arrays and hashes to be returned.
       methods, order, data = Array.new, Hash.new, Hash.new
-      
+
       # Score is always the most important.
       methods << 'score'
       order['score'] = -1
-      
+
       # Add the configured methods.
-      tie_break_methods.each do |m|
+      tie_breaks.each do |m|
         methods << m
         order[m] = -1
       end
-      
+
       # Name is included as the last and least important tie breaker unless it's already been added.
       unless methods.include?('name')
         methods << 'name'
         order['name'] = +1
       end
-      
+
       # We'll need the number of rounds.
       rounds = last_round
-      
+
       # Pre-calculate some scores that are not in themselves tie break score
       # but are needed in the calculation of some of the actual tie-break scores.
       pre_calculated = Array.new
@@ -469,18 +491,18 @@ The return value from _renumber_ is the tournament object itself.
           data[m][p.num] = tie_break_score(data, m, p, rounds)
         end
       end
-      
+
       # Now calculate all the other scores.
       methods.each do |m|
         next if pre_calculated.include?(m)
         data[m] = Hash.new
         @player.values.each { |p| data[m][p.num] = tie_break_score(data, m, p, rounds) }
       end
-      
+
       # Finally, return what we calculated.
       [methods, order, data]
     end
-    
+
     # Return a tie break score for a given player and a given tie break method.
     def tie_break_score(hash, method, player, rounds)
       case method

data/lib/icu_tournament/tournament_sp.rb

@@ -0,0 +1,309 @@
+require 'inifile'
+require 'dbf'
+
+module ICU
+  class Tournament
+
+=begin rdoc
+
+== SwissPerfect
+
+This is the format produced by the Windows program, SwissPerfect[http://www.swissperfect.com/]. It consists of three
+files with the same name but different endings: <em>.ini</em> for meta data such as tournament name and tie-break
+rules, <em>.trn</em> for the player details such as name and ID, and <em>.sco</em> for the results. The first
+file is text and the other two are in an old binary format known as <em>DBase 3</em>.
+
+To parse such a set of files, use either the _parse_file!_ or _parse_file_ method supplying the name of any one
+of the three files or just the stem name without any ending. In case of error, such as any of the files not being
+found, _parse_file!_ will throw an exception while _parse_file_ will return _nil_ and record an error message.
+As well as a file name or stem name, you must also supply a start date because SwissPerfect does not record this
+information.
+
+  parser = ICU::Tournament::SwissPerfect.new
+  tournament = parser.parse_file('champs', "2010-07-03")  # looks for "champs.ini", "champs.trn" and "champs.sco"
+  puts parser.error unless tournament
+
+Because the data is in three parts, some of which are in a legacy binary format, serialization to this format is
+not supported. Instead, a method is provided to serialize any tournament text in the format of <em>SwissPerfects</em>
+text export format, an example of which is shown below.
+
+  No  Name                 Loc Id  Total   1     2     3
+
+  1   Griffiths, Ryan-Rhys 6897    3       4:W   2:W   3:W
+  2   Flynn, Jamie         5226    2       3:W   1:L   4:W
+  3   Hulleman, Leon       6409    1       2:L   4:W   1:L
+  4   Dunne, Thomas        10914   0       1:L   3:L   2:L
+
+This format is important in Irish chess, as it's the format used to submit results to the <em>MicroSoft Access</em>
+implementation of the ICU ratings database.
+
+  swiss_perfect = tournament.serialize('SwissPerfect')
+
+As a side effect of serialization, the player numbers will be reordered (to ensure they range from 1 to the total
+number of players) and their order in the serialized format will be by player number. If you would like to have
+rank order instead, then first rank the tournament (if it isn't already ranked) and then call the _renumber_ method
+without the option argument (which will renumber by rank) before serializing. For example:
+
+  swiss_perfect = tournament.rerank(:neustadtl, :buchholz).renumber.serialize('SwissPerfect)
+
+== Todo
+
+* Allow parsing from 1 zip file
+
+=end
+
+    class SwissPerfect
+      attr_reader :error
+
+      TRN = {
+        :dob        => "BIRTH_DATE",
+        :fed        => "FEDER",
+        :first_name => "FIRSTNAME",
+        :gender     => "SEX",
+        :id         => ["LOC_ID", "INTL_ID"],
+        :last_name  => "SURNAME",
+        :num        => "ID",
+        :rank       => "ORDER",
+        :rating     => ["LOC_RTG", "INTL_RTG"],
+      } # not used: ABSENT BOARD CLUB FORB_PAIRS LATE_ENTRY LOC_RTG2 MEMO TEAM TECH_SCORE WITHDRAWAL (START_NO, BONUS used below)
+
+      SCO = %w{ROUND WHITE BLACK W_SCORE B_SCORE W_TYPE B_TYPE}  # not used W_SUBSCO, B_SUBSCO
+
+      # Parse SP data returning a Tournament or raising an exception on error.
+      def parse_file!(file, start)
+        @t = Tournament.new('Dummy', start)
+        @bonus = {}
+        @start_no = {}
+        ini, trn, sco = get_files(file)
+        parse_ini(ini)
+        parse_trn(trn)
+        parse_sco(sco)
+        fixup
+        @t.validate!(:rerank => true)
+        @t
+      end
+
+      # Parse SP data returning an ICU::Tournament or a nil on failure. In the latter
+      # case, an error message will be available via the <em>error</em> method.
+      def parse_file(file, start)
+        begin
+          parse_file!(file, start)
+        rescue => ex
+          @error = ex.message
+          nil
+        end
+      end
+
+      # Serialise a tournament to SwissPerfect text export format.
+      def serialize(t)
+        return nil unless t.class == ICU::Tournament && t.players.size > 2;
+
+        # Ensure a nice set of numbers.
+        t.renumber(:order)
+
+        # Widths for the rank, name and ID and the number of rounds.
+        m1 = t.players.inject(2) { |l, p| p.num.to_s.length  > l ? p.num.to_s.length  : l }
+        m2 = t.players.inject(4) { |l, p| p.name.length      > l ? p.name.length      : l }
+        m3 = t.players.inject(6) { |l, p| p.id.to_s.length   > l ? p.id.to_s.length   : l }
+        rounds = t.last_round
+
+        # The header, followed by a blank line.
+        formats = ["%-#{m1}s", "%-#{m2}s", "%-#{m3}s", "%-5s"]
+        (1..rounds).each { |r| formats << "%#{m1}d  " % r }
+        sp = formats.join("\t") % ['No', 'Name', 'Loc Id', 'Total']
+        sp << "\r\n\r\n"
+
+        # Adjust the round parts of the formats for players results.
+        (1..t.last_round).each { |r| formats[r+3] = "%#{m1+2}s" }
+
+        # Now add a line for each player.
+        t.players.each { |p| sp << p.to_sp_text(rounds, "#{formats.join(%Q{\t})}\r\n") }
+
+        # And return the whole lot.
+        sp
+      end
+
+      private
+
+      def get_files(file)
+        file.match(/\.zip$/i) ? get_zipped_files(file) : get_bare_files(file)
+      end
+
+      def get_bare_files(file)
+        file.sub!(/\.\w+$/, '')
+        %w(ini trn sco).map do |p|
+          q = [p, p.upcase].detect { |r| File.file? "#{file}.#{r}" }
+          raise "cannot find file #{file}.#{p}" unless q
+          "#{file}.#{q}"
+        end
+      end
+
+      def get_zipped_files(file)
+        raise "get_zip_files not implemented"
+      end
+
+      def parse_ini(file)
+        begin
+          ini = IniFile.load(file)
+        rescue
+          raise "invalid INI file"
+        end
+        raise "invalid INI file (no sections)" if ini.sections.size == 0
+        %w(name arbiter rounds).each do |key|
+          val = (ini['Tournament Info'][key.capitalize] || '').squeeze(" ").strip
+          @t.send("#{key}=", val) if val.size > 0
+        end
+        @t.tie_breaks = ini['Standings']['Tie Breaks'].to_s.split(/,/).map do |tbid|
+          case tbid.to_i             # tie break name in SwissPerfect
+          when 1217 then :buchholz   # Buchholz
+          when 1218 then :harkness   # Median Buchholz
+          when 1219 then nil         # Progress        - not implenented yet
+          when 1220 then :neustadtl  # Berger          
+          when 1221 then nil         # Rating Sum      - not implemented yet
+          when 1222 then :wins       # Number of Wins  
+          when 1223 then nil         # Minor Scores    - not applicable
+          when 1226 then nil         # Brightwell      - not applicable
+          else nil
+          end 
+        end.find_all { |tb| tb }
+      end
+
+      def parse_trn(file)
+        begin
+          trn = DBF::Table.new(file)
+        rescue
+          raise "invalid TRN file"
+        end
+        raise "invalid TRN file (no records)" if trn.record_count == 0
+        trn.each do |r|
+          next unless r
+          h = trn_record_to_hash(r)
+          @t.add_player(ICU::Player.new(h.delete(:first_name), h.delete(:last_name), h.delete(:num), h))
+        end
+      end
+
+      def parse_sco(file)
+        begin
+          sco = DBF::Table.new(file)
+        rescue
+          raise "invalid SCO file"
+        end
+        raise "invalid SCO file (no records)" if sco.record_count == 0
+        sco.each do |r|
+          next unless r
+          hs = sco_record_to_hashes(r)
+          hs.each { |h| @t.add_result(ICU::Result.new(h.delete(:round), h.delete(:player), h.delete(:score), h)) }
+        end
+      end
+
+      def trn_record_to_hash(r)
+        @bonus[r.attributes["ID"]] = %w{BONUS MEMO}.inject(0.0){ |b,k| b > 0.0 ? b : r.attributes[k].to_f }
+        @start_no[r.attributes["ID"]] = r.attributes["START_NO"]
+        TRN.inject(Hash.new) do |hash, pair|
+          keys = pair[1]
+          keys = [keys] unless keys.class == Array
+          val, val2 = keys.map { |k| r.attributes[k] }
+          case pair[0]
+          when :fed    then val = val && val.match(/^[A-Z]{3}$/i) ? val.upcase : nil
+          when :gender then val = val.to_i > 0 ? %w(M F)[val.to_i-1] : nil
+          when :id     then val = val.to_i > 0 ? val : (val2.to_i > 0 ? val2 : nil)
+          when :rating then val = val.to_i > 0 ? val : (val2.to_i > 0 ? val2 : nil)
+          when :title  then val = val.to_i > 0 ? %w(GM WGM IM WIM FM WFM)[val.to_i-1] : nil
+          end
+          hash[pair[0]] = val unless val.nil? || val == ''
+          hash
+        end
+      end
+
+      def sco_record_to_hashes(record)
+        r, w, b, ws, bs, wt, bt = SCO.map { |k| record.attributes[k] }
+        hashes = []
+        if w > 0 && b > 0 && ws + bs == 2
+          hashes.push({ :round => r, :player => w, :score => %w(L D W)[ws], :opponent => b, :colour => 'W' })
+          hashes.last[:rateable] = false unless wt == 1 && bt == 1
+        else
+          hashes.push({ :round => r, :player => w, :score => %w(L D W)[ws], :colour => 'W' }) if w > 0
+          hashes.push({ :round => r, :player => b, :score => %w(L D W)[bs], :colour => 'B' }) if b > 0
+        end
+        hashes
+      end
+
+      def fixup
+        fix_number_of_rounds
+        fix_missing_results
+        fix_bonuses
+        fix_numbering
+      end
+
+      def fix_number_of_rounds
+        rounds = @t.last_round
+        @t.rounds = rounds
+      end
+
+      def fix_missing_results
+        @t.players.each { |p| @t.add_result(ICU::Result.new(1, p.num, 'L')) if p.results.size == 0 }
+      end
+
+      def fix_bonuses
+        @t.players.each do |p|
+          bonus = @bonus[p.num] || 0
+          next unless bonus > 0
+
+          # Try to distribute the bonus in half-points to rounds where the player has no result.
+          (1..@t.rounds).each do |r|
+            result = p.find_result(r)
+            next if result
+            bonus = bonus - 0.5
+            p.add_result(ICU::Result.new(r, p.num, 'D'))
+            break if bonus <= 0
+          end
+          next unless bonus > 0
+
+          # Try to distribute the bonus in half-points to rounds where the player has unrated results.
+          (1..@t.rounds).each do |r|
+            result = p.find_result(r)
+            next unless result
+            next if result.opponent
+            next if result.score == 'W'
+            bonus = bonus - 0.5
+            result.score = result.score == 'D' ? 'W' : 'D'
+            break if bonus <= 0
+          end
+        end
+      end
+
+      def fix_numbering
+        @t.renumber(@start_no)
+      end
+    end
+  end
+
+  class Player
+    # Format a player's record as it would appear in an SP text export file.
+    def to_sp_text(rounds, format)
+      attrs = [num.to_s, name, id.to_s, ('%.1f' % points).sub(/\.0/, '')]
+      (1..rounds).each do |r|
+        result = find_result(r)
+        attrs << (result ? result.to_sp_text : " : ")
+      end
+      format % attrs
+    end
+  end
+
+  class Result
+    # Format a player's result as it would appear in an SP text export file.
+    def to_sp_text
+      sp = opponent ? opponent.to_s : '0'
+      sp << ':'
+      if rateable
+        sp << score
+      else
+        sp << case score
+        when 'W' then '+'
+        when 'L' then '-'
+        else '='
+        end
+      end
+    end
+  end
+end

data/lib/icu_tournament/version.rb

@@ -1,5 +1,5 @@
 module ICU
   class Tournament
-    VERSION = "0.9.6"
+    VERSION = "1.0.0"
   end
 end

data/spec/tournament_sp_spec.rb

@@ -0,0 +1,157 @@
+require File.dirname(__FILE__) + '/spec_helper'
+SAMPLES = File.dirname(__FILE__) + '/samples/sp/'
+
+module ICU
+  class Tournament
+    def signature
+      [name, arbiter, rounds, start, players.size].join("|")
+    end
+  end
+  class Player
+    def signature
+      [
+        name, id, rating, points,
+        results.map{ |r| r.round }.join(''),
+        results.map{ |r| r.score }.join(''),
+        results.map{ |r| r.colour || "-" }.join(''),
+        results.map{ |r| r.rateable ? 'T' : 'F' }.join(''),
+      ].join("|")
+    end
+  end
+end
+
+module ICU
+  class Tournament
+    describe SwissPerfect do
+
+      context "Gonzaga Challengers 2010" do
+
+        before(:all) do
+          @p = ICU::Tournament::SwissPerfect.new
+          @t = @p.parse_file(SAMPLES + 'gonzaga_challengers_2010.trn', "2010-01-29")
+          @s = open(SAMPLES + 'gonzaga_challengers_2010.txt') { |f| f.read }
+        end
+
+        it "should parse and have the right basic details" do
+          @p.error.should be_nil
+          @t.signature.should == "Gonzaga Chess Classic 2010 Challengers Section|Herbert Scarry|6|2010-01-29|56"
+        end
+
+        it "should have correct details for selected players" do
+          @t.player(2).signature.should  == "Mullooly, Neil M.|6438|1083|6.0|123456|WWWWWW|WBWBWB|TTTTTT" # winner
+          @t.player(4).signature.should  == "Gallagher, Mark|12138|1036|4.0|123456|WLWWWL|WBWBWB|FTTTTT"  # had one bye
+          @t.player(45).signature.should == "Catre, Loredan||507|3.5|123456|WDLWLW|BWBWBW|FTTTFT"         # had two byes
+          @t.player(56).signature.should == "McDonnell, Cathal||498|0.0|1|L|-|F"                          # last
+        end
+        
+        it "should have the correct tie breaks" do
+          @t.tie_breaks.join('|').should == "buchholz|harkness"
+        end
+
+        it "should serialize to the text export format" do
+          @t.serialize('SwissPerfect').should == @s
+        end
+      end
+
+      context "U19 Junior Championships 2010" do
+
+        before(:all) do
+          @p = ICU::Tournament::SwissPerfect.new
+          @t = @p.parse_file(SAMPLES + 'junior_championships_u19_2010.sco', "2010-04-11")
+          @s = open(SAMPLES + 'junior_championships_u19_2010.txt') { |f| f.read }
+        end
+
+        it "should parse and have the right basic details" do
+          @p.error.should be_nil
+          @t.signature.should == "U - 19 All Ireland||3|2010-04-11|4"
+        end
+
+        it "should have correct details for selected players" do
+          @t.player(1).signature.should == "Griffiths, Ryan-Rhys|6897|2225|3.0|123|WWW|WWB|TTT"
+          @t.player(2).signature.should == "Flynn, Jamie|5226|1633|2.0|123|WLW|WBW|TTT"
+          @t.player(3).signature.should == "Hulleman, Leon|6409|1466|1.0|123|LWL|BBW|TTT"
+          @t.player(4).signature.should == "Dunne, Thomas|10914||0.0|123|LLL|BWB|TTT"
+        end
+        
+        it "should have the no tie breaks" do
+          @t.tie_breaks.join('|').should == ""
+        end
+
+        it "should serialize to the text export format" do
+          @t.rerank.renumber.serialize('SwissPerfect').should == @s
+        end
+      end
+
+      context "Limerick Club Championship 2009-10" do
+
+        before(:all) do
+          @p = ICU::Tournament::SwissPerfect.new
+          @t = @p.parse_file(SAMPLES + 'LimerickClubChampionship09.ini', "2009-09-15")
+        end
+
+        it "should parse and have the right basic details" do
+          @p.error.should be_nil
+          @t.signature.should == "Limerick Club Championship 2009||7|2009-09-15|19"
+        end
+
+        it "should have correct details for selected players" do
+          @t.player(15).signature.should == "Talazec, Laurent|10692|1570|5.5|1234567|WWWDDDW|WWBWBWB|FTTTTTT"  # winner
+          @t.player(6).signature.should  == "Foenander, Phillip|7168|1434|4.0|1234567|WLWLLWW|BWBWBWB|TTFFTTT" # had some byes
+          @t.player(19).signature.should == "Wall, Robert|||3.0|34567|WWLWL|WWBBW|FTTTT"                       # didn't play 1st 2 rounds
+          @t.player(17).signature.should == "Freeman, Conor|||2.0|1234567|DDLWLLL|--BWBWB|FFTTTTT"             # had byes and bonus (in BONUS)
+          @t.player(18).signature.should == "Freeman, Ruiri|||2.0|1234567|DDLLLLW|--WBBWB|FFTTTTF"             # had byes and bonus (in BONUS)
+          @t.player(16).signature.should == "O'Connor, David|||1.0|123|WLL|WBW|FTF"                            # last
+        end
+        
+        it "should have the correct tie breaks" do
+          @t.tie_breaks.join('|').should == "harkness|buchholz"
+        end
+      end
+
+      context "Junior Inter Provincials U16 2010" do
+
+        before(:all) do
+          @p = ICU::Tournament::SwissPerfect.new
+          @t = @p.parse_file(SAMPLES + 'junior_provincials_u16_2010', "2010-02-02")
+        end
+
+        it "should parse and have the right basic details" do
+          @p.error.should be_nil
+          @t.signature.should == "U16 Inter Provincials 2010|David B Murray|3|2010-02-02|18"
+        end
+
+        it "should have correct details for selected players" do
+          @t.player(15).signature.should == "Gupta, Radhika||1247|3.0|123|WWW|BBW|TTT"            # won all his games
+          @t.player(18).signature.should == "Hurley, Thomas|6292|820|1.0|1|W|B|F"                 # scored just 1 from a bye in R1
+          @t.player(8).signature.should  == "Berney, Mark|10328|1948|2.0|23|WW|BW|TT"             # didn't play in round 1
+          @t.player(10).signature.should == "O'Donnell, Conor E.|10792|1073|2.0|123|LWW|WBW|TFT"  # got just 1 point for a bye
+        end
+        
+        it "should have the correct tie breaks" do
+          @t.tie_breaks.join('|').should == "neustadtl"
+        end
+      end
+
+      context "Mulcahy Cup 2010" do
+
+        before(:all) do
+          @p = ICU::Tournament::SwissPerfect.new
+          @t = @p.parse_file(SAMPLES + 'mulcahy_2010', "2010-01-15")
+        end
+
+        it "should parse and have the right basic details" do
+          @p.error.should be_nil
+          @t.signature.should == "Mulcahy Cup 2010|Stephen Short|6|2010-01-15|50"
+        end
+
+        it "should have correct details for selection of players who got bonuses (in MEMO)" do
+          @t.player(23).signature.should == "Long, Killian|10293|1506|2.5|123456|WDLLWL|WWBWBB|TFTTTT"
+          @t.player(26).signature.should == "Bradley, Michael|6756|1413|3.0|123456|DDLWWL|BWWBWW|TFTTTT"
+          @t.player(15).signature.should == "Twomey, Pat|1637|1656|4.5|123456|WDLWWW|WWWBWB|FFTTTT"
+          @t.player(46).signature.should == "O'Riordan, Pat|10696|900|2.0|123456|LDDLDD|BWBWWB|TTTTFT"
+          @t.player(38).signature.should == "Gill, Craig I.|10637|1081|2.0|123456|LLWDDL|BWBWWB|TTTTFT"
+        end
+      end
+    end
+  end
+end

data/spec/tournament_spec.rb

@@ -262,6 +262,37 @@ EOS
         lambda { @t.time_control = 'abc' }.should raise_error(/invalid.*time.*control/)
       end
     end
+    
+    context "tie breaks" do
+      before(:each) do
+        @t = Tournament.new('Edinburgh Masters', '2009-11-09')
+      end
+      
+      it "should an empty tie breaks list by default" do
+        @t.tie_breaks.should be_an_instance_of(Array)
+        @t.tie_breaks.should be_empty
+      end
+      
+      it "should be settable to one or more valid tie break methods" do
+        @t.tie_breaks = [:neustadtl]
+        @t.tie_breaks.join('|').should == "neustadtl"
+        @t.tie_breaks = [:neustadtl, :blacks]
+        @t.tie_breaks.join('|').should == "neustadtl|blacks"
+        @t.tie_breaks = ['Wins', 'Sonneborn-Berger', :harkness]
+        @t.tie_breaks.join('|').should == "wins|neustadtl|harkness"
+        @t.tie_breaks = []
+        @t.tie_breaks.join('|').should == ""
+      end
+      
+      it "should rasie an error is not given an array" do
+        lambda { @t.tie_breaks = :neustadtl }.should raise_error(/array/i)
+      end
+      
+      it "should rasie an error is given any invalid tie-break methods" do
+        lambda { @t.tie_breaks = ["My Bum"] }.should raise_error(/invalid/i)
+        lambda { @t.tie_breaks = [:neustadtl, "Your arse"] }.should raise_error(/invalid/i)
+      end
+    end
 
     context "players" do
       before(:each) do
@@ -502,6 +533,13 @@ EOS
         @t.players.map{ |p| p.num }.join('|').should == '1|2|3'
         @t.players.map{ |p| p.last_name }.join('|').should == 'Fischer|Kasparov|Orr'
       end
+
+      it "should be renumberable by order" do
+        @t.rerank.renumber(:order)
+        @t.invalid.should be_false
+        @t.players.map{ |p| p.num }.join('|').should == '1|2|3'
+        @t.players.map{ |p| p.last_name }.join('|').should == 'Fischer|Orr|Kasparov'
+      end
     end
 
     context "reranking" do
@@ -545,7 +583,8 @@ EOS
       end
       
       it "should have correct Buchholz tie break scores" do
-        scores = @t.tie_break_scores("Buchholz")
+        @t.tie_breaks = ["Buchholz"]
+        scores = @t.tie_break_scores
         scores[1].should == 2.0
         scores[2].should == 2.5
         scores[3].should == 7.0
@@ -557,7 +596,8 @@ EOS
       it "Buchholz should be sensitive to unplayed games" do
         @t.player(1).find_result(1).opponent = nil
         @t.player(6).find_result(1).opponent = nil
-        scores = @t.tie_break_scores("Buchholz")
+        @t.tie_breaks = ["Buchholz"]
+        scores = @t.tie_break_scores
         scores[1].should == 1.5  # 0.5 from Orr changed to 0
         scores[2].should == 2.5  # didn't play Fischer or Orr so unaffected
         scores[3].should == 6.5  # 3 from Fischer's changed to 2.5
@@ -567,7 +607,8 @@ EOS
       end
       
       it "should have correct Neustadtl tie break scores" do
-        scores = @t.tie_break_scores(:neustadtl)
+        @t.tie_breaks = [:neustadtl]
+        scores = @t.tie_break_scores
         scores[1].should == 2.0
         scores[2].should == 2.5
         scores[3].should == 1.0
@@ -579,7 +620,8 @@ EOS
       it "Neustadtl should be sensitive to unplayed games" do
         @t.player(1).find_result(1).opponent = nil
         @t.player(6).find_result(1).opponent = nil
-        scores = @t.tie_break_scores("Neustadtl")
+        @t.tie_breaks = ["Neustadtl"]
+        scores = @t.tie_break_scores
         scores[1].should == 1.5  # 0.5 from Orr changed to 0
         scores[2].should == 2.5  # didn't play Fischer or Orr so unaffected
         scores[3].should == 1.0  # win against Minnie unaffected
@@ -589,7 +631,8 @@ EOS
       end
       
       it "should have correct Harkness tie break scores" do
-        scores = @t.tie_break_scores('harkness')
+        @t.tie_breaks = ['harkness']
+        scores = @t.tie_break_scores
         scores[1].should == 0.5
         scores[2].should == 1.0
         scores[3].should == 3.0
@@ -599,7 +642,8 @@ EOS
       end
       
       it "should have correct Modified Median tie break scores" do
-        scores = @t.tie_break_scores('Modified Median')
+        @t.tie_breaks = ['Modified Median']
+        scores = @t.tie_break_scores
         scores[1].should == 1.5
         scores[2].should == 2.0
         scores[3].should == 4.0
@@ -609,7 +653,8 @@ EOS
       end
       
       it "should have correct tie break scores for number of blacks" do
-        scores = @t.tie_break_scores('Blacks')
+        @t.tie_breaks = ['Blacks']
+        scores = @t.tie_break_scores
         scores[3].should == 0
         scores[4].should == 2
       end
@@ -617,13 +662,15 @@ EOS
       it "number of blacks should should be sensitive to unplayed games" do
         @t.player(2).find_result(1).opponent = nil
         @t.player(4).find_result(1).opponent = nil
-        scores = @t.tie_break_scores(:blacks)
+        @t.tie_breaks = [:blacks]
+        scores = @t.tie_break_scores
         scores[3].should == 0
         scores[4].should == 1
       end
       
       it "should have correct tie break scores for number of wins" do
-        scores = @t.tie_break_scores(:wins)
+        @t.tie_breaks = [:wins]
+        scores = @t.tie_break_scores
         scores[1].should == 3
         scores[6].should == 0
       end
@@ -631,7 +678,8 @@ EOS
       it "number of wins should should be sensitive to unplayed games" do
         @t.player(1).find_result(1).opponent = nil
         @t.player(6).find_result(1).opponent = nil
-        scores = @t.tie_break_scores('WINS')
+        @t.tie_breaks = ['WINS']
+        scores = @t.tie_break_scores
         scores[1].should == 2
         scores[6].should == 0
       end
@@ -647,7 +695,8 @@ EOS
       end
     
       it "should be configurable to use Buchholz" do
-        @t.rerank('Buchholz')
+        @t.tie_breaks = ['Buchholz']
+        @t.rerank
         @t.player(2).rank.should == 1  # 3.0/2.5
         @t.player(1).rank.should == 2  # 3.0/2.0
         @t.player(3).rank.should == 3  # 1.0/7.0
@@ -657,7 +706,8 @@ EOS
       end
       
       it "should be configurable to use Neustadtl" do
-        @t.rerank(:neustadtl)
+        @t.tie_breaks = [:neustadtl]
+        @t.rerank
         @t.player(2).rank.should == 1  # 3.0/2.5
         @t.player(1).rank.should == 2  # 3.0/2.0
         @t.player(3).rank.should == 3  # 1.0/1.0
@@ -667,7 +717,8 @@ EOS
       end
       
       it "should be configurable to use number of blacks" do
-        @t.rerank(:blacks)
+        @t.tie_breaks = [:blacks]
+        @t.rerank
         @t.player(2).rank.should == 1  # 3.0/2
         @t.player(1).rank.should == 2  # 3.0/1
         @t.player(4).rank.should == 3  # 1.0/2
@@ -677,7 +728,8 @@ EOS
       end
       
       it "should be configurable to use number of wins" do
-        @t.rerank(:wins)
+        @t.tie_breaks = [:wins]
+        @t.rerank
         @t.player(1).rank.should == 1  # 3.0/3/"Fi"
         @t.player(2).rank.should == 2  # 3.0/3/"Ka"
         @t.player(3).rank.should == 3  # 1.0/1/"Mic"
@@ -687,12 +739,14 @@ EOS
       end
       
       it "should exhibit equivalence between Neustadtl and Sonneborn-Berger" do
-        @t.rerank('Sonneborn-Berger')
+        @t.tie_breaks = ['Sonneborn-Berger']
+        @t.rerank
         (1..6).inject(''){ |t,r| t << @t.player(r).rank.to_s }.should == '213465'
       end
       
       it "should be able to use more than one method" do
-        @t.rerank(:neustadtl, :buchholz)
+        @t.tie_breaks = [:neustadtl, :buchholz]
+        @t.rerank
         @t.player(2).rank.should == 1  # 3.0/2.5
         @t.player(1).rank.should == 2  # 3.0/2.0
         @t.player(3).rank.should == 3  # 1.0/1.0
@@ -700,17 +754,10 @@ EOS
         @t.player(5).rank.should == 5  # 0.5/0.25/6.5
         @t.player(6).rank.should == 6  # 0.5/0.25/4.5
       end
-      
-      it "should throw exception on invalid tie break method" do
-        lambda { @t.rerank(:no_such_tie_break_method) }.should raise_error(/invalid.*method/)
-      end
-    
-      it "should throw exception on invalid tie break method via validation" do
-        lambda { @t.validate!(:rerank => :stupid_tie_break_method) }.should raise_error(/invalid.*method/)
-      end
     
       it "should be possible as a side effect of validation" do
-        @t.invalid(:rerank => :buchholz).should be_false
+        @t.tie_breaks = [:buchholz]
+        @t.invalid(:rerank => true).should be_false
         @t.player(2).rank.should == 1  # 3/3
         @t.player(1).rank.should == 2  # 3/2
         @t.player(3).rank.should == 3  # 1/7
@@ -720,7 +767,8 @@ EOS
       end
       
       it "should be possible as a side effect of validation with multiple tie break methods" do
-        @t.invalid(:rerank => [:neustadtl, :buchholz]).should be_false
+        @t.tie_breaks = [:neustadtl, :buchholz]
+        @t.invalid(:rerank => true).should be_false
         @t.player(2).rank.should == 1  # 3/3
         @t.player(1).rank.should == 2  # 3/2
         @t.player(3).rank.should == 3  # 1/7

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: icu_tournament
 version: !ruby/object:Gem::Version 
-  version: 0.9.6
+  version: 1.0.0
 platform: ruby
 authors: 
 - Mark Orr
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-04-18 00:00:00 +01:00
+date: 2010-05-14 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -22,6 +22,26 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: 1.4.0
     version: 
+- !ruby/object:Gem::Dependency 
+  name: inifile
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.3.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: dbf
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.2.5
+    version: 
 - !ruby/object:Gem::Dependency 
   name: rspec
   type: :development
@@ -50,6 +70,7 @@ files:
 - lib/icu_tournament/tournament.rb
 - lib/icu_tournament/tournament_fcsv.rb
 - lib/icu_tournament/tournament_krause.rb
+- lib/icu_tournament/tournament_sp.rb
 - lib/icu_tournament/util.rb
 - lib/icu_tournament/version.rb
 - lib/icu_tournament.rb
@@ -61,6 +82,7 @@ files:
 - spec/team_spec.rb
 - spec/tournament_fcsv_spec.rb
 - spec/tournament_krause_spec.rb
+- spec/tournament_sp_spec.rb
 - spec/tournament_spec.rb
 - spec/util_spec.rb
 - LICENCE
@@ -102,5 +124,6 @@ test_files:
 - spec/team_spec.rb
 - spec/tournament_fcsv_spec.rb
 - spec/tournament_krause_spec.rb
+- spec/tournament_sp_spec.rb
 - spec/tournament_spec.rb
 - spec/util_spec.rb