icu_ratings 1.5.0 → 1.5.1

data/lib/icu_ratings/player.rb

@@ -117,8 +117,8 @@ module ICU
   # There is one other optional parameter, _desc_ (short for "description"). It has no effect on player
   # type or rating calculations and it cannot be used to retrieve players from a tournament (only the
   # player number can be used for that). Its only use is to attach additional arbitary data to players.
-  # Any object can be used and descriptions don't have to be unique. The attribute's typical use,
-  # if it's used at all, is expected to be for player names in the form of String values.
+  # Any object can be used and descriptions don't have to be unique. The attribute's typical use, if
+  # it's used at all, is expected to be for player names and/or ID numbers, in the form of String values.
   #
   #   t.add_player(8, :rating => 2800, :desc => 'Gary Kasparov (4100018)')
   #   t.player(8).desc    # "Gary Kasparov (4100018)"
@@ -128,24 +128,24 @@ module ICU
   # After the <em>rate!</em> method has been called on the ICU::RatedTournament object, the results
   # of the rating calculations are available via various methods of the player objects:
   #
-  # _new_rating_::     This is the player's new rating. For rated players it is their old rating
-  #                    plus their _rating_change_ plus their _bonus_ (if any). For provisional players
-  #                    it is their performance rating including their previous games. For unrated
-  #                    players it is their tournament performance rating. New ratings are not
-  #                    calculated for foreign players so this method just returns their start _rating_.
-  # _rating_change_::  This is calculated from a rated player's old rating, their K-factor and the sum
-  #                    of expected scores in each game. The same as the difference between the old and
-  #                    new ratings (unless there is a bonus). Zero for all other types of players.
-  # _performance_::    This returns the tournament rating performance for rated, unrated and
-  #                    foreign players. For provisional players it returns a weighted average
-  #                    of the player's tournament performance and their previous games. For
-  #                    provisional and unrated players it is the same as _new_rating_.
-  # _expected_score_:: This returns the sum of expected scores over all results for all player types.
-  #                    For rated players, this number times the K-factor gives their rating change.
-  #                    It is calculated for provisional, unrated and foreign players but not actually
-  #                    used to estimate new ratings (for provisional and unrated players performance
-  #                    estimates are used instead).
-  # _bonus_::          The bonus received by a rated player (usually zero). Nil for other player types.
+  # _new_rating_::      This is the player's new rating. For rated players it is their old rating
+  #                     plus their _rating_change_ plus their _bonus_ (if any). For provisional players
+  #                     it is their performance rating including their previous games. For unrated
+  #                     players it is their tournament performance rating. New ratings are not
+  #                     calculated for foreign players so this method just returns their start _rating_.
+  # _rating_change_::   This is calculated from a rated player's old rating, their K-factor and the sum
+  #                     of expected scores in each game. The same as the difference between the old and
+  #                     new ratings (unless there is a bonus). Not available for other player types.
+  # _performance_::     This returns the tournament rating performance for rated, unrated and
+  #                     foreign players. For provisional players it returns a weighted average
+  #                     of the player's tournament performance and their previous games. For
+  #                     provisional and unrated players it is the same as _new_rating_.
+  # _expected_score_::  This returns the sum of expected scores over all results for all player types.
+  #                     For rated players, this number times the K-factor gives their rating change.
+  #                     It is calculated for provisional, unrated and foreign players but not actually
+  #                     used to estimate new ratings (for provisional and unrated players performance
+  #                     estimates are used instead).
+  # _bonus_::           The bonus received by a rated player (usually zero). Not available for other player types.
   #
   # == Unrateable Players
   #
@@ -155,53 +155,49 @@ module ICU
   # method.
   #
   class RatedPlayer
-    attr_reader :num, :rating, :kfactor, :games, :bonus
+    attr_reader :num, :type, :performance, :results
     attr_accessor :desc
 
