icu_tournament 1.3.7 → 1.3.8

data/lib/icu_tournament/tournament.rb

@@ -94,20 +94,25 @@ module ICU
   #
   #   t.validate(:rerank => true)
   #
-  # Ranking is inconsistent if some but not all players have a rank or if all players
-  # but at least one pair of players exist where one has a higher score but a lower rank.
+  # Ranking is inconsistent if not all players have a rank or at least one pair of players exist
+  # where one has a higher score but a lower rank.
   #
-  # 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
-  # an array of methods (strings or symbols) in order of precedence to the _tie_breaks_ setter. Examples:
+  # To rank the players requires one or more tie break methods for ordering players on the same score.
+  # Methods can be specified by supplying an array of methods names (strings or symbols) in order of
+  # precedence to the _tie_breaks_ setter. Examples:
   #
   #   t.tie_breaks = ['Sonneborn-Berger']
   #   t.tie_breaks = [:buchholz, :neustadtl, :blacks, :wins]
-  #   t.tie_breaks = []  # reset to the default
+  #   t.tie_breaks = []  # use the default - see below
   #
-  # See ICU::TieBreak for the full list of supported tie break methods.
+  # If the first method fails to differentiate two tied players, the second is tried, and then the
+  # third and so on. See ICU::TieBreak for the full list of supported tie break methods.
   #
-  # The return value from _rerank_ is the tournament object itself, to allow chaining, for example:
+  # Unless explicity specified, the _name_ tie break (which orders alphabetically by last name
+  # then first name) is implicitly used as a method of last resort. Thus, in the absence of any
+  # tie break methods being specified at all, alphabetical ordering is the default.
+  #
+  # The return value from _rerank_ is the tournament object itself, to allow method chaining, for example:
   #
   #   t.rerank.renumber
   #

data/lib/icu_tournament/tournament_krause.rb

@@ -43,23 +43,25 @@ module ICU
     #   daffy = tournament.player(2)
     #   daffy.title                       # => "IM"
     #   daffy.rating                      # => 2200
+    #   daffy.fide_rating                 # => nil
     #   daffy.fed                         # => "IRL"
-    #   daffy.id                          # => 7654321
-    #   daffy.fide                        # => nil
+    #   daffy.id                          # => nil
+    #   daffy.fide_id                     # => 7654321
     #   daffy.dob                         # => "1937-04-17"
     #
-    # By default, ID numbers and ratings in the input are interpreted as local IDs and ratings. If, instead, they should be interpreted as
-    # FIDE IDs and ratings, add the following option:
+    # By default, ratings are interpreted as ICU. If, instead, they should be interpreted as
+    # FIDE ratings, add the _fide_ option:
     #
-    #   tournament = parser.parse_file('tournament.tab', :fide_id => true)
+    #   tournament = parser.parse_file('tournament.tab', :fide => true)
     #   daffy = tournament.player(2)
-    #   daffy.id                          # => nil
-    #   daffy.fide                        # => 7654321
     #   daffy.rating                      # => nil
     #   daffy.fide_rating                 # => 2200
     #
+    # ID numbers, on the other hand, are automatically classified as either FIDE or ICU on the basis of size,
+    # since all FIDE IDs are greater than 100000 whereas ICU IDs are much smaller.
+    #
     # If the ranking numbers are missing from the file or inconsistent (e.g. player A is ranked above player B
-    # but has less points than player B) they are recalculated as a side effect of the parse.
+    # but has less points) they are recalculated as a side effect of the parse.
     #
     #   daffy.rank                        # => 1
     #   minnie.rank                       # => 2
@@ -87,8 +89,8 @@ module ICU
     # By default, local (ICU) IDs and ratings are used for the serialization, but both methods accept an option that
     # causes FIDE IDs and ratings to be used instead:
     #
-    #   krause = parser.serialize(tournament, :fide_id => true)
-    #   krause = tournament.serialize('Krause', :fide_id => true)
+    #   krause = parser.serialize(tournament, :fide => true)
+    #   krause = tournament.serialize('Krause', :fide => true)
     #
     # The following lists Krause data identification numbers, their description and, where available, their corresponding
     # attributes in an ICU::Tournament instance.
@@ -316,7 +318,7 @@ module ICU
         @tournament.start = @data
         @start_set = true
       end
-      
+
       # Split text into lines but also pad the player lines (those beginning "001 ").
       def get_lines(text)
         lines = text.split(/\s*\n/)
@@ -352,17 +354,15 @@ module ICU
           :dob    => @data[65, 10],
           :rank   => @data[81, 4],
         }
-        
-        # The IDs and ratings can be local or international.
-        itype = arg[:fide] ? :fide_id : :id
-        rtype = arg[:fide] ? :fide_rating : :rating
-        opt[itype] = @data[53, 11]
-        opt[rtype] = @data[44, 4]
-        
-        # Remove obviously bad data.
-        opt.delete(itype) if opt.has_key?(itype) && opt[itype].to_i == 0
-        opt.delete(rtype) if opt.has_key?(rtype) && opt[rtype].to_i == 0
-        
+
+        # Ratings are assumed to be local unless otherwise specified.
+        rating = @data[44, 4].to_i
+        opt[arg[:fide] ? :fide_rating : :rating] = rating if rating > 0 && rating < 4000
+
+        # IDs can be determined to be FIDE or ICU on the basis of their size.
+        id = @data[53, 11].to_i
+        opt[id >= 100000 ? :fide_id : :id] = id if id > 0
+
         # Options to remove other bad data.
         opt.delete(:fed) if arg[:fed].to_s == 'ignore'
         opt.delete(:fed) if arg[:fed].to_s == 'skip' && !ICU::Federation.find(opt[:fed])
