sanichi-chess_icu 0.5.2 → 0.5.3

data/VERSION.yml

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

data/lib/chess_icu/player.rb

@@ -210,10 +210,10 @@ All other attributes are unaffected.
     end
     
     # Renumber the player according to the supplied hash. Return self.
-    def renumber!(map)
+    def renumber(map)
       raise "player number #{@num} not found in renumbering hash" unless map[@num]
       self.num = map[@num]
-      @results.each{ |r| r.renumber!(map) }
+      @results.each{ |r| r.renumber(map) }
       self
     end
     

data/lib/chess_icu/result.rb

@@ -171,7 +171,7 @@ The _points_ read-only accessor always returns a floating point number: either 0
     end
     
     # Renumber the player and opponent (if there is one) according to the supplied hash. Return self.
-    def renumber!(map)
+    def renumber(map)
       raise "result player number #{@player} not found in renumbering hash" unless map[@player]
       self.player = map[@player]
       if @opponent

data/lib/chess_icu/team.rb

@@ -69,7 +69,7 @@ Attempting to add non-numbers or duplicate numbers as new team members results i
     end
     
     # Renumber the players according to the supplied hash. Return self.
-    def renumber!(map)
+    def renumber(map)
       @members.each_with_index do |pnum, index|
         raise "player number #{pnum} not found in renumbering hash" unless map[pnum]
         @members[index] = map[pnum]

data/lib/chess_icu/tournament.rb

@@ -56,18 +56,33 @@ If the _rerank_ option is set, as in this example:
 
 then there are additional side effects of validating a tournament:
 
-* the players will be ranked if no players have any rank
+* the players will be ranked if there is no existing ranking
 * the players will be reranked if the existing ranking is inconsistent
 
 Ranking is consistent if either no players have any rank or if all players have a rank and no player is ranked higher than another player with more points.
 
-The players in a tournament, whose reference numbers can be any set of unique integers (including zero and negative numbers),
-can be renumbered in order of rank or name. After renumbering the new player numbers will start at 1 and go up to the number
-of players.
+The default tie break method used to rank players on the same score is alphabetical (by last name then first name).
+Other methods can be specified via the _rerank_ option. Instead of setting the option to _true_, alternatives are
+the following (both symbols or strings will work):
 
-  t.renumber!(:name)       # renumber by name
-  t.renumber!(:rank)       # renumber by rank
-  t.renumber!              # same - rank is the default
+* _sum_of_scores_: sum of opponents' scores
+* _name_: this is the default and the same as setting the option to true
+
+Since _validate_ and _invalid_ only rerank a tournament with absent or inconsistent ranking, to force
+a particular kind of ranking of a tournament which is already ranked, use the _rerank_ method. This method
+takes one argument, the tie break method and it works the same as the _rerank_ option to _validate_. For example:
+
+  t.rerank(:sum_of_scores)   # rerank using sum of scores as tie break
+  t.rerank(:name)            # rerank using player names as tie break
+  t.rerank                   # same as _name_, which is the default
+
+The players in a tournament, whose reference numbers can be any set of unique integers (including zero and
+negative numbers), can be renumbered in order of rank or name. After renumbering the new player numbers will
+start at 1 and go up to the number of players.
+
+  t.renumber(:name)       # renumber by name
+  t.renumber(:rank)       # renumber by rank
+  t.renumber              # same - rank is the default
 
 A side effect of renumbering by rank is that if the tournament started without any player rankings or
 with inconsitent rankings, it will be reranked (i.e. the method _rerank_ will be called).
@@ -256,20 +271,20 @@ with inconsitent rankings, it will be reranked (i.e. the method _rerank_ will be
       end
     end
         
-    # Rerank the tournament by score, resolving ties using name.
-    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
+    # Rerank the tournament by score first and if necessary using a configurable tie breaker method.
+    def rerank(tie_break_method = :name)
+      points, tie_break_scores, tie_break_order = rerank_data(tie_break_method)
+      sortable = @player.values.map { |p| [p, points[p.num], tie_break_scores[p.num]] }
+      sortable.sort do |a,b|
+        diff = b[1] <=> a[1]
+        diff == 0 ? (b[2] <=> a[2]) * tie_break_order : diff
+      end.each_with_index do |s,i|
+        s[0].rank = i + 1
       end
     end
-    
-    # Renumber the players according to a given criterion. Return self.
-    def renumber!(criterion = :rank)
+
+    # Renumber the players according to a given criterion.
+    def renumber(criterion = :rank)
       map = Hash.new
       
       # Decide how to rank.
@@ -281,14 +296,12 @@ with inconsitent rankings, it will be reranked (i.e. the method _rerank_ will be
       end
       
       # Apply ranking.
-      @teams.each{ |t| t.renumber!(map) }
+      @teams.each{ |t| t.renumber(map) }
       @player = @player.values.inject({}) do |hash, player|
-        player.renumber!(map)
+        player.renumber(map)
         hash[player.num] = player
         hash
       end
-      
-      self
     end
 
     # Is a tournament invalid? Either returns false (if it's valid) or an error message.
@@ -304,7 +317,7 @@ with inconsitent rankings, it will be reranked (i.e. the method _rerank_ will be
     # Raise an exception if a tournament is not valid.
     # Covers all the ways a tournament can be invalid not already enforced by the setters.
     def validate!(options={})
-      begin check_ranks rescue rerank end if options[:rerank]
+      begin check_ranks rescue rerank(options[:rerank]) end if options[:rerank]
       check_players
       check_rounds
       check_dates
@@ -401,5 +414,32 @@ with inconsitent rankings, it will be reranked (i.e. the method _rerank_ will be
         end
       end
     end
+    
+    # Return a hash of total points, a hash of tie break scores and a tie break
+    # order (+1 for ascending, -1 for descending) depending on the tie break method.
+    def rerank_data(tie_break_method)
+      points = Hash.new
+      @player.values.each do |p|
+        points[p.num] = p.points
+      end
+      tie_break_scores = Hash.new
+      tie_break_method = tie_break_method.to_sym if tie_break_method.class == String
+      @player.values.each do |p|
+        if tie_break_method == :name || tie_break_method == true
+          tie_break_scores[p.num] = p.name
+        else
+          tie_break_scores[p.num] = 0.0
+          if (tie_break_method == :sum_of_scores)
+            p.results.each do |r|
+              tie_break_scores[p.num]+= points[r.opponent] if r.opponent
+            end
+          else
+            raise "invalid tie break method '#{tie_break_method}'"
+          end
+        end
+      end
+      tie_break_order = tie_break_method == :name ? -1 : 1
+      [points, tie_break_scores, tie_break_order]
+    end
   end
 end

data/spec/player_spec.rb

@@ -245,13 +245,13 @@ module ICU
       
       it "should renumber successfully if the map has the relevant player numbers" do
         map = { 10 => 1, 20 => 2, 30 => 3 }
-        @p.renumber!(map).num.should == 1
+        @p.renumber(map).num.should == 1
         @p.results.map{ |r| r.opponent }.sort.join('').should == '23'
       end
       
       it "should raise exception if a player number is not in the map" do
-        lambda { @p.renumber!({ 100 => 1, 20 => 2, 30 => 3 }) }.should raise_error(/player.*10.*not found/)
-        lambda { @p.renumber!({ 10 => 1, 200 => 2, 30 => 3 }) }.should raise_error(/opponent.*20.*not found/)
+        lambda { @p.renumber({ 100 => 1, 20 => 2, 30 => 3 }) }.should raise_error(/player.*10.*not found/)
+        lambda { @p.renumber({ 10 => 1, 200 => 2, 30 => 3 }) }.should raise_error(/opponent.*20.*not found/)
       end
     end
     

data/spec/result_spec.rb

@@ -146,14 +146,14 @@ module ICU
       
       it "should renumber successfully if the map has the relevant player numbers" do
         map = { 4 => 1, 3 => 2 }
-        @r1.renumber!(map).player.should == 1
-        @r2.renumber!(map).player.should == 2
+        @r1.renumber(map).player.should == 1
+        @r2.renumber(map).player.should == 2
         @r1.opponent.should be_nil
         @r2.opponent.should == 1
       end
       
       it "should raise exception if a player number is not in the map" do
-        lambda { @r1.renumber!({ 5 => 1, 3 => 2 }) }.should raise_error(/player.*4.*not found/)
+        lambda { @r1.renumber({ 5 => 1, 3 => 2 }) }.should raise_error(/player.*4.*not found/)
       end
     end
     

data/spec/team_spec.rb

@@ -48,11 +48,12 @@ module ICU
 
       it "should renumber successfully if the map has the relevant player numbers" do
         map = { 0 => 1, 3 => 2, -7 => 3 }
-        @t.renumber!(map).members.sort.join('').should == '123'
+        @t.renumber(map)
+        @t.members.sort.join('').should == '123'
       end
 
       it "should raise exception if a player is missing from the renumber map" do
-        lambda { @t.renumber!({ 5 => 1, 3 => 2 }) }.should raise_error(/player.*not found/)
+        lambda { @t.renumber({ 5 => 1, 3 => 2 }) }.should raise_error(/player.*not found/)
       end
     end
   end

data/spec/tournament_krause_spec.rb

@@ -225,7 +225,7 @@ REORDERED
         end
       
         it "should serialise correctly after renumbering by rank" do
-          @t.renumber!
+          @t.renumber
           @p.serialize(@t).should == @reordered
         end
       end

data/spec/tournament_spec.rb

@@ -454,21 +454,88 @@ module ICU
       end
 
       it "should be renumberable by rank" do
-        @t.renumber!.invalid.should be_false
+        @t.renumber
+        @t.invalid.should be_false
         @t.players.map{ |p| p.num }.join('|').should == '1|2|3'
         @t.players.map{ |p| p.first_name }.join('|').should == 'Mark|Gary|Bobby'
       end
       
       it "should be ranked after renumbering by rank" do
-        @t.renumber!.invalid.should be_false
+        @t.renumber
+        @t.invalid.should be_false
         @t.players.map{ |p| p.rank }.join('|').should == '1|2|3'
       end
       
       it "should be renumberable by name" do
-        @t.renumber!(:name).invalid.should be_false
+        @t.renumber(:name)
+        @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|Kasparov|Orr'
       end
     end
+
+    context "reranking" do
+      before(:each) do
+        @t = Tournament.new('Edinburgh Masters', '2009-11-09')
+        @t.add_player(@boby = Player.new('Bobby', 'Fischer', 1))
+        @t.add_player(@gary = Player.new('Gary', 'Kasparov', 2))
+        @t.add_player(@boby = Player.new('Micky', 'Mouse', 3))
+        @t.add_player(@boby = Player.new('Minnie', 'Mouse', 4))
+        @t.add_player(@boby = Player.new('Gearoidn', 'Ui Laighleis', 5))
+        @t.add_player(@mark = Player.new('Mark', 'Orr', 6))
+        @t.add_result(Result.new(1, 1, 'W', :opponent => 6))
+        @t.add_result(Result.new(2, 1, 'W', :opponent => 3))
+        @t.add_result(Result.new(3, 1, 'W', :opponent => 5))
+        @t.add_result(Result.new(1, 2, 'W', :opponent => 5))
+        @t.add_result(Result.new(2, 2, 'W', :opponent => 4))
+        @t.add_result(Result.new(3, 2, 'W', :opponent => 3))
+        @t.add_result(Result.new(1, 3, 'W', :opponent => 4))
+        @t.add_result(Result.new(3, 4, 'W', :opponent => 6))
+        @t.add_result(Result.new(2, 5, 'W', :opponent => 6))
+      end
+
+      it "should initially be valid but unranked" do
+        @t.invalid.should be_false
+        @t.player(1).rank.should be_nil
+      end
+
+      it "should use names for tie breaking by default" do
+        @t.rerank
+        @t.player(1).rank.should == 1  # 3/"Fischer"
+        @t.player(2).rank.should == 2  # 3/"Kasparov"
+        @t.player(3).rank.should == 3  # 1/"Mouse,Mickey"
+        @t.player(4).rank.should == 4  # 1/"Mouse,Minnie"
+        @t.player(5).rank.should == 5  # 1/"Ui"
+        @t.player(6).rank.should == 6  # 0
+      end
+    
+      it "should be configurable to use sum-of-opponents score" do
+        @t.rerank('sum_of_scores')
+        @t.player(2).rank.should == 1  # 3/3
+        @t.player(1).rank.should == 2  # 3/2
+        @t.player(3).rank.should == 3  # 1/7
+        @t.player(5).rank.should == 4  # 1/6
+        @t.player(4).rank.should == 5  # 1/4
+        @t.player(6).rank.should == 6  # 0/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 => :sum_of_scores).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
+        @t.player(5).rank.should == 4  # 1/6
+        @t.player(4).rank.should == 5  # 1/4
+        @t.player(6).rank.should == 6  # 0/5
+      end
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: sanichi-chess_icu
 version: !ruby/object:Gem::Version 
-  version: 0.5.2
+  version: 0.5.3
 platform: ruby
 authors: 
 - Mark Orr
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-09-03 00:00:00 -07:00
+date: 2009-09-12 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -59,6 +59,7 @@ files:
 - spec/util_spec.rb
 has_rdoc: true
 homepage: http://github.com/sanichi/chess_icu
+licenses: 
 post_install_message: 
 rdoc_options: 
 - --charset=UTF-8
@@ -79,7 +80,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.2.0
+rubygems_version: 1.3.5
 signing_key: 
 specification_version: 2
 summary: For parsing files of chess tournament data into ruby classes.