-    # After the tournament has been rated, this is the player's new rating.
-    def new_rating
-      full_rating? ? @rating + rating_change + @bonus : performance
-    end
-
-    # After the tournament has been rated, this is the difference between the old and new ratings for
-    # rated players, based on sum of expected scores in each games and the player's K-factor.
-    # Zero for all other types of players.
-    def rating_change
-      @results.inject(0.0) { |c, r| c + (r.rating_change || 0.0) }
-    end
-
-    # After the tournament has been rated, this returns the sum of expected scores over all results.
-    def expected_score
-      @results.inject(0.0) { |e, r| e + (r.expected_score || 0.0) }
-    end
-
-    # After the tournament has been rated, this returns the tournament rating performance for
-    # rated, unrated and foreign players. Returns zero for rated players.
-    def performance
-      @performance
-    end
-
-    # Returns an array of the player's results (ICU::RatedResult) in round order.
-    def results
-      @results
+    def self.factory(num, args={}) # :nodoc:
+      num     = check_num(num)
+      rating  = check_rating(args[:rating])
+      kfactor = check_kfactor(args[:kfactor])
+      games   = check_games(args[:games])
+      desc    = args[:desc]
+      case
+        when  rating &&  kfactor && !games then FullRating.new(num, desc, rating, kfactor)
+        when  rating && !kfactor &&  games then ProvRating.new(num, desc, rating, games)
+        when  rating && !kfactor && !games then FrgnRating.new(num, desc, rating)
+        when !rating && !kfactor && !games then NoneRating.new(num, desc)
+        else  raise "invalid combination of player attributes"
+      end
     end
 
-    # The sum of the player's scores in all rounds in which they have a result.
-    def score
-      @results.inject(0.0) { |e, r| e + r.score }
+    def self.check_num(arg) # :nodoc:
+      num = arg.to_i
+      raise "invalid player num (#{arg})" if num == 0 && !arg.to_s.match(/^\s*\d/)
+      num
     end
 
-    # Returns the type of player as a symbol: one of _rated_, _provisional_, _unrated_ or _foreign_.
-    def type
-      @type
+    def self.check_rating(arg) # :nodoc:
+      return unless arg
+      rating = arg.to_f
+      raise "invalid player rating (#{arg})" if rating == 0.0 && !arg.to_s.match(/^\s*\d/)
+      rating
     end
 
-    def full_rating? # :nodoc:
-      @type == :rated || @type == :foreign
+    def self.check_kfactor(arg) # :nodoc:
+      return unless arg
+      kfactor = arg.to_f
+      raise "invalid player k-factor (#{arg})" if kfactor <= 0.0
+      kfactor
     end
 
-    def bonus_rating # :nodoc:
-      @bonus_rating || @rating
+    def self.check_games(arg) # :nodoc:
+      return unless arg
+      games = arg.to_i
+      raise "invalid number of games (#{arg})" if games <= 0 || games >= 20
+      games
     end
 
     # Calculate a K-factor according to ICU rules.
@@ -219,6 +215,117 @@ module ICU
       end
     end
 
+    def reset # :nodoc:
+      @performance = nil
+      @estimated_performance = nil
+    end
+
+    class FullRating < RatedPlayer # :nodoc:
+      attr_reader :rating, :kfactor, :bonus
+
+      def initialize(num, desc, rating, kfactor)
+        @type = :rated
+        @rating = rating
+        @kfactor = kfactor
+        @bonus = 0
+        super(num, desc)
+      end
+
+      def reset
+        @bonus_rating = nil
+        @bonus = 0
+        super
+      end
+
+      def rating_change
+        @results.inject(0.0) { |c, r| c + (r.rating_change || 0.0) }
+      end
+
+      def new_rating(type=nil)
+        case type
+        when :start
+          @rating                          # the player's start rating
+        when :opponent
+          @bonus_rating || @rating         # the rating used for opponents during the calculations
+        else
+          @rating + rating_change + @bonus # the player's final rating
+        end
+      end
+
+      def calculate_bonus
+        return if @kfactor <= 24 || @results.size <= 4 || @rating >= 2100
+        change = rating_change
+        return if change <= 35 || @rating + change >= 2100
+        threshold = 32 + 3 * (@results.size - 4)
+        bonus = (change - threshold).round
+        return if bonus <= 0
+        bonus = (1.25 * bonus).round if kfactor >= 40
+        [2100, @performance].each { |max| bonus = max - @rating if bonus + @rating > max }
+        return if bonus <= 0
+        bonus = bonus.round
+        @bonus_rating = @rating + change + bonus
+        @bonus = bonus
+      end
+
+      def update_bonus
+        @bonus_rating = @rating + @bonus + rating_change if @bonus_rating
+      end
+    end
+
+    class ProvRating < RatedPlayer # :nodoc:
+      attr_reader :rating, :games
+
+      def initialize(num, desc, rating, games)
+        @type = :provisional
+        @rating = rating
+        @games = games
+        super(num, desc)
+      end
+
+      def new_rating(type=nil)
+        performance
+      end
+
+      def average_performance(new_performance, new_games)
+        old_performance = games * rating
+        old_games       = games
+        (new_performance + old_performance) / (new_games + old_games)
+      end
+    end
+
+    class NoneRating < RatedPlayer # :nodoc:
+      def initialize(num, desc)
+        @type = :unrated
+        super(num, desc)
+      end
+
+      def new_rating(type=nil)
+        performance
+      end
+    end
+
+    class FrgnRating < RatedPlayer # :nodoc:
+      attr_reader :rating
+
+      def initialize(num, desc, rating)
+        @type = :foreign
+        @rating = rating
+        super(num, desc)
+      end
+
+      def new_rating(type=nil)
+        rating
+      end
+    end
+
+    def expected_score
+      @results.inject(0.0) { |e, r| e + (r.expected_score || 0.0) }
+    end
+
+    def score
+      @results.inject(0.0) { |e, r| e + r.score }
+    end
+
     def add_result(result) # :nodoc:
       raise "invalid result (#{result.class})" unless result.is_a? ICU::RatedResult
       raise "players cannot score results against themselves" if self == result.opponent