@@ -414,7 +414,7 @@ module ICU
         end
         result.points
       end
-      
+
       # See if byes can be used to make the sum of scores match the declared total.
       def fix_sum(player, full_byes, half_byes, total, sum)
         return false unless total > sum

data/lib/icu_tournament/version.rb

@@ -2,6 +2,6 @@
 
 module ICU
   class Tournament
-    VERSION = "1.3.7"
+    VERSION = "1.3.8"
   end
 end

data/spec/tournament_krause_spec.rb

@@ -131,9 +131,9 @@ KRAUSE
 
         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')
+          check_player(1, 'Minerva', 'Mouse', :gender => 'F', :rating => 1900, :fed => 'USA', :fide_id => 1234567, :dob => '1928-05-15', :rank => 2)
+          check_player(2, 'Daffy',   'Duck',  :gender => 'M', :rating => 2200, :fed => 'IRL', :fide_id => 7654321, :dob => '1937-04-17', :rank => 1, :title => 'IM')
+          check_player(3, 'Mickey',  'Mouse', :gender => 'M', :rating => 2600, :fed => 'USA', :fide_id => 1726354, :dob => '1928-05-15', :rank => 3, :title => 'GM')
         end
 
         it "should have correct results for each player" do
@@ -193,13 +193,13 @@ KRAUSE
         end
 
         it "should serialize back to the original if the input is fully canonicalised" do
-          t = @p.parse!(@krause)
-          ICU::Tournament::Krause.new.serialize(t).should == @krause
+          t = @p.parse!(@krause, :fide => true)
+          ICU::Tournament::Krause.new.serialize(t, :fide => true).should == @krause
         end
 
         it "should serialize using the convenience method of the tournament object" do
-          t = @p.parse!(@krause)
-          t.serialize('Krause').should == @krause
+          t = @p.parse!(@krause, :fide => true)
+          t.serialize('Krause', :fide => true).should == @krause
         end
 
         it "should serialize only if :fide option is used correctly" do
@@ -208,16 +208,10 @@ KRAUSE
           t.serialize('Krause').should_not == @krause
         end
 
-        it "should not serialize coorectly if mixed ID types are used" do
+        it "should not serialize correctly if mixed rating types are used" do
           t = @p.parse!(@krause, :fide => true)
           t.serialize('Krause').should_not == @krause
         end
-
-        it "should serialize coorectly if FIDE IDs are used consistently" do
-          t = @p.parse!(@krause, :fide => true)
-          t.serialize('Krause', :fide => true).should == @krause
-        end
-
       end
 
       context "auto-ranking" do
@@ -240,30 +234,39 @@ KRAUSE
         end
       end
 
-      context "local or FIDE IDs" do
+      context "local or FIDE ratings and IDs" do
         before(:each) 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    2 m  m Orr,Mark                          2258 IRL        1350 1955-11-09  2.0          1 w 1               3 b 1
 001    3 m  g Bologan,Viktor                    2663 MDA             1971-01-01  0.0                    1 b 0     2 w 0
 KRAUSE
           @p = ICU::Tournament::Krause.new
         end
 
-        it "should have local IDs by default" do
+        it "should have local ratings by default" do
           @t = @p.parse(@krause)
-          check_player(1, 'Gearoidin', 'Ui Laighleis', :id => 2501171, :fide_id => nil)
-          check_player(2, 'Mark',      'Orr',          :id => 2500035, :fide_id => nil)
-          check_player(3, 'Viktor',    'Bologan',      :id => nil,     :fide_id => nil)
+          check_player(1, 'Gearoidin', 'Ui Laighleis', :rating => 1985, :fide_rating => nil)
+          check_player(2, 'Mark',      'Orr',          :rating => 2258, :fide_rating => nil)
+          check_player(3, 'Viktor',    'Bologan',      :rating => 2663, :fide_rating => nil)
         end
 
-        it "should have FIDE IDs if option is used" do
+        it "should have FIDE ratings if option is specified" do
+          @t = @p.parse(@krause, :fide => true)
+          check_player(1, 'Gearoidin', 'Ui Laighleis', :rating => nil, :fide_rating => 1985)
+          check_player(2, 'Mark',      'Orr',          :rating => nil, :fide_rating => 2258)
+          check_player(3, 'Viktor',    'Bologan',      :rating => nil, :fide_rating => 2663)
+        end
+        
+        it "should auto-detect FIDE or ICU IDs based on size, the option has no effect" do
+          @t = @p.parse(@krause)
+          check_player(1, 'Gearoidin', 'Ui Laighleis', :id => nil,  :fide_id => 2501171)
+          check_player(2, 'Mark',      'Orr',          :id => 1350, :fide_id => nil)
           @t = @p.parse(@krause, :fide => true)
-          check_player(1, 'Gearoidin', 'Ui Laighleis', :fide => 2501171, :id => nil)
-          check_player(2, 'Mark',      'Orr',          :fide => 2500035, :id => nil)
-          check_player(3, 'Viktor',    'Bologan',      :fide => nil,     :id => nil)
+          check_player(1, 'Gearoidin', 'Ui Laighleis', :id => nil,  :fide_id => 2501171)
+          check_player(2, 'Mark',      'Orr',          :id => 1350, :fide_id => nil)
         end
       end
 

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 1
   - 3
-  - 7
-  version: 1.3.7
+  - 8
+  version: 1.3.8
 platform: ruby
 authors: 
 - Mark Orr
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-03-04 00:00:00 +00:00
+date: 2011-03-06 00:00:00 +00:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency