sanichi-chess_icu 0.2.10 → 0.3.0

data/README.rdoc

@@ -17,10 +17,11 @@ Tournament objects are created by parsing files of various formats. An instance
 with the file's contents as the only argument.
 
   require 'chess_icu'
-  data = open('tournament.csv') { |f| f.read }
+  data = open('tournament.txt') { |f| f.read }
+  parser = ICU::Tournament::Parser.new  # substitute the name of an available parser (see below) for "Parser"
   tournament = parser.parse(data)
 
-On success, the parse method returns an object of type ICU::Tournament. On error, it returns _nil_ and an error message
+On success, the _parse_ method returns an object of type ICU::Tournament. On error, it returns _nil_ and an error message
 can be retrieved from the parser instance:
 
   parser.error  # => error message or nil on success
@@ -29,14 +30,15 @@ Alternatively, if an exception is preferred on error, the <em>parse!</em> method
 
   tournament = parser.parse!(data)
 
-The file formats supported in the current version are:
+The currently available parsers are:
 
 * Foreign CSV (ICU::Tournament::ForeignCSV) - for players to report their individual results in foreign tournaments
+* Krause (ICU::Tournament::Krause) - the format used by FIDE
 
 
 == TODO
   
-Future versions of this software will be able to parse other types of files such as SwissPerfect and FIDE's Krause format.
+Future versions of this software will be able to parse additional file formats (such as SwissPerfect).
 
 
 == Author

data/Rakefile

@@ -34,6 +34,12 @@ Spec::Rake::SpecTask.new(:fcsv) do |spec|
   spec.spec_opts = ['--colour --format nested']
 end
 
+Spec::Rake::SpecTask.new(:krs) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/tournament_krause_spec.rb']
+  spec.spec_opts = ['--colour --format nested']
+end
+
 Rake::RDocTask.new(:rdoc) do |rdoc|
   if File.exist?('VERSION.yml')
     config = YAML.load(File.read('VERSION.yml'))

data/VERSION.yml

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

data/lib/chess_icu.rb

@@ -1,4 +1,9 @@
 # :enddoc:
+
+chess_icu_files = Array.new
+chess_icu_files.concat %w{util name federation}
+chess_icu_files.concat %w{player result tournament}
+chess_icu_files.concat %w{fcsv krause}.map{ |f| "tournament_#{f}"}
+
 dir = File.dirname(__FILE__)
-%w{util name player result tournament}.each { |file| require "#{dir}/#{file}" }
-%w{fcsv}.each                               { |file| require "#{dir}/tournament_#{file}" }
+chess_icu_files.each { |file| require "#{dir}/#{file}" }

data/lib/federation.rb