@@ -234,31 +341,25 @@ module ICU
       @results.sort!{ |a,b| a.round <=> b.round }
     end
 
-    def init # :nodoc:
-      @performance = nil
-      @estimated_performance = nil
-      @bonus_rating = nil
-      @bonus = 0
-    end
-
     def rate!(update_bonus=false) # :nodoc:
       @results.each { |r| r.rate!(self) }
-      @bonus_rating = @rating + @bonus + rating_change if update_bonus && @bonus_rating
+      self.update_bonus if update_bonus && respond_to?(:update_bonus)
     end
 
     def estimate_performance # :nodoc:
-      new_games, new_performance = results.inject([0,0.0]) do |sum, result|
-        opponent = result.opponent
-        if opponent.full_rating? || opponent.performance
+      games, performance = results.inject([0,0.0]) do |sum, result|
+        rating = result.opponent.new_rating(:opponent)
+        if rating
           sum[0]+= 1
-          sum[1]+= (opponent.full_rating? ? opponent.bonus_rating : opponent.performance) + (2 * result.score - 1) * 400.0
+          sum[1]+= rating + (2 * result.score - 1) * 400.0
         end
         sum
       end
-      if new_games > 0
-        old_games, old_performance = type == :provisional ? [games, games * rating] : [0, 0.0]
-        @estimated_performance = (new_performance + old_performance) / (new_games + old_games)
-      end
+      @estimated_performance = average_performance(performance, games) if games > 0
+    end
+
+    def average_performance(performance, games) # :nodoc:
+      performance / games
     end
 
     def update_performance(thresh) # :nodoc:
@@ -274,22 +375,6 @@ module ICU
       stable
     end
 
-    def calculate_bonus # :nodoc:
-      # Rounding is performed in places to emulate the older MSAccess implementation.
-      return if @type != :rated || @kfactor <= 24 || @results.size <= 4 || @rating >= 2100
-      change = rating_change
-      return if change <= 35 || @rating + change >= 2100
-      threshold = 32 + 3 * (@results.size - 4)
-      bonus = (change - threshold).round
-      return if bonus <= 0
-      bonus = (1.25 * bonus).round if kfactor >= 40
-      [2100, @performance].each { |max| bonus = max - @rating if bonus + @rating > max }
-      return if bonus <= 0
-      bonus = bonus.round
-      @bonus_rating = @rating + change + bonus
-      @bonus = bonus
-    end
-
     def ==(other) # :nodoc:
       return false unless other.is_a? ICU::RatedPlayer
       num == other.num
@@ -297,42 +382,10 @@ module ICU
 
     private
 
-    def initialize(num, opt={}) # :nodoc:
-      self.num = num
-      [:rating, :kfactor, :games, :desc].each { |atr| self.send("#{atr}=", opt[atr]) unless opt[atr].nil? }
+    def initialize(num, desc) # :nodoc:
+      @num     = num
+      @desc    = desc
       @results = []
-      @type = deduce_type
-      @bonus = 0
-    end
-
-    def num=(num)
-      @num = num.to_i
-      raise "invalid player num (#{num})" if @num == 0 && !num.to_s.match(/^\s*\d/)
-    end
-
-    def rating=(rating)
-      @rating = rating.to_f
-      raise "invalid player rating (#{rating})" if @rating == 0.0 && !rating.to_s.match(/^\s*\d/)
-    end
-
-    def kfactor=(kfactor)
-      @kfactor = kfactor.to_f
-      raise "invalid player k-factor (#{kfactor})" if @kfactor <= 0.0
-    end
-
-    def games=(games)
-      @games = games.to_i
-      raise "invalid number of games (#{games})" if @games <= 0 || @games >= 20
-    end
-
-    def deduce_type
-      case
-        when  @rating &&  @kfactor && !@games then :rated
-        when  @rating && !@kfactor &&  @games then :provisional
-        when  @rating && !@kfactor && !@games then :foreign
-        when !@rating && !@kfactor && !@games then :unrated
-        else  raise "invalid combination of player attributes"
-      end
     end
   end
 end

data/lib/icu_ratings/result.rb

@@ -87,32 +87,17 @@ module ICU
   #
   # The main rating calculations are available from player methods (see ICU::RatedPlayer)
   # but additional details are available via methods of each player's individual results:
-  # _expected_score_, _rating_change_.
+  # _expected_score_, _rating_change_ (rated players only).
   #
   class RatedResult
-    attr_reader :round, :opponent, :score
-
-    # After the tournament has been rated, this returns the expected score (between 0 and 1)
-    # for the player based on the rating difference with the opponent scaled by 400.
-    # The standard Elo formula is used: 1/(1 + 10^(diff/400)).
-    def expected_score
-      @expected_score
-    end
-
-    # After the tournament has been rated, returns the change in rating due to this particular
-    # result. Only for rated players (returns _nil_ for other types of players). Computed from
-    # the difference between actual and expected scores multiplied by the player's K-factor.
-    # The sum of these changes is the overall rating change for rated players.
-    def rating_change
-      @rating_change
-    end
+    attr_reader :round, :opponent, :score, :expected_score, :rating_change
 
     def rate!(player) # :nodoc:
-      player_rating   = player.full_rating?   ? player.rating         : player.performance
-      opponent_rating = opponent.full_rating? ? opponent.bonus_rating : opponent.performance
+      player_rating   = player.new_rating(:start)
+      opponent_rating = opponent.new_rating(:opponent)
       if player_rating && opponent_rating
         @expected_score = 1 / (1 + 10 ** ((opponent_rating - player_rating) / 400.0))
-        @rating_change  = (@score - @expected_score) * player.kfactor if player.type == :rated
+        @rating_change  = (score - expected_score) * player.kfactor if player.type == :rated
       end
     end
 

data/lib/icu_ratings/tournament.rb

@@ -86,7 +86,7 @@ module ICU
     def add_player(num, args={})
       raise "player with number #{num} already exists" if @player[num]
       args[:kfactor] = ICU::RatedPlayer.kfactor(args[:kfactor].merge({ :start => start, :rating => args[:rating] })) if args[:kfactor].is_a?(Hash)
-      @player[num] = ICU::RatedPlayer.new(num, args)
+      @player[num] = ICU::RatedPlayer.factory(num, args)
     end
 
     # Add a new result to the tournament. Two instances of ICU::RatedResult are
@@ -126,7 +126,7 @@ module ICU
       end
 
       # Phase 1.
-      players.each { |p| p.init }
+      players.each { |p| p.reset }
       @iterations1 = performance_ratings(max_iterations[0], threshold)
       players.each { |p| p.rate! }
 
@@ -182,7 +182,7 @@ module ICU
 
     # Calculate bonuses for all players and return the number who got one.
     def calculate_bonuses
-      @player.values.inject(0) { |t,p| t + (p.calculate_bonus ? 1 : 0) }
+      @player.values.select{ |p| p.respond_to?(:bonus) }.inject(0) { |t,p| t + (p.calculate_bonus ? 1 : 0) }
     end
   end
 end

data/lib/icu_ratings/version.rb

@@ -2,6 +2,6 @@
 
 module ICU
   class Ratings
-    VERSION = "1.5.0"
+    VERSION = "1.5.1"
   end
 end

data/spec/player_spec.rb

@@ -3,48 +3,44 @@ require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
 module ICU
   describe RatedPlayer do
-    context "#new - different types of players" do
+    context "#factory - different types of players" do
       before(:all) do
-        @r = ICU::RatedPlayer.new(1, :rating => 2000, :kfactor => 10.0)
-        @p = ICU::RatedPlayer.new(2, :rating => 1500, :games => 10)
-        @f = ICU::RatedPlayer.new(3, :rating => 2500)
-        @u = ICU::RatedPlayer.new(4)
+        @r = ICU::RatedPlayer.factory(1, :rating => 2000, :kfactor => 10.0)
+        @p = ICU::RatedPlayer.factory(2, :rating => 1500, :games => 10)
+        @f = ICU::RatedPlayer.factory(3, :rating => 2500)
+        @u = ICU::RatedPlayer.factory(4)
       end
 
       it "rated players have a rating and k-factor" do
         @r.num.should     == 1
         @r.rating.should  == 2000
         @r.kfactor.should == 10.0