@@ -0,0 +1,272 @@
+module ICU
+
+=begin rdoc
+
+== Federations
+
+This class can be used to map a string into an object representing a chess federation.
+In FIDE, chess federations are generally either referred to by their full names such as
+_Ireland_ or _Russia_ or by three letter codes such as _IRL_ or _RUS_. The three letter
+codes are mostly the same as those found in the international standard known as
+{ISO 3166-1 alpha-3}[http://en.wikipedia.org/wiki/ISO_3166-1_alpha-3], but with
+some differences (e.g. for England, Scotland and Wales).
+
+You cannot directly create instances of this class using _new_. Instead, you supply
+a string to the class method _find_ and, if the string supplied uniguely identifies a
+federation, an instance is returned which responds to _name_ and _code_.
+
+  fed = ICU::Federation.find('IRL')
+  fed.name                                           # => "Ireland"
+  fed.code                                           # => "IRL"
+
+If the string is not sufficient to identify a federation, the _find_ method returns _nil_.
+
+  fed = ICU::Federation.find('ZYX')                  # => nil
+
+If the string is three letters long and matches (case insenstively) one of the unique
+federation codes, then the instance corresponding to that federation is returned.
+
+  ICU::Federation.find('rUs').code                   # => "RUS"
+
+If the string is more than three letters long and if it is a substring (case insensitive)
+of exactly one federation name, then that federation is returned.
+
+  ICU::Federation.find('ongoli').name                # => "Mongolia"
+
+In all other cases, nil is returned. In the following example, the string more than one federation.
+
+  ICU::Federation.find('land')                       # => nil
+
+The method is not fooled by irrelevant white space.
+
+  ICU::Federation.find('  united   states   ').code  # => 'USA'
+  
+=end
+
+  class Federation
+    attr_reader :code, :name
+    private_class_method :new
+    
+    # Given a code, name or part of a name, return the corresponding federation instance.
+    # If there is no match or more than one match, _nil_ is returned.
+    def self.find(str=nil)
+      return nil unless str
+      str = str.to_s
+      return nil if str.length < 3
+      compile unless @@objects
+      str = str.strip.squeeze(' ').downcase
+      return @@codes[str] if str.length == 3
+      return @@names[str] if @@names[str]
+      matches = Array.new
+      @@names.each_key do |name|
+        matches << @@names[name] if name.index(str)
+      end
+      matches.uniq!
+      return nil unless matches.length == 1
+      matches[0]
+    end
+    
+    def initialize(code, name) # :nodoc: because new is private
+      @code = code
+      @name = name
+    end
+    
+    private
+    
+    def self.compile
+      return if @@objects
+      @@names = Hash.new
+      @@codes = Hash.new
+      @@objects = Array.new
+      @@data.each do |d|
+        object = new(d[0], d[1])
+        @@objects << object
+        @@codes[d[0].downcase] = object
+        (1..d.length-1).each do |i|
+          @@names[d[i].downcase] = object
+        end
+      end
+    end
+    
+    # The data structures compiled.
+    @@objects, @@codes, @@names = nil, nil, nil
+    
+    # An array of data that gets compiled into other data structures.
+    @@data =
+    [
+      ['AFG', 'Afghanistan'],
+      ['ALB', 'Albania'],
+      ['ALG', 'Algeria'],
+      ['AND', 'Andorra'],
+      ['ANG', 'Angola'],
+      ['ANT', 'Antigua'],
+      ['ARG', 'Argentina'],
+      ['ARM', 'Armenia'],
+      ['ARU', 'Aruba'],
+      ['AUS', 'Australia'],
+      ['AUT', 'Austria'],
+      ['AZE', 'Azerbaijan'],
+      ['BAH', 'Bahamas'],
+      ['BRN', 'Bahrain'],
+      ['BAN', 'Bangladesh'],
+      ['BAR', 'Barbados'],
+      ['BLR', 'Belarus'],
+      ['BEL', 'Belgium'],
+      ['BIZ', 'Belize'],
+      ['BEN', 'Benin Republic'],
+      ['BER', 'Bermuda'],
+      ['BHU', 'Bhutan'],
+      ['BOL', 'Bolivia'],
+      ['BIH', 'Bosnia and Herzegovina'],
+      ['BOT', 'Botswana'],
+      ['BRA', 'Brazil'],
+      ['IVB', 'British Virgin Islands'],
+      ['BRU', 'Brunei Darussalam'],
+      ['BUL', 'Bulgaria'],
+      ['BUR', 'Burkina Faso'],
+      ['BDI', 'Burundi'],
+      ['CAM', 'Cambodia'],
+      ['CMR', 'Cameroon'],
+      ['CAN', 'Canada'],
+      ['CHA', 'Chad'],
+      ['CHI', 'Chile'],
+      ['CHN', 'China'],
+      ['TPE', 'Chinese Taipei'],
+      ['COL', 'Colombia'],
+      ['CRC', 'Costa Rica'],
+      ['CRO', 'Croatia'],
+      ['CUB', 'Cuba'],
+      ['CYP', 'Cyprus'],
+      ['CZE', 'Czech Republic'],
+      ['DEN', 'Denmark'],
+      ['DJI', 'Djibouti'],
+      ['DOM', 'Dominican Republic'],
+      ['ECU', 'Ecuador'],
+      ['EGY', 'Egypt'],
+      ['ESA', 'El Salvador'],
+      ['ENG', 'England'],
+      ['EST', 'Estonia'],
+      ['ETH', 'Ethiopia'],
+      ['FAI', 'Faroe Islands'],
+      ['FIJ', 'Fiji'],
+      ['FIN', 'Finland'],
+      ['FRA', 'France'],
+      ['GAB', 'Gabon'],
+      ['GAM', 'Gambia'],
+      ['GEO', 'Georgia'],
+      ['GER', 'Germany'],
+      ['GHA', 'Ghana'],
+      ['GRE', 'Greece'],
+      ['GUA', 'Guatemala'],
+      ['GCI', 'Guernsey'],
+      ['GUY', 'Guyana'],
+      ['HAI', 'Haiti'],
+      ['HON', 'Honduras'],
+      ['HKG', 'Hong Kong'],
+      ['HUN', 'Hungary'],
+      ['ISL', 'Iceland'],
+      ['IND', 'India'],
+      ['INA', 'Indonesia'],
+      ['IRI', 'Iran'],
+      ['IRQ', 'Iraq'],
+      ['IRL', 'Ireland'],
+      ['ISR', 'Israel'],
+      ['ITA', 'Italy'],
+      ['CIV', 'Ivory Coast'],
+      ['JAM', 'Jamaica'],
+      ['JPN', 'Japan'],
+      ['JCI', 'Jersey'],
+      ['JOR', 'Jordan'],
+      ['KAZ', 'Kazakhstan'],
+      ['KEN', 'Kenya'],
+      ['KUW', 'Kuwait'],
+      ['KGZ', 'Kyrgyzstan'],
+      ['LAT', 'Latvia'],
+      ['LIB', 'Lebanon'],
+      ['LBA', 'Libya'],
+      ['LIE', 'Liechtenstein'],
+      ['LTU', 'Lithuania'],
+      ['LUX', 'Luxembourg'],
+      ['MAC', 'Macau'],
+      ['MKD', 'Macedonia', 'Former YUG Rep of Macedonia', 'Former Yugoslav Republic of Macedonia', 'FYROM'],
+      ['MAD', 'Madagascar'],
+      ['MAW', 'Malawi'],
+      ['MAS', 'Malaysia'],
+      ['MDV', 'Maldives'],
+      ['MLI', 'Mali'],
+      ['MLT', 'Malta'],
+      ['MAU', 'Mauritania'],
+      ['MRI', 'Mauritius'],
+      ['MEX', 'Mexico'],
+      ['MDA', 'Moldova'],
+      ['MNC', 'Monaco'],
+      ['MGL', 'Mongolia'],
+      ['MNE', 'Montenegro'],
+      ['MAR', 'Morocco'],
+      ['MOZ', 'Mozambique'],
+      ['MYA', 'Myanmar'],
+      ['NAM', 'Namibia'],
+      ['NEP', 'Nepal'],
+      ['NED', 'Netherlands'],
+      ['AHO', 'Netherlands Antilles'],
+      ['NZL', 'New Zealand'],
+      ['NCA', 'Nicaragua'],
+      ['NGR', 'Nigeria'],
+      ['NOR', 'Norway'],
+      ['PAK', 'Pakistan'],
+      ['PLW', 'Palau'],
+      ['PLE', 'Palestine'],
+      ['PAN', 'Panama'],
+      ['PNG', 'Papua New Guinea'],
+      ['PAR', 'Paraguay'],
+      ['PER', 'Peru'],
+      ['PHI', 'Philippines'],
+      ['POL', 'Poland'],
+      ['POR', 'Portugal'],
+      ['PUR', 'Puerto Rico'],
+      ['QAT', 'Qatar'],
+      ['ROU', 'Romania'],
+      ['RUS', 'Russia'],
+      ['RWA', 'Rwanda'],
+      ['SMR', 'San Marino'],
+      ['STP', 'Sao Tome and Principe'],
+      ['SCO', 'Scotland'],
+      ['SEN', 'Senegal'],
+      ['SRB', 'Serbia'],
+      ['SEY', 'Seychelles'],
+      ['SIN', 'Singapore'],
+      ['SVK', 'Slovakia'],
+      ['SLO', 'Slovenia'],
+      ['SOM', 'Somalia'],
+      ['RSA', 'South Africa'],
+      ['KOR', 'South Korea'],
+      ['ESP', 'Spain'],
+      ['SRI', 'Sri Lanka'],
+      ['SUD', 'Sudan'],
+      ['SUR', 'Surinam'],
+      ['SWE', 'Sweden'],
+      ['SUI', 'Switzerland'],
+      ['SYR', 'Syria'],
+      ['TJK', 'Tajikistan'],
+      ['TAN', 'Tanzania'],
+      ['THA', 'Thailand'],
+      ['TRI', 'Trinidad and Tobago'],
+      ['TUN', 'Tunisia'],
+      ['TUR', 'Turkey'],
+      ['TKM', 'Turkmenistan'],
+      ['UGA', 'Uganda'],
+      ['UKR', 'Ukraine'],
+      ['UAE', 'United Arab Emirates'],
+      ['USA', 'United States of America'],
+      ['URU', 'Uruguay'],
+      ['ISV', 'US Virgin Islands'],
+      ['UZB', 'Uzbekistan'],
+      ['VEN', 'Venezuela'],
+      ['VIE', 'Vietnam'],
+      ['WLS', 'Wales'],
+      ['YEM', 'Yemen'],
+      ['ZAM', 'Zambia'],
+      ['ZIM', 'Zimbabwe'],
+    ]
+  end
+end

data/lib/player.rb

@@ -132,10 +132,9 @@ All other attributes are unaffected.
     
     # Federation. Is either unknown (nil) or a string containing at least three letters.
     def fed=(fed)
-      @fed = fed.to_s.strip
-      @fed.upcase! if @fed.length == 3
-      @fed = nil if @fed == ''
-      raise "invalid federation (#{fed})" unless @fed.nil? || @fed.match(/[a-z]{3}/i)
+      obj = Federation.find(fed)
+      @fed = obj ? obj.code : nil
+      raise "invalid federation (#{fed})" if @fed.nil? && fed.to_s.strip.length > 0
     end
     
     # Chess title. Is either unknown (nil) or one of: _GM_, _IM_, _FM_, _CM_, _NM_,
@@ -143,6 +142,8 @@ All other attributes are unaffected.
     def title=(title)
       @title = title.to_s.strip.upcase
       @title << 'M' if @title.match(/[A-LN-Z]$/)
+      @title = 'IM' if @title == 'M'
+      @title = 'WIM' if @title == 'WM'
       @title = nil if @title == ''
       raise "invalid chess title (#{title})" unless @title.nil? || @title.match(/^W?[GIFCN]M$/)
     end
@@ -184,11 +185,13 @@ All other attributes are unaffected.
       raise "invalid gender (#{gender})" unless @gender.nil? || @gender.match(/^[MF]$/)
     end
     
-    # Add a result. Use the same name method in ICU::Tournament instead.
+    # Add a result. Don't use this method directly - use ICU::Tournament#add_result instead.
     def add_result(result)
       raise "invalid result" unless result.class == ICU::Result
       raise "player number (#{@num}) is not matched to result player number (#{result.player})" unless @num == result.player
-      raise "round number (#{result.round}) of new result should be unique" unless @results.map { |r| r.round }.grep(result.round).size == 0
+      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
     end
     

data/lib/result.rb

@@ -178,5 +178,12 @@ The _points_ read-only accessor always returns a floating point number: either 0
       end
       true
     end
+    
+    # Strict equality. True if the there's loose equality and also the rateablity is the same.
+    def eql?(other)
+      return true if equal?(other)
+      return false unless self == other
+      self.rateable == other.rateable
+    end
   end
 end

data/lib/tournament.rb

@@ -21,7 +21,7 @@ firstly adding all the players and then adding all the results.
   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'))
 
-  [10, 20, 30].each { |n| puts "#{t.player(n).points} #{t.player(n).name}" }
+  [10, 20, 30].each { |n| p = t.player(n); puts "#{p.points} #{p.name}" }
 
 Would result in the following output.
 
@@ -63,16 +63,11 @@ raise an exception if the players it references through their tournament numbers
       end
     end
     
-    # Set the tournament federation. Can be _nil.
+    # Set the tournament federation. Can be _nil_.
     def fed=(fed)
-      fed = fed.to_s.strip
-      if fed == ''
-        @fed = nil
-      else
-        raise "invalid tournament federation (#{fed})" unless fed.match(/^[-a-z ]+/i) && fed.length >= 3
-        fed.upcase! if fed.length == 3
-        @fed = fed
-      end
+      obj = Federation.find(fed)
+      @fed = obj ? obj.code : nil
+      raise "invalid tournament federation (#{fed})" if @fed.nil? && fed.to_s.strip.length > 0
     end
     
     # Set a start date in yyyy-mm-dd format.
@@ -180,5 +175,53 @@ raise an exception if the players it references through their tournament numbers
         @player[result.opponent].add_result(reverse)
       end
     end
+    
+    # Return true if the players ranking is consistent, false otherwise.
+    # The players ranking is consistent if:
+    # * every player has a rank
+    # * no two players have the same rank
+    # * the highest rank is 1
+    # * the lowest rank is equal to the total of players
+    def ranking_consistent?
+      # No two players can have the same rank.
+      ranks = Hash.new
+      @player.values.each do |p|
+        if p.rank
+          return false if ranks[p.rank]
+          ranks[p.rank] = p
+        end
+      end
+      
+      # Every player has to have a rank.
+      return false unless ranks.size == @player.size
+
+      # The higest and lowest ranks respectively should be 1 and the number of players.
+      by_rank = @player.values.sort{ |a,b| a.rank <=> b.rank}
+      return false unless by_rank[0].rank == 1
+      return false unless by_rank[-1].rank == ranks.size
+      
+      # If scores are ordered by ranks, they should go from highest to lowest.
+      if by_rank.size > 1
+        (1..by_rank.size-1).each do |i|
+          p1 = by_rank[i-1]
+          p2 = by_rank[i]
+          return false if p1.points < p2.points
+        end
+      end
+      
+      true
+    end
+    
+    # Rerank the tournament.
+    def rerank
+      @player.values.map{ |p| [p, p.points] }.sort do |a,b|
+        d = b[1] <=> a[1]
+        d = a[0].last_name <=> b[0].last_name if d == 0
+        d = a[0].first_name <=> b[0].first_name if d == 0
+        d
+      end.each_with_index do |v,i|
+        v[0].rank = i + 1
+      end
+    end
   end
 end

data/lib/tournament_krause.rb

@@ -0,0 +1,296 @@
+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
+  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.rounds                 # => 3
+  tournament.fed                    # => "IRL"
+  tournament.players.size           # => 9
+  
+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"
+
+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. 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.
+
+  krause = parser.serialize(tournament)
+
+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]                   Not implemented yet.
+[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 _yyyy-mm-dd_ format, but setter can use any reasonable date format. Start date is mandadory.
+[052 End date]                Get or set with _finish_. Returns either _yyyy-mm-dd_ 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]             Not implemented yet.
+
+=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_comment                       # team name and members (not implemented yet)
+              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_comment                       # round dates (not implemented yet)
+              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
+        
+        # Validate the data now that we have everything.
+        validate
+        
+        @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.players.each{ |p| krause << p.to_krause(@tournament.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_comment
+        @comments << @line
+        @comments << "\n"
+      end
+      
+      def validate
+        # Certain attributes are mandatory.
+        raise "tournament name missing"       unless @name_set
+        raise "tournament start date missing" unless @start_set
+        
+        # There must be at least two players.
+        raise "minimum number of players is 2" if @tournament.players.length < 2
+        
+        # Every player must have at least one result.
+        @tournament.players.each { |p| raise "player #{p.num} has no results" if p.results.size == 0 }
+        
+        # Rerank the tournament if there are no ranking values or if there are but they're not consistent.
+        @tournament.rerank unless @tournament.ranking_consistent?
+
+        # Set the number of rounds.
+        @tournament.rounds = @tournament.players.inject(0) do |pa, p|
+          pm = p.results.inject(0){ |ra, r| ra < r.round ? r.round : ra }
+          pa < pm ? pm : pa
+        end
+      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': 'm'; when 'F': 'w'; else ''; end)
+      krause << sprintf(' %2s', case @title; when nil: ''; when 'IM': 'm'; when 'WIM': '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': '1'; when 'L': '0'; else '='; end if  @rateable
+      krause << case @score; when 'W': '+'; when 'L': '-'; else '='; end if !@rateable
+      krause
+    end
+  end
+end

data/spec/federation_spec.rb

@@ -0,0 +1,117 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+module ICU
+  describe Federation do
+    context "#find using codes" do
+      it "should find a federation given a valid code" do
+        fed = Federation.find('IRL')
+        fed.code.should == 'IRL'
+        fed.name.should == 'Ireland'
+      end
+      
+      it "should find a federation from code case insensitively" do
+        fed = Federation.find('rUs')
+        fed.code.should == 'RUS'
+        fed.name.should == 'Russia'
+      end
+      
+      it "should find a federation despite irrelevant whitespace" do
+        fed = Federation.find('  mex    ')
+        fed.code.should == 'MEX'
+        fed.name.should == 'Mexico'
+      end
+      
+      it "should return nil for an invalid code" do
+        Federation.find('XYZ').should be_nil
+      end
+    end
+    
+    context "#find using names" do
+      it "should find a federation given a valid name" do
+        fed = Federation.find('England')
+        fed.code.should == 'ENG'
+        fed.name.should == 'England'
+      end
+      
+      it "should find a federation from name case insensitively" do
+        fed = Federation.find('franCE')
+        fed.code.should == 'FRA'
+        fed.name.should == 'France'
+      end
+      
+      it "should not be fooled by irrelevant whitespace" do
+        fed = Federation.find(' united  states  of  america ')
+        fed.code.should == 'USA'
+        fed.name.should == 'United States of America'
+      end
+      
+      it "should return nil for an invalid name" do
+        Federation.find('Mordor').should be_nil
+      end
+    end
+    
+    context "#find using parts of names" do
+      it "should find a federation given a substring which is unique and at least 4 characters" do
+        fed = Federation.find('bosni')
+        fed.code.should == 'BIH'
+        fed.name.should == 'Bosnia and Herzegovina'
+      end
+      
+      it "should not be fooled by irrelevant whitespace" do
+        fed = Federation.find('  arab    EMIRATES   ')
+        fed.code.should == 'UAE'
+        fed.name.should == 'United Arab Emirates'
+      end
+      
+      it "should not find a federation if the substring matches more than one" do
+        Federation.find('land').should be_nil
+      end
+      
+      it "should return nil for any string smaller in length than 3" do
+        Federation.find('ze').should be_nil
+      end
+    end
+    
+    context "#find federations with alternative names" do
+      it "should find Macedonia multiple ways" do
+        Federation.find('MKD').name.should == 'Macedonia'
+        Federation.find('FYROM').name.should == 'Macedonia'
+        Federation.find('macedoni').name.should == 'Macedonia'
+        Federation.find('Macedonia').name.should == 'Macedonia'
+        Federation.find('former YUG Rep').name.should == 'Macedonia'
+        Federation.find('Republic of Macedonia').name.should == 'Macedonia'
+        Federation.find('former yugoslav republic').name.should == 'Macedonia'
+      end
+    end
+      
+    context "#find with alternative inputs" do
+      it "should behave robustly with completely invalid inputs" do
+        Federation.find().should be_nil
+        Federation.find(nil).should be_nil
+        Federation.find('').should be_nil
+        Federation.find(1).should be_nil
+      end
+    end
+    
+    context "#new is private" do
+      it "#new cannot be called directly" do
+        lambda { Federation.new('IRL', 'Ireland') }.should raise_error(/private method/)
+      end
+    end
+    
+    context "documentation examples" do
+      it "should all be correct for valid input" do
+        ICU::Federation.find('IRL').name.should == 'Ireland'
+        ICU::Federation.find('IRL').code.should == 'IRL'
+        ICU::Federation.find('rUs').code.should == 'RUS'
+        ICU::Federation.find('ongoli').name.should == 'Mongolia'
+        ICU::Federation.find('  united   states   ').code.should == 'USA'
+      end
+      
+      it "should return nil for invalid input" do
+        ICU::Federation.find('ZYX').should be_nil
+        ICU::Federation.find('land').should be_nil
+      end
+    end
+  end
+end

data/spec/player_spec.rb

@@ -83,7 +83,7 @@ module ICU
 
       it "should consist of at least three letters" do
         Player.new('Gary', 'Kasparov', 1, :fed => 'RUS').fed.should == 'RUS'
-        Player.new('Mark', 'Orr', 3, :fed => ' Ireland ').fed.should == 'Ireland'
+        Player.new('Mark', 'Orr', 3, :fed => ' Ireland ').fed.should == 'IRL'
         lambda { Player.new('Danny', 'Kopec', 3, :fed => 'US') }.should raise_error(/invalid federation/)
       end
     end
@@ -97,9 +97,11 @@ module ICU
       it "should be one of national, candidate, FIDE, international or grand master" do
         Player.new('Gary', 'Kasparov', 1, :title => 'GM').title.should == 'GM'
         Player.new('Mark', 'Orr', 2, :title => ' im ').title.should == 'IM'
+        Player.new('Mark', 'Quinn', 2, :title => 'm').title.should == 'IM'
         Player.new('Pia', 'Cramling', 3, :title => ' wg ').title.should == 'WGM'
         Player.new('Philip', 'Short', 4, :title => 'F ').title.should == 'FM'
         Player.new('Gearoidin', 'Ui Laighleis', 5, :title => 'wc').title.should == 'WCM'
+        Player.new('Gearoidin', 'Ui Laighleis', 7, :title => 'wm').title.should == 'WIM'
         Player.new('Eamon', 'Keogh', 6, :title => 'nm').title.should == 'NM'
         lambda { Player.new('Mark', 'Orr', 3, :title => 'Dr') }.should raise_error(/invalid chess title/)
       end

data/spec/result_spec.rb

@@ -150,6 +150,7 @@ module ICU
       end
       
       it "should be equal if the round, player numbers, result and colour all match" do
+        (@r1 == @r1).should be_true
         (@r1 == @r2).should be_true
       end
       
@@ -161,5 +162,21 @@ module ICU
         (@r1 == @r7).should be_false
       end
     end
+    
+    context "strict equality" do
+      before(:each) do
+        @r1 = Result.new(1, 1, 0, :opponent => 2, :colour => 'W')
+        @r2 = Result.new(1, 1, 0, :opponent => 2, :colour => 'W')
+        @r3 = Result.new(1, 1, 0, :opponent => 2, :colour => 'W', :rateable => false)
+        @r4 = Result.new(2, 1, 0, :opponent => 2, :colour => 'W')
+      end
+      
+      it "should only be equal if everything is the same" do
+        @r1.eql?(@r1).should be_true
+        @r1.eql?(@r2).should be_true
+        @r1.eql?(@r3).should be_false
+        @r1.eql?(@r4).should be_false
+      end
+    end
   end
 end

data/spec/tournament_krause_spec.rb

@@ -0,0 +1,287 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+module ICU
+  class Tournament
+    describe Krause do
+      def check_player(num, first, last, other={})
+        p = @t.player(num)
+        p.first_name.should == first
+        p.last_name.should  == last
+        p.gender.should     == other[:gender]
+        p.title.should      == other[:title]
+        p.rating.should     == other[:rating]
+        p.fed.should        == other[:fed]
+        p.id.should         == other[:id]
+        p.dob.should        == other[:dob]
+        p.rank.should       == other[:rank]
+      end
+      
+      def check_results(num, results, points)
+        p = @t.player(num)
+        p.results.size.should == results
+        p.points.should == points
+      end
+      
+      context "a typical tournament" do
+        before(:all) do
+          krause = <<KRAUSE
+012 Las Vegas National Open
+022 Las Vegas
+032 USA
+042 2008.06.07
+052 2008.06.10
+062 3
+072 3
+082 1
+092 All-Play-All
+102 Hans Scmidt
+112 Gerry Graham, Herbert Scarry
+122 60 in 2hr, 30 in 1hr, rest in 1hr
+013 Coaching Team                      1    2
+0         1         2         3         4         5         6         7         8         9         0         1         2
+0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890
+132                                                                                        08.02.01  08.02.02  08.02.03
+001    1 w    Ui Laighleis,Gearoidin            1985 IRL     2501171 1964.06.10  1.0    2     2 b 0     3 w 1          
+001    2 m  m Orr,Mark                          2258 IRL     2500035 1955.11.09  2.0    1     1 w 1               3 b 1
+001    3 m  g Bologan,Viktor                    2663 MDA    13900048 1971.01.01  0.0    3               1 b 0     2 w 0
+KRAUSE
+          @p = Krause.new
+          @t = @p.parse!(krause)
+        end
+        
+        it "should have a name, city and federation" do
+          @t.name.should == 'Las Vegas National Open'
+          @t.city.should == 'Las Vegas'
+          @t.fed.should  == 'USA'
+        end
+        
+        it "should have start and end dates" do
+          @t.start.should  == '2008-06-07'
+          @t.finish.should == '2008-06-10'
+        end
+        
+        it "should have a number of rounds, a type and a time control" do
+          @t.rounds.should       == 3
+          @t.type.should         == 'All-Play-All'
+          @t.time_control.should == '60 in 2hr, 30 in 1hr, rest in 1hr'
+        end
+        
+        it "should have an arbiter and deputies" do
+          @t.arbiter.should == 'Hans Scmidt'
+          @t.deputy.should  == 'Gerry Graham, Herbert Scarry'
+        end
+        
+        it "should have players and their details" do
+          @t.should have(3).players
+          check_player(1, 'Gearoidin', 'Ui Laighleis', :gender => 'F', :rating => 1985, :fed => 'IRL', :id =>  2501171, :dob => '1964-06-10', :rank => 2)
+          check_player(2, 'Mark', 'Orr',               :gender => 'M', :rating => 2258, :fed => 'IRL', :id =>  2500035, :dob => '1955-11-09', :rank => 1, :title => 'IM')
+          check_player(3, 'Viktor', 'Bologan',         :gender => 'M', :rating => 2663, :fed => 'MDA', :id => 13900048, :dob => '1971-01-01', :rank => 3, :title => 'GM')
+        end
+        
+        it "should have correct results for each player" do
+          check_results(1, 2, 1.0)
+          check_results(2, 2, 2.0)
+          check_results(3, 2, 0.0)
+        end
+        
+        it "the parser should retain comment lines" do
+          comments = <<COMMENTS
+062 3
+072 3
+082 1
+013 Coaching Team                      1    2
+0         1         2         3         4         5         6         7         8         9         0         1         2
+0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890
+132                                                                                        08.02.01  08.02.02  08.02.03
+COMMENTS
+          @p.comments.should == comments
+        end
+      end
+      
+      context "the documentation example" do
+        before(:all) do
+          krause = <<KRAUSE
+012 Fantasy Tournament
+032 IRL
+042 2009.09.09
+0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890
+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
+KRAUSE
+          @p = Krause.new
+          @t = @p.parse!(krause)
+        end
+
+        it "should have a name and federation" do
+          @t.name.should == 'Fantasy Tournament'
+          @t.fed.should  == 'IRL'
+        end
+
+        it "should have a startdates" do
+          @t.start.should  == '2009-09-09'
+        end
+
+        it "should have a number of rounds" do
+          @t.rounds.should       == 3
+        end
+
+        it "should have players and their details" do
+          @t.should have(3).players
+          check_player(1, 'Minerva', 'Mouse', :gender => 'F', :rating => 1900, :fed => 'USA', :id => 1234567, :dob => '1928-05-15', :rank => 2)
+          check_player(2, 'Daffy',   'Duck',  :gender => 'M', :rating => 2200, :fed => 'IRL', :id => 7654321, :dob => '1937-04-17', :rank => 1, :title => 'IM')
+          check_player(3, 'Mickey',  'Mouse', :gender => 'M', :rating => 2600, :fed => 'USA', :id => 1726354, :dob => '1928-05-15', :rank => 3, :title => 'GM')
+        end
+
+        it "should have correct results for each player" do
+          check_results(1, 2, 1.0)
+          check_results(2, 2, 2.0)
+          check_results(3, 2, 0.0)
+        end
+
+        it "the parser should retain comment lines" do
+          @p.comments.should == "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890\n"
+        end
+      end
+      
+      context "serialisation" do
+        before(:all) do
+          @krause = <<KRAUSE
+012 Las Vegas National Open
+022 Las Vegas
+032 USA
+042 2008-06-07
+052 2008-06-10
+092 All-Play-All
+102 Hans Scmidt
+112 Gerry Graham, Herbert Scarry
+122 60 in 2hr, 30 in 1hr, rest in 1hr
+001    1 w    Ui Laighleis,Gearoidin            1985 IRL     2501171 1964-06-10  2.0    2     2 b 0     3 w +     4 b 1
+001    2 m  m Orr,Mark                          2258 IRL     2500035 1955-11-09  2.5    1     1 w 1  0000 - =     3 b 1
+001    3 m  g Bologan,Viktor                    2663 MDA    13900048 1971-01-01  0.0    4               1 b -     2 w 0
+001    4   wg Cramling,Pia                      2500 SWE     1700030 1963-04-23  0.5    3            0000 - =     1 w 0
+KRAUSE
+          @p = Krause.new
+          @t = @p.parse!(@krause)
+        end
+
+        it "should serialize back to the original if the input is fully canonicalised" do
+          @p.serialize(@t).should == @krause
+        end
+
+        it "should return nil on invalid input" do
+          @p.serialize('Rubbish').should be_nil
+        end
+      end
+
+      context "auto-ranking" do
+        before(:all) do
+          @krause = <<KRAUSE
+012 Las Vegas National Open
+042 2008-06-07
+001    1 w    Ui Laighleis,Gearoidin            1985 IRL     2501171 1964-06-10  1.0          2 b 0     3 w 1
+001    2 m  m Orr,Mark                          2258 IRL     2500035 1955-11-09  2.0          1 w 1               3 b 1
+001    3 m  g Bologan,Viktor                    2663 MDA    13900048 1971-01-01  0.0                    1 b 0     2 w 0
+KRAUSE
+          @p = Krause.new
+          @t = @p.parse!(@krause)
+        end
+
+        it "should have rankings automatically set" do
+          @t.player(1).rank.should == 2
+          @t.player(2).rank.should == 1
+          @t.player(3).rank.should == 3
+        end
+      end
+
+      context "errors" do
+        before(:each) do
+          @k = <<KRAUSE
+012 Gonzaga Classic
+022 Dublin
+032 IRL
+042 2008-02-01
+052 2008-02-03
+062 12
+092 Swiss
+102 Michael Germaine, mlgermaine@eircom.net
+122 120 minutes per player per game
+001    1      Griffiths,Ryan Rhys                    IRL     2502054             4.0    1  0000 - =     3 b 1     8 w 1     5 b =     7 w 1
+001    2      Hotak,Marian                           SVK    14909677             3.5    2     3 w 0     6 b =    11 w 1     8 b 1     5 w 1
+001    3      Duffy,Seamus                           IRL                         3.0    3     2 b 1     1 w 0     4 w 1     6 b =     8 w =
+001    4      Cafolla,Peter                          IRL     2500884             3.0    4     7 b 1     5 w =     3 b 0    11 b +     6 w =
+001    5      Ferry,Edward                           SCO     2461587             3.0    5    10 b 1     4 b =     9 w 1     1 w =     2 b 0
+001    6      Boyle,Bernard                          IRL     2501830             3.0    6    12 b =     2 w =    10 b 1     3 w =     4 b =
+001    7      McCarthy,Tim                           IRL     2500710             2.5    7     4 w 0    10 w =    12 b +     9 b 1     1 b 0
+001    8      Benson,Oisin P.                        IRL     2501821             2.0    8  0000 - =    11 w 1     1 b 0     2 w 0     3 b =
+001    9      Murray,David B.                        IRL     2501511             2.0    9    11 b =    12 w +     5 b 0     7 w 0    10 w =
+001   10      Moser,Philippe                         SUI     1308041             1.5   10     5 w 0     7 b =     6 w 0  0000 - =     9 b =
+001   11      Barbosa,Paulo                          POR     1904612             1.5   11     9 w =     8 b 0     2 b 0     4 w -  0000 - +
+001   12      McCabe,Darren                          IRL     2500760             0.5   12     6 w =     9 b -     7 w -
+KRAUSE
+          @p = Krause.new
+        end
+
+        it "the unaltered example is valid Krause" do
+          t = @p.parse(@k).should be_instance_of(Tournament)
+        end
+
+        it "removing the line on which the tournament name is specified should cause an error" do
+          @k.sub!('012 Gonzaga Classic', '')
+          lambda { t = @p.parse!(@k) }.should raise_error(/name missing/)
+        end
+
+        it "blanking the tournament name should cause an error" do
+          @k.sub!('Gonzaga Classic', '')
+          lambda { t = @p.parse!(@k) }.should raise_error(/name missing/)
+        end
+
+        it "blanking the start date should cause an error" do
+          @k.sub!('2008-02-01', '')
+          lambda { t = @p.parse!(@k) }.should raise_error(/start date missing/)
+        end
+
+        it "creating a duplicate player number should cause an error" do
+          @k.sub!('  2  ', '  1  ')
+          lambda { t = @p.parse!(@k) }.should raise_error(/player number/)
+        end
+
+        it "creating a duplicate rank number should not cause an error becuse the tournament will be reranked" do
+          @k.sub!('4.0    1', '4.0    2')
+          t = @p.parse!(@k)
+          t.player(1).rank.should == 1
+        end
+
+        it "referring to a non-existant player number should cause an error" do
+           @k.sub!(' 3 b 1', '33 b 1')
+           lambda { t = @p.parse!(@k) }.should raise_error(/opponent number/)
+        end
+
+        it "inconsistent colours should cause an error" do
+           @k.sub!('3 b 1', '3 w 1')
+           lambda { t = @p.parse!(@k) }.should raise_error(/result/)
+        end
+
+        it "inconsistent scores should cause an error" do
+           @k.sub!('3 b 1', '3 b =')
+           lambda { t = @p.parse!(@k) }.should raise_error(/result/)
+        end
+
+        it "inconsistent totals should cause an error" do
+           @k.sub!('4.0', '4.5')
+           lambda { t = @p.parse!(@k) }.should raise_error(/total/)
+        end
+
+        it "invalid federations should cause an error" do
+           @k.sub!('SCO', 'XYZ')
+           lambda { t = @p.parse!(@k) }.should raise_error(/federation/)
+        end
+
+        it "removing any player that somebody else has played should cause an error" do
+           @k.sub!(/^001   12.*$/, '')
+           lambda { t = @p.parse!(@k) }.should raise_error(/opponent/)
+        end
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: sanichi-chess_icu
 version: !ruby/object:Gem::Version 
-  version: 0.2.10
+  version: 0.3.0
 platform: ruby
 authors: 
 - Mark Orr
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-04-26 00:00:00 -07:00
+date: 2009-05-04 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -38,17 +38,21 @@ files:
 - Rakefile
 - VERSION.yml
 - lib/chess_icu.rb
+- lib/federation.rb
 - lib/name.rb
 - lib/player.rb
 - lib/result.rb
 - lib/tournament.rb
 - lib/tournament_fcsv.rb
+- lib/tournament_krause.rb
 - lib/util.rb
+- spec/federation_spec.rb
 - spec/name_spec.rb
 - spec/player_spec.rb
 - spec/result_spec.rb
 - spec/spec_helper.rb
 - spec/tournament_fcsv_spec.rb
+- spec/tournament_krause_spec.rb
 - spec/tournament_spec.rb
 - spec/util_spec.rb
 has_rdoc: true
@@ -78,10 +82,12 @@ signing_key:
 specification_version: 2
 summary: For parsing files of chess tournament data into ruby classes.
 test_files: 
+- spec/federation_spec.rb
 - spec/name_spec.rb
 - spec/player_spec.rb
 - spec/result_spec.rb
 - spec/spec_helper.rb
 - spec/tournament_fcsv_spec.rb
+- spec/tournament_krause_spec.rb
 - spec/tournament_spec.rb
 - spec/util_spec.rb