-        @r.games.should   be_nil
         @r.type.should    == :rated
-        @r.full_rating?.should be_true
+        @r.should_not respond_to(:games)
       end
 
       it "provisionally rated players have a rating and number of games" do
-        @p.num.should     == 2
-        @p.rating.should  == 1500
-        @p.kfactor.should be_nil
-        @p.games.should   == 10
-        @p.type.should    == :provisional
-        @p.full_rating?.should be_false
+        @p.num.should    == 2
+        @p.rating.should == 1500
+        @p.games.should  == 10
+        @p.type.should   == :provisional
+        @p.should_not respond_to(:kfactor)
       end
 
       it "foreign players just have a rating" do
-        @f.num.should     == 3
-        @f.rating.should  == 2500
-        @f.kfactor.should be_nil
-        @f.games.should   be_nil
-        @f.type.should    == :foreign
-        @f.full_rating?.should be_true
+        @f.num.should    == 3
+        @f.rating.should == 2500
+        @f.type.should   == :foreign
+        @f.should_not respond_to(:kfactor)
+        @f.should_not respond_to(:games)
       end
 
       it "unrated players just have nothing other than their number" do
-        @u.num.should     == 4
-        @u.rating.should  be_nil
-        @u.kfactor.should be_nil
-        @u.games.should   be_nil
-        @u.type.should    == :unrated
-        @u.full_rating?.should be_false
+        @u.num.should  == 4
+        @u.type.should == :unrated
+        @u.should_not respond_to(:rating)
+        @u.should_not respond_to(:kfactor)
+        @u.should_not respond_to(:games)
       end
 
       it "other combinations are invalid" do
@@ -53,13 +49,13 @@ module ICU
           { :games => 10, :kfactor => 10 },
           { :games => 10, :kfactor => 10, :rating  => 1000 },
           { :kfactor => 10 },
-        ].each { |opts| lambda { ICU::RatedPlayer.new(1, opts) }.should raise_error(/invalid.*combination/i) }
+        ].each { |opts| lambda { ICU::RatedPlayer.factory(1, opts) }.should raise_error(/invalid.*combination/i) }
       end
     end
 
     context "#new - miscellaneous" do
       it "attribute values can be given by strings, even when space padded" do
-        p = ICU::RatedPlayer.new(' 1 ', :kfactor => ' 10.0 ', :rating => ' 1000 ')
+        p = ICU::RatedPlayer.factory(' 1 ', :kfactor => ' 10.0 ', :rating => ' 1000 ')
         p.num.should     == 1
         p.kfactor.should == 10.0
         p.rating.should  == 1000
@@ -68,46 +64,46 @@ module ICU
 
     context "restrictions, or lack thereof, on attributes" do
       it "the player number can be zero or even negative" do
-        lambda { ICU::RatedPlayer.new(-1) }.should_not raise_error
-        lambda { ICU::RatedPlayer.new(0)  }.should_not raise_error
+        lambda { ICU::RatedPlayer.factory(-1) }.should_not raise_error
+        lambda { ICU::RatedPlayer.factory(0)  }.should_not raise_error
       end
 
       it "k-factors must be positive" do
-        lambda { ICU::RatedPlayer.new(1, :kfactor =>  0) }.should raise_error(/invalid.*factor/i)
-        lambda { ICU::RatedPlayer.new(1, :kfactor => -1) }.should raise_error(/invalid.*factor/i)
+        lambda { ICU::RatedPlayer.factory(1, :kfactor =>  0) }.should raise_error(/invalid.*factor/i)
+        lambda { ICU::RatedPlayer.factory(1, :kfactor => -1) }.should raise_error(/invalid.*factor/i)
       end
 
       it "the rating can be zero or even negative" do
-        lambda { ICU::RatedPlayer.new(1, :rating =>  0) }.should_not raise_error
-        lambda { ICU::RatedPlayer.new(1, :rating => -1) }.should_not raise_error
+        lambda { ICU::RatedPlayer.factory(1, :rating =>  0) }.should_not raise_error
+        lambda { ICU::RatedPlayer.factory(1, :rating => -1) }.should_not raise_error
       end
 
       it "ratings are stored as floats but can be specified with an integer" do
-        ICU::RatedPlayer.new(1, :rating => 1234.5).rating.should == 1234.5
-        ICU::RatedPlayer.new(1, :rating => 1234.0).rating.should == 1234
-        ICU::RatedPlayer.new(1, :rating =>   1234).rating.should == 1234
+        ICU::RatedPlayer.factory(1, :rating => 1234.5).rating.should == 1234.5
+        ICU::RatedPlayer.factory(1, :rating => 1234.0).rating.should == 1234
+        ICU::RatedPlayer.factory(1, :rating =>   1234).rating.should == 1234
       end
 
       it "the number of games shoud not exceed 20" do
-        lambda { ICU::RatedPlayer.new(1, :rating => 1000, :games => 19) }.should_not raise_error
-        lambda { ICU::RatedPlayer.new(1, :rating => 1000, :games => 20) }.should raise_error
-        lambda { ICU::RatedPlayer.new(1, :rating => 1000, :games => 21) }.should raise_error
+        lambda { ICU::RatedPlayer.factory(1, :rating => 1000, :games => 19) }.should_not raise_error
+        lambda { ICU::RatedPlayer.factory(1, :rating => 1000, :games => 20) }.should raise_error
+        lambda { ICU::RatedPlayer.factory(1, :rating => 1000, :games => 21) }.should raise_error
       end
 
       it "a description, such as a name, but can be any object, is optional" do
-        ICU::RatedPlayer.new(1, :desc => 'Fischer, Robert').desc.should == 'Fischer, Robert'
-        ICU::RatedPlayer.new(1, :desc => 1).desc.should be_an_instance_of(Fixnum)
-        ICU::RatedPlayer.new(1, :desc => 1.0).desc.should be_an_instance_of(Float)
-        ICU::RatedPlayer.new(1).desc.should be_nil
+        ICU::RatedPlayer.factory(1, :desc => 'Fischer, Robert').desc.should == 'Fischer, Robert'
+        ICU::RatedPlayer.factory(1, :desc => 1).desc.should be_an_instance_of(Fixnum)
+        ICU::RatedPlayer.factory(1, :desc => 1.0).desc.should be_an_instance_of(Float)
+        ICU::RatedPlayer.factory(1).desc.should be_nil
       end
     end
 
     context "results" do
       before(:each) do
         @p  = ICU::RatedPlayer.new(1, :kfactor => 10, :rating => 1000)
-        @r1 = ICU::RatedResult.new(1, ICU::RatedPlayer.new(2), 'W')
-        @r2 = ICU::RatedResult.new(2, ICU::RatedPlayer.new(3), 'L')
-        @r3 = ICU::RatedResult.new(3, ICU::RatedPlayer.new(4), 'D')
+        @r1 = ICU::RatedResult.new(1, ICU::RatedPlayer.factory(2), 'W')
+        @r2 = ICU::RatedResult.new(2, ICU::RatedPlayer.factory(3), 'L')
+        @r3 = ICU::RatedResult.new(3, ICU::RatedPlayer.factory(4), 'D')
       end
 
       it "should be returned in round order" do

data/spec/result_spec.rb

@@ -5,20 +5,20 @@ module ICU
   describe RatedResult do
     context "a basic rated result" do
       before(:all) do
-        @o = ICU::RatedPlayer.new(2)
+        @o = ICU::RatedPlayer.factory(2)
       end
 
       it "needs a round, opponent and score (win, loss or draw)" do
         r = ICU::RatedResult.new(1, @o, 'W')
         r.round.should == 1
-        r.opponent.should be_an_instance_of(ICU::RatedPlayer)
+        r.opponent.should be_a_kind_of(ICU::RatedPlayer)
         r.score.should == 1.0
       end
     end
 
     context "restrictions, or lack thereof, on attributes" do
       before(:each) do
-        @p = ICU::RatedPlayer.new(2)
+        @p = ICU::RatedPlayer.factory(2)
       end
 
       it "round numbers must be positive" do
@@ -41,7 +41,7 @@ module ICU
 
     context "#opponents_score" do
       before(:each) do
-        @p = ICU::RatedPlayer.new(2)
+        @p = ICU::RatedPlayer.factory(2)
       end
 
       it "should give the score from the opponent's perspective" do
@@ -53,8 +53,8 @@ module ICU
 
     context "equality" do
       before(:each) do
-        @p1 = ICU::RatedPlayer.new(1)
-        @p2 = ICU::RatedPlayer.new(2)
+        @p1 = ICU::RatedPlayer.factory(1)
+        @p2 = ICU::RatedPlayer.factory(2)
         @r1 = ICU::RatedResult.new(1, @p1, 'W')
         @r2 = ICU::RatedResult.new(1, @p1, 'W')
         @r3 = ICU::RatedResult.new(2, @p1, 'W')

data/spec/tournament_spec.rb

@@ -343,7 +343,7 @@ module ICU
           unless num == 13
             p = @t.player(num)
             p.expected_score.should_not == 0.0
-            p.rating_change.should == 0.0
+            p.should_not respond_to(:rating_change)
             p.new_rating.should == p.rating
           end
         end
@@ -762,17 +762,17 @@ module ICU
 
       it "should agree with ICU rating database" do
         [
-          [1, 3.5, 3.84,  977, 1073,  0], # Austin
-          [2, 4.0, 3.51, 1068, 1042,  0], # Kevin
-          [3, 1.0, 1.05,  636,  636,  0], # Nikhil
-          [4, 0.0, 0.78,  520,  537,  0], # Sean
-          [5, 3.5, 1.74, 1026,  835, 45], # Michael
-          [6, 3.0, 3.54,  907, 1010,  0], # Eoin
+          [1, 3.5, 3.84,  977, 1073,   0], # Austin
+          [2, 4.0, 3.51, 1068, 1042,   0], # Kevin
+          [3, 1.0, 1.05,  636,  636, nil], # Nikhil
+          [4, 0.0, 0.78,  520,  537,   0], # Sean
+          [5, 3.5, 1.74, 1026,  835,  45], # Michael
+          [6, 3.0, 3.54,  907, 1010,   0], # Eoin
         ].each do |item|
           num, score, expected_score, performance, new_rating, bonus = item
           p = @t.player(num)
           p.score.should == score
-          p.bonus.should == bonus
+          p.bonus.should == bonus if bonus
           p.performance.should be_within(0.5).of(performance)
           p.expected_score.should be_within(0.01).of(expected_score)
           p.new_rating.should be_within(0.5).of(new_rating)
@@ -817,13 +817,13 @@ module ICU
 
         @m = [
           # MSAccess results taken from rerun of original which is different (reason unknown).
-          [1, 4.0, 4.28, 1052, 1052,  0], # Fanjini
-          [2, 3.5, 1.93,  920,  757, 35], # Guinan
-          [3, 3.5, 2.29,  932,  798, 18], # Duffy
-          [4, 1.0, 1.52,  588,  707,  0], # Cooke
-          [5, 1.0, 1.40,  828,  828,  0], # Callaghan
-          [6, 1.0, 0.91,  627,  627,  0], # Montenegro
-          [7, 0.0, 0.78,  460,  635,  0], # Lowry-O'Reilly
+          [1, 4.0, 4.28, 1052, 1052, nil], # Fanjini
+          [2, 3.5, 1.93,  920,  757,  35], # Guinan
+          [3, 3.5, 2.29,  932,  798,  18], # Duffy
+          [4, 1.0, 1.52,  588,  707,   0], # Cooke
+          [5, 1.0, 1.40,  828,  828, nil], # Callaghan
+          [6, 1.0, 0.91,  627,  627, nil], # Montenegro
+          [7, 0.0, 0.78,  460,  635,   0], # Lowry-O'Reilly
         ]
       end
 
@@ -832,7 +832,7 @@ module ICU
           num, score, expected_score, performance, new_rating, bonus = item
           p = @t.player(num)
           p.score.should == score
-          p.bonus.should == bonus
+          p.bonus.should == bonus if bonus
           p.performance.should be_within(num == 2 ? 0.6 : 0.5).of(performance)
           p.expected_score.should be_within(0.01).of(expected_score)
           p.new_rating.should be_within(0.5).of(new_rating)
@@ -845,7 +845,7 @@ module ICU
           num, score, expected_score, performance, new_rating, bonus = item
           p = @t.player(num)
           p.score.should == score
-          p.bonus.should == bonus
+          p.bonus.should == bonus if bonus
           p.performance.should be_within(num == 2 ? 0.6 : 0.5).of(performance)
           p.expected_score.should be_within(0.01).of(expected_score)
           p.new_rating.should be_within(0.5).of(new_rating)
@@ -859,7 +859,7 @@ module ICU
           num, score, expected_score, performance, new_rating, bonus = item
           p = @t.player(num)
           p.score.should == score
-          p.bonus.should == 0
+          p.bonus.should == 0 if bonus
           p.performance.should_not be_within(1.0).of(performance)
           p.expected_score.should_not be_within(0.01).of(expected_score)
           p.new_rating.should_not be_within(1.0).of(new_rating)
@@ -986,7 +986,7 @@ module ICU
       end
 
       it "should behave like ratings.ciu.ie" do
-        @p1.send("kfactor=", 32)
+        @p1.instance_eval { @kfactor = 32 }
         @t.rate!
         @p1.new_rating.should be_within(0.5).of(1603)
         @p1.expected_score.should be_within(0.001).of(2.868)
@@ -1230,7 +1230,7 @@ module ICU
         @o5.new_rating.should == @o5.performance
         @o6.new_rating.should == @o6.performance
 
-        ratings = [@o1, @o2, @o3, @o4, @o5, @o6].map { |o| o.type == :rated ? o.rating : o.new_rating }
+        ratings = [@o1, @o2, @o3, @o4, @o5, @o6].map { |o| o.new_rating(:opponent) }
 
         average_of_ratings = ratings.inject(0.0){ |m,r| m = m + r } / 6.0
         average_of_ratings.should_not be_within(0.5).of(@p.new_rating)
@@ -1251,7 +1251,7 @@ module ICU
         @o5.new_rating.should == @o5.performance
         @o6.new_rating.should == @o6.performance
 
-        ratings = [@o1, @o2, @o3, @o4, @o5, @o6].map { |o| o.type == :rated ? o.rating : o.new_rating }
+        ratings = [@o1, @o2, @o3, @o4, @o5, @o6].map { |o| o.new_rating(:opponent) }
 
         average_of_ratings = ratings.inject(0.0){ |m,r| m = m + r } / 6.0
         average_of_ratings.should be_within(0.5).of(@p.new_rating)
@@ -2079,12 +2079,12 @@ module ICU
       end
     end
 
-    context "#rate - Dierdre Turner in the Limerick U1400 2012" do
+    context "#rate - Deirdre Turner in the Limerick U1400 2012" do
       before(:each) do
         @t = ICU::RatedTournament.new(desc: "Limerick U1400 2012")
 
-        # Add the players of most interest (Dierdre Turner and her opponents).
-        @p  = @t.add_player(6697, desc: "Dierdre Turner")
+        # Add the players of most interest (Deirdre Turner and her opponents).
+        @p  = @t.add_player(6697, desc: "Deirdre Turner")
         @o1 = @t.add_player(6678, desc: "John P. Dunne",      rating:  980, kfactor: 40)
         @o2 = @t.add_player(6694, desc: "Jordan O'Sullivan")
         @o3 = @t.add_player(6681, desc: "Ruairi Freeman",     rating:  537, kfactor: 40)
@@ -2111,7 +2111,7 @@ module ICU
         @t.add_player(6696, desc: "Mark David Tonita")
         @t.add_player(6698, desc: "Eoghan Turner")
 
-        # Dierdre's results.
+        # Deirdre's results.
         @t.add_result(1, 6697, 6678, "L")
         @t.add_result(2, 6697, 6694, "W")
         @t.add_result(3, 6697, 6681, "W")
@@ -2183,7 +2183,7 @@ module ICU
       end
 
       it "should be setup properly" do
-        @p.desc.should  == "Dierdre Turner"
+        @p.desc.should  == "Deirdre Turner"
         @o1.desc.should == "John P. Dunne"
         @o2.desc.should == "Jordan O'Sullivan"
         @o3.desc.should == "Ruairi Freeman"
@@ -2200,7 +2200,7 @@ module ICU
         @o6.type.should == :provisional
 
         @o1.rating.should == 980
-        @o2.rating.should be_nil
+        @o2.should_not respond_to(:rating)
         @o3.rating.should == 537
         @o4.rating.should == 682
         @o5.rating.should == 1320
@@ -2216,16 +2216,14 @@ module ICU
         @p.new_rating.should == @p.performance
 
         @o1.bonus.should == 23
-        @o2.bonus.should == 0
         @o3.bonus.should == 0
         @o4.bonus.should == 0
         @o5.bonus.should == 0
-        @o6.bonus.should == 0
 
-        ratings = [@o1, @o2, @o3, @o4, @o5, @o6].map { |o| o.bonus > 0 || o.type != :rated ? o.new_rating : o.rating }
+        ratings = [@o1, @o2, @o3, @o4, @o5, @o6].map { |o| o.new_rating(:opponent) }
 
         performance = ratings.inject(0.0){ |m,r| m = m + r } / 6.0
-        performance.should be_within(0.5).of(@p.new_rating)
+        performance.should be_within(0.1).of(@p.new_rating)
 
         @t.iterations1.should be > 1
         @t.iterations2.should be > 1

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: icu_ratings
 version: !ruby/object:Gem::Version
-  version: 1.5.0
+  version: 1.5.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-12-26 00:00:00.000000000 Z
+date: 2012-12-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -111,7 +111,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -4449600080095585228
+      hash: 1156445910149714022
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -120,7 +120,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -4449600080095585228
+      hash: 1156445910149714022
 requirements: []
 rubyforge_project: icu_ratings
 rubygems_version: 1.8.23