icu_ratings 1.8.2 → 1.8.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ba52aa09adfeab3a2c91eca7e9f82864d54d3bba
+  data.tar.gz: 92feb5576f6a87a390875ad8d09869fe233cc9c7
+SHA512:
+  metadata.gz: c06150bd0a95a3830ecd699b3798ecce39a9c13047aac70576fbae7f1ec3b80db680276476fec1eb448c0d057cf90232a2fec35a03fde34d6f5885431b431631
+  data.tar.gz: 471a2e5ceb94f4ec78188b1102627a123d4b357acae5b3ad638e34d3ad6cbf44a1f192f80fe98ae1588831bf76c2b46c747b0ce8e3161bf976a7c15bc56088ed

data/README.rdoc

@@ -14,7 +14,7 @@ with only a provisional rating or without any prior rating) which is different t
 
   sudo gem install icu_ratings
 
-Tested on Ruby 1.9.2, 1.9.3 and 2.0.0. Version 1.0.5 was the last to support Ruby 1.8.7.
+Tested on Ruby 1.9.2, 1.9.3, 2.2.0 and 2.2.0. Version 1.0.5 was the last to support Ruby 1.8.7.
 
 == Usage
 

data/lib/icu_ratings/version.rb

@@ -2,6 +2,6 @@
 
 module ICU
   class Ratings
-    VERSION = "1.8.2"
+    VERSION = "1.8.3"
   end
 end

data/spec/player_spec.rb

@@ -12,35 +12,35 @@ module ICU
       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.type.should    == :rated
-        @r.should_not respond_to(:games)
+        expect(@r.num).to     eq(1)
+        expect(@r.rating).to  eq(2000)
+        expect(@r.kfactor).to eq(10.0)
+        expect(@r.type).to    eq(:rated)
+        expect(@r).not_to 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.games.should  == 10
-        @p.type.should   == :provisional
-        @p.should_not respond_to(:kfactor)
+        expect(@p.num).to    eq(2)
+        expect(@p.rating).to eq(1500)
+        expect(@p.games).to  eq(10)
+        expect(@p.type).to   eq(:provisional)
+        expect(@p).not_to respond_to(:kfactor)
       end
 
       it "foreign players just have a rating" do
-        @f.num.should    == 3
-        @f.rating.should == 2500
-        @f.type.should   == :foreign
-        @f.should_not respond_to(:kfactor)
-        @f.should_not respond_to(:games)
+        expect(@f.num).to    eq(3)
+        expect(@f.rating).to eq(2500)
+        expect(@f.type).to   eq(:foreign)
+        expect(@f).not_to respond_to(:kfactor)
+        expect(@f).not_to respond_to(:games)
       end
 
       it "unrated players just have nothing other than their number" do
-        @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)
+        expect(@u.num).to  eq(4)
+        expect(@u.type).to eq(:unrated)
+        expect(@u).not_to respond_to(:rating)
+        expect(@u).not_to respond_to(:kfactor)
+        expect(@u).not_to respond_to(:games)
       end
 
       it "other combinations are invalid" do
@@ -49,52 +49,52 @@ module ICU
           { :games => 10, :kfactor => 10 },
           { :games => 10, :kfactor => 10, :rating  => 1000 },
           { :kfactor => 10 },
-        ].each { |opts| lambda { ICU::RatedPlayer.factory(1, opts) }.should raise_error(/invalid.*combination/i) }
+        ].each { |opts| expect { ICU::RatedPlayer.factory(1, opts) }.to 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.factory(' 1 ', :kfactor => ' 10.0 ', :rating => ' 1000 ')
-        p.num.should     == 1
-        p.kfactor.should == 10.0
-        p.rating.should  == 1000
+        expect(p.num).to     eq(1)
+        expect(p.kfactor).to eq(10.0)
+        expect(p.rating).to  eq(1000)
       end
     end
 
     context "restrictions, or lack thereof, on attributes" do
       it "the player number can be zero or even negative" do
-        lambda { ICU::RatedPlayer.factory(-1) }.should_not raise_error
-        lambda { ICU::RatedPlayer.factory(0)  }.should_not raise_error
+        expect { ICU::RatedPlayer.factory(-1) }.not_to raise_error
+        expect { ICU::RatedPlayer.factory(0)  }.not_to raise_error
       end
 
       it "k-factors must be positive" do
-        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)
+        expect { ICU::RatedPlayer.factory(1, :kfactor =>  0) }.to raise_error(/invalid.*factor/i)
+        expect { ICU::RatedPlayer.factory(1, :kfactor => -1) }.to raise_error(/invalid.*factor/i)
       end
 
       it "the rating can be zero or even negative" do
-        lambda { ICU::RatedPlayer.factory(1, :rating =>  0) }.should_not raise_error
-        lambda { ICU::RatedPlayer.factory(1, :rating => -1) }.should_not raise_error
+        expect { ICU::RatedPlayer.factory(1, :rating =>  0) }.not_to raise_error
+        expect { ICU::RatedPlayer.factory(1, :rating => -1) }.not_to raise_error
       end
 
       it "ratings are stored as floats but can be specified with an integer" do
-        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
+        expect(ICU::RatedPlayer.factory(1, :rating => 1234.5).rating).to eq(1234.5)
+        expect(ICU::RatedPlayer.factory(1, :rating => 1234.0).rating).to eq(1234)
+        expect(ICU::RatedPlayer.factory(1, :rating =>   1234).rating).to eq(1234)
       end
 
       it "the number of games shoud not exceed 20" do
-        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
+        expect { ICU::RatedPlayer.factory(1, :rating => 1000, :games => 19) }.not_to raise_error
+        expect { ICU::RatedPlayer.factory(1, :rating => 1000, :games => 20) }.to raise_error
+        expect { ICU::RatedPlayer.factory(1, :rating => 1000, :games => 21) }.to raise_error
       end
 
       it "a description, such as a name, but can be any object, is optional" do
-        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
+        expect(ICU::RatedPlayer.factory(1, :desc => 'Fischer, Robert').desc).to eq('Fischer, Robert')
+        expect(ICU::RatedPlayer.factory(1, :desc => 1).desc).to be_an_instance_of(Fixnum)
+        expect(ICU::RatedPlayer.factory(1, :desc => 1.0).desc).to be_an_instance_of(Float)
+        expect(ICU::RatedPlayer.factory(1).desc).to be_nil
       end
     end
 
@@ -108,58 +108,58 @@ module ICU
 
       it "should be returned in round order" do
         @p.add_result(@r2)
-        @p.results.size.should == 1
-        @p.results[0].should == @r2
+        expect(@p.results.size).to eq(1)
+        expect(@p.results[0]).to eq(@r2)
         @p.add_result(@r3)
-        @p.results.size.should == 2
-        @p.results[0].should == @r2
-        @p.results[1].should == @r3
+        expect(@p.results.size).to eq(2)
+        expect(@p.results[0]).to eq(@r2)
+        expect(@p.results[1]).to eq(@r3)
         @p.add_result(@r1)
-        @p.results.size.should == 3
-        @p.results[0].should == @r1
-        @p.results[1].should == @r2
-        @p.results[2].should == @r3
+        expect(@p.results.size).to eq(3)
+        expect(@p.results[0]).to eq(@r1)
+        expect(@p.results[1]).to eq(@r2)
+        expect(@p.results[2]).to eq(@r3)
       end
 
       it "the total score should stay consistent with results as they are added" do
-        @p.score.should == 0.0
+        expect(@p.score).to eq(0.0)
         @p.add_result(@r1)
-        @p.score.should == 1.0
+        expect(@p.score).to eq(1.0)
         @p.add_result(@r2)
-        @p.score.should == 1.0
+        expect(@p.score).to eq(1.0)
         @p.add_result(@r3)
-        @p.score.should == 1.5
+        expect(@p.score).to eq(1.5)
       end
     end
 
     context "calculation of K-factor" do
       it "should return 16 for players 2100 and above" do
-        ICU::RatedPlayer.kfactor(:rating => 2101, :start => '2010-07-10', :dob => '1955-11-09', :joined => '1974-01-01').should == 16
-        ICU::RatedPlayer.kfactor(:rating => 2100, :start => '2010-07-10', :dob => '1955-11-09', :joined => '1974-01-01').should == 16
-        ICU::RatedPlayer.kfactor(:rating => 2099, :start => '2010-07-10', :dob => '1955-11-09', :joined => '1974-01-01').should_not == 16
+        expect(ICU::RatedPlayer.kfactor(:rating => 2101, :start => '2010-07-10', :dob => '1955-11-09', :joined => '1974-01-01')).to eq(16)
+        expect(ICU::RatedPlayer.kfactor(:rating => 2100, :start => '2010-07-10', :dob => '1955-11-09', :joined => '1974-01-01')).to eq(16)
+        expect(ICU::RatedPlayer.kfactor(:rating => 2099, :start => '2010-07-10', :dob => '1955-11-09', :joined => '1974-01-01')).not_to eq(16)
       end
 
       it "should otherwise return 40 for players aged under 21 at the start of the tournament" do
-        ICU::RatedPlayer.kfactor(:rating => 2000, :start => '2010-07-10', :dob => '1989-07-11', :joined => '1999-01-01').should == 40
-        ICU::RatedPlayer.kfactor(:rating => 2000, :start => '2010-07-10', :dob => '1989-07-10', :joined => '1999-01-01').should_not == 40
-        ICU::RatedPlayer.kfactor(:rating => 2000, :start => '2010-07-10', :dob => '1989-07-09', :joined => '1999-01-01').should_not == 40
+        expect(ICU::RatedPlayer.kfactor(:rating => 2000, :start => '2010-07-10', :dob => '1989-07-11', :joined => '1999-01-01')).to eq(40)
+        expect(ICU::RatedPlayer.kfactor(:rating => 2000, :start => '2010-07-10', :dob => '1989-07-10', :joined => '1999-01-01')).not_to eq(40)
+        expect(ICU::RatedPlayer.kfactor(:rating => 2000, :start => '2010-07-10', :dob => '1989-07-09', :joined => '1999-01-01')).not_to eq(40)
       end
 
       it "should otherwise return 32 for players with under 8 years experience at the start of the tournament" do
-        ICU::RatedPlayer.kfactor(:rating => 2000, :start => '2010-07-10', :dob => '1989-01-01', :joined => '2002-07-11').should == 32
-        ICU::RatedPlayer.kfactor(:rating => 2000, :start => '2010-07-10', :dob => '1989-01-01', :joined => '2002-07-10').should_not == 32
-        ICU::RatedPlayer.kfactor(:rating => 2000, :start => '2010-07-10', :dob => '1989-01-01', :joined => '2002-07-09').should_not == 32
+        expect(ICU::RatedPlayer.kfactor(:rating => 2000, :start => '2010-07-10', :dob => '1989-01-01', :joined => '2002-07-11')).to eq(32)
+        expect(ICU::RatedPlayer.kfactor(:rating => 2000, :start => '2010-07-10', :dob => '1989-01-01', :joined => '2002-07-10')).not_to eq(32)
+        expect(ICU::RatedPlayer.kfactor(:rating => 2000, :start => '2010-07-10', :dob => '1989-01-01', :joined => '2002-07-09')).not_to eq(32)
       end
 
       it "should otherwise return 24" do
-        ICU::RatedPlayer.kfactor(:rating => 2000, :start => '2010-07-10', :dob => '1989-01-01', :joined => '2002-01-01').should == 24
+        expect(ICU::RatedPlayer.kfactor(:rating => 2000, :start => '2010-07-10', :dob => '1989-01-01', :joined => '2002-01-01')).to eq(24)
       end
       
       it "should throw an exception if required information is missing" do
-        lambda { ICU::RatedPlayer.kfactor(:start => '2010-07-10', :dob => '1989-01-01', :joined => '2002-01-01') }.should raise_error(/missing.*rating/)
-        lambda { ICU::RatedPlayer.kfactor(:rating => 2000, :dob => '1989-01-01', :joined => '2002-01-01') }.should raise_error(/missing.*start/)
-        lambda { ICU::RatedPlayer.kfactor(:rating => 2000, :start => '2010-07-10', :joined => '2002-01-01') }.should raise_error(/missing.*dob/)
-        lambda { ICU::RatedPlayer.kfactor(:rating => 2000, :start => '2010-07-10', :dob => '1989-01-01') }.should raise_error(/missing.*join/)
+        expect { ICU::RatedPlayer.kfactor(:start => '2010-07-10', :dob => '1989-01-01', :joined => '2002-01-01') }.to raise_error(/missing.*rating/)
+        expect { ICU::RatedPlayer.kfactor(:rating => 2000, :dob => '1989-01-01', :joined => '2002-01-01') }.to raise_error(/missing.*start/)
+        expect { ICU::RatedPlayer.kfactor(:rating => 2000, :start => '2010-07-10', :joined => '2002-01-01') }.to raise_error(/missing.*dob/)
+        expect { ICU::RatedPlayer.kfactor(:rating => 2000, :start => '2010-07-10', :dob => '1989-01-01') }.to raise_error(/missing.*join/)
       end
     end
 
@@ -170,38 +170,38 @@ module ICU
       end
 
       it "the same player number can't be added twice" do
-        lambda { @t.add_player(2) }.should_not raise_error
-        lambda { @t.add_player(2) }.should raise_error
+        expect { @t.add_player(2) }.not_to raise_error
+        expect { @t.add_player(2) }.to raise_error
       end
 
       it "parameters can be specified using strings, even with whitespace padding" do
         p = @t.add_player("  0  ", :rating => "  2000.5  ", :kfactor => "  20.5  ")
-        p.num.should == 0
-        p.num.should be_an_instance_of(Fixnum)
-        p.rating.should == 2000.5
-        p.rating.should be_an_instance_of(Float)
-        p.kfactor.should == 20.5
-        p.kfactor.should be_an_instance_of(Float)
+        expect(p.num).to eq(0)
+        expect(p.num).to be_an_instance_of(Fixnum)
+        expect(p.rating).to eq(2000.5)
+        expect(p.rating).to be_an_instance_of(Float)
+        expect(p.kfactor).to eq(20.5)
+        expect(p.kfactor).to be_an_instance_of(Float)
         p = @t.add_player("  -1  ", :rating => "  2000.5  ", :games => "  15  ")
-        p.games.should == 15
-        p.games.should be_an_instance_of(Fixnum)
+        expect(p.games).to eq(15)
+        expect(p.games).to be_an_instance_of(Fixnum)
       end
 
       it "the games parameter should not exceed 20" do
-        lambda { @t.add_player(2, :rating => 1500, :games => 20 ) }.should raise_error
+        expect { @t.add_player(2, :rating => 1500, :games => 20 ) }.to raise_error
       end
 
       it "adding different player types" do
         p = @t.add_player(3, :rating => 2000, :kfactor => 16)
-        p.type.should == :rated
+        expect(p.type).to eq(:rated)
         p = @t.add_player(4, :rating => 1600, :games => 10)
-        p.type.should == :provisional
+        expect(p.type).to eq(:provisional)
         p = @t.add_player(5)
-        p.type.should == :unrated
+        expect(p.type).to eq(:unrated)
         p = @t.add_player(6, :rating => 2500)
-        p.type.should == :foreign
-        lambda { @t.add_player(7, :rating => 2000, :kfactor => 16, :games => 10) }.should raise_error
-        lambda { t.add_plater(7, :kfactor => 16) }.should raise_error
+        expect(p.type).to eq(:foreign)
+        expect { @t.add_player(7, :rating => 2000, :kfactor => 16, :games => 10) }.to raise_error
+        expect { t.add_plater(7, :kfactor => 16) }.to raise_error
       end
     end
   end

data/spec/result_spec.rb

@@ -10,9 +10,9 @@ module ICU
 
       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_a_kind_of(ICU::RatedPlayer)
-        r.score.should == 1.0
+        expect(r.round).to eq(1)
+        expect(r.opponent).to be_a_kind_of(ICU::RatedPlayer)
+        expect(r.score).to eq(1.0)
       end
     end
 
@@ -22,20 +22,20 @@ module ICU
       end
 
       it "round numbers must be positive" do
-        lambda { ICU::RatedResult.new(0, 1, 'W') }.should raise_error(/invalid.*round number/i)
-        lambda { ICU::RatedResult.new(-1, 1, 'W') }.should raise_error(/invalid.*round number/i)
+        expect { ICU::RatedResult.new(0, 1, 'W') }.to raise_error(/invalid.*round number/i)
+        expect { ICU::RatedResult.new(-1, 1, 'W') }.to raise_error(/invalid.*round number/i)
       end
 
       it "the opponent must be an object, not a number" do
-        lambda { ICU::RatedResult.new(1, 0,  'W') }.should raise_error(/invalid.*class.*Fixnum/)
-        lambda { ICU::RatedResult.new(1, @p, 'W') }.should_not raise_error
+        expect { ICU::RatedResult.new(1, 0,  'W') }.to raise_error(/invalid.*class.*Fixnum/)
+        expect { ICU::RatedResult.new(1, @p, 'W') }.not_to raise_error
       end
 
       it "the score can be any of the usual suspects" do
-        ['W', 'w',  1,  1.0].each { |r| ICU::RatedResult.new(1, @p, r).score.should == 1.0 }
-        ['L', 'l',  0,  0.0].each { |r| ICU::RatedResult.new(1, @p, r).score.should == 0.0 }
-        ['D', 'd', '½', 0.5].each { |r| ICU::RatedResult.new(1, @p, r).score.should == 0.5 }
-        lambda { ICU::RatedResult.new(1, @p, '') }.should raise_error(/invalid.*score/)
+        ['W', 'w',  1,  1.0].each { |r| expect(ICU::RatedResult.new(1, @p, r).score).to eq(1.0) }
+        ['L', 'l',  0,  0.0].each { |r| expect(ICU::RatedResult.new(1, @p, r).score).to eq(0.0) }
+        ['D', 'd', '½', 0.5].each { |r| expect(ICU::RatedResult.new(1, @p, r).score).to eq(0.5) }
+        expect { ICU::RatedResult.new(1, @p, '') }.to raise_error(/invalid.*score/)
       end
     end
 
@@ -45,9 +45,9 @@ module ICU
       end
 
       it "should give the score from the opponent's perspective" do
-        ICU::RatedResult.new(1, @p, 'W').opponents_score.should == 0.0
-        ICU::RatedResult.new(1, @p, 'L').opponents_score.should == 1.0
-        ICU::RatedResult.new(1, @p, 'D').opponents_score.should == 0.5
+        expect(ICU::RatedResult.new(1, @p, 'W').opponents_score).to eq(0.0)
+        expect(ICU::RatedResult.new(1, @p, 'L').opponents_score).to eq(1.0)
+        expect(ICU::RatedResult.new(1, @p, 'D').opponents_score).to eq(0.5)
       end
     end
 
@@ -63,10 +63,10 @@ module ICU
       end
 
       it "should return true only if all attributes match" do
-        (@r1 == @r2).should be_true
-        (@r1 == @r3).should be_false
-        (@r1 == @r4).should be_false
-        (@r1 == @r5).should be_false
+        expect(@r1 == @r2).to be_truthy
+        expect(@r1 == @r3).to be_falsey
+        expect(@r1 == @r4).to be_falsey
+        expect(@r1 == @r5).to be_falsey
       end
     end
 
@@ -83,24 +83,24 @@ module ICU
       end
 
       it "it is OK but unnecessary to add the same result from the other players perspective" do
-        @t.player(10).results.size.should == 1
-        @t.player(20).results.size.should == 1
-        lambda { @t.add_result(1, 20, 10, 'L') }.should_not raise_error
-        @t.player(10).results.size.should == 1
-        @t.player(20).results.size.should == 1
+        expect(@t.player(10).results.size).to eq(1)
+        expect(@t.player(20).results.size).to eq(1)
+        expect { @t.add_result(1, 20, 10, 'L') }.not_to raise_error
+        expect(@t.player(10).results.size).to eq(1)
+        expect(@t.player(20).results.size).to eq(1)
       end
 
       it "adding results against other players in the same round will cause an exception" do
-        lambda { @t.add_result(1, 10, 30, 'W') }.should raise_error(/inconsistent/i)
-        lambda { @t.add_result(1, 10, 20, 'L') }.should raise_error(/inconsistent/i)
+        expect { @t.add_result(1, 10, 30, 'W') }.to raise_error(/inconsistent/i)
+        expect { @t.add_result(1, 10, 20, 'L') }.to raise_error(/inconsistent/i)
       end
 
       it "a player cannot have a result against himself/herself" do
-        lambda { @t.add_result(2, 10, 10, 'D') }.should raise_error(/players.*cannot.*sel[fv]/i)
+        expect { @t.add_result(2, 10, 10, 'D') }.to raise_error(/players.*cannot.*sel[fv]/i)
       end
 
       it "results are returned in score order irrespecive of the order they're added in" do
-        @t.player(0).results.map{ |r| r.round }.join(',').should == "1,2,3,4"
+        expect(@t.player(0).results.map{ |r| r.round }.join(',')).to eq("1,2,3,4")
       end
     end
   end

data/spec/tournament_spec.rb

@@ -5,25 +5,25 @@ module ICU
   describe RatedTournament do
     context "restrictions, or lack thereof, on attributes" do
       it "a tournament can have an optional description, such as a name, but any object is allowed" do
-        ICU::RatedTournament.new(:desc => 'Irish Championship 2010').desc.should == 'Irish Championship 2010'
-        ICU::RatedTournament.new(:desc => 1.0).desc.should be_an_instance_of(Float)
-        ICU::RatedTournament.new.desc.should be_nil
+        expect(ICU::RatedTournament.new(:desc => 'Irish Championship 2010').desc).to eq('Irish Championship 2010')
+        expect(ICU::RatedTournament.new(:desc => 1.0).desc).to be_an_instance_of(Float)
+        expect(ICU::RatedTournament.new.desc).to be_nil
       end
 
       it "a tournament can have an optional start date" do
-        ICU::RatedTournament.new(:start => '2010-01-01').start.should be_a(Date)
-        ICU::RatedTournament.new(:start => '03/06/2013').start.to_s.should == '2013-06-03'
-        ICU::RatedTournament.new(:start => Date.parse('1955-11-09')).start.to_s.should == '1955-11-09'
-        ICU::RatedTournament.new.start.should be_nil
-        lambda { ICU::RatedTournament.new(:start => 'error') }.should raise_error
+        expect(ICU::RatedTournament.new(:start => '2010-01-01').start).to be_a(Date)
+        expect(ICU::RatedTournament.new(:start => '03/06/2013').start.to_s).to eq('2013-06-03')
+        expect(ICU::RatedTournament.new(:start => Date.parse('1955-11-09')).start.to_s).to eq('1955-11-09')
+        expect(ICU::RatedTournament.new.start).to be_nil
+        expect { ICU::RatedTournament.new(:start => 'error') }.to raise_error
       end
 
       it "should have setters for the optional arguments" do
         t = ICU::RatedTournament.new
         t.desc=("Championship")
         t.start=("2010-07-01")
-        t.desc.should == "Championship"
-        t.start.should == Date.parse("2010-07-01")
+        expect(t.desc).to eq("Championship")
+        expect(t.start).to eq(Date.parse("2010-07-01"))
       end
     end
 
@@ -34,22 +34,22 @@ module ICU
 
       it "should set a K-factor of 16 for players with rating >= 2100" do
         @p = @t.add_player(1, :rating => 2200, :kfactor => { :dob => "1955-11-09", :joined => "1976-09-01" })
-        @p.kfactor.should == 16
+        expect(@p.kfactor).to eq(16)
       end
 
       it "should set a K-factor of 40 for players with rating < 2100 and age < 21" do
         @p = @t.add_player(1, :rating => 2000, :kfactor => { :dob => "1995-01-10", :joined => "2009-09-01" })
-        @p.kfactor.should == 40
+        expect(@p.kfactor).to eq(40)
       end
 
       it "should set a K-factor of 32 for players with rating < 2100, age >= 21 and experience < 8" do
         @p = @t.add_player(1, :rating => 2000, :kfactor => { :dob => "1975-01-10", :joined => "2005-09-01" })
-        @p.kfactor.should == 32
+        expect(@p.kfactor).to eq(32)
       end
 
       it "should set a K-factor of 24 for players with rating < 2100, age >= 21 and experience >= 8" do
         @p = @t.add_player(1, :rating => 2000, :kfactor => { :dob => "1975-01-10", :joined => "1995-09-01" })
-        @p.kfactor.should == 24
+        expect(@p.kfactor).to eq(24)
       end
     end
 
@@ -61,15 +61,15 @@ module ICU
       end
 
       it "should return the players in number-order" do
-        @t.players.size.should == 2
-        @t.players[0].num.should == 1
-        @t.players[1].num.should == 2
+        expect(@t.players.size).to eq(2)
+        expect(@t.players[0].num).to eq(1)
+        expect(@t.players[1].num).to eq(2)
       end
 
       it "should return the player object with the matching number" do
-        @t.player(1).num.should == 1
-        @t.player(2).num.should == 2
-        @t.player(3).should be_nil
+        expect(@t.player(1).num).to eq(1)
+        expect(@t.player(2).num).to eq(2)
+        expect(@t.player(3)).to be_nil
       end
     end
 
@@ -83,54 +83,54 @@ module ICU
 
       it "should be added to both players" do
         @t.add_result(1, @p1, @p2, 'L')
-        @p1.results.size.should == 1
-        @p1.results[0].should == ICU::RatedResult.new(1, @p2, 'L')
-        @p2.results.size.should == 1
-        @p2.results[0].should == ICU::RatedResult.new(1, @p1, 'W')
-        @p3.results.size.should == 0
+        expect(@p1.results.size).to eq(1)
+        expect(@p1.results[0]).to eq(ICU::RatedResult.new(1, @p2, 'L'))
+        expect(@p2.results.size).to eq(1)
+        expect(@p2.results[0]).to eq(ICU::RatedResult.new(1, @p1, 'W'))
+        expect(@p3.results.size).to eq(0)
         @t.add_result(2, @p3, @p2, 'W')
-        @p1.results.size.should == 1
-        @p2.results.size.should == 2
-        @p2.results[0].should == ICU::RatedResult.new(1, @p1, 'W')
-        @p2.results[1].should == ICU::RatedResult.new(2, @p3, 'L')
-        @p3.results.size.should == 1
-        @p3.results[0].should == ICU::RatedResult.new(2, @p2, 'W')
+        expect(@p1.results.size).to eq(1)
+        expect(@p2.results.size).to eq(2)
+        expect(@p2.results[0]).to eq(ICU::RatedResult.new(1, @p1, 'W'))
+        expect(@p2.results[1]).to eq(ICU::RatedResult.new(2, @p3, 'L'))
+        expect(@p3.results.size).to eq(1)
+        expect(@p3.results[0]).to eq(ICU::RatedResult.new(2, @p2, 'W'))
       end
 
       it "player objects or numbers can be used" do
-        lambda { @t.add_result(1, @p1, @p2, 'L') }.should_not raise_error
-        lambda { @t.add_result(2, 1, 2, 'W') }.should_not raise_error
+        expect { @t.add_result(1, @p1, @p2, 'L') }.not_to raise_error
+        expect { @t.add_result(2, 1, 2, 'W') }.not_to raise_error
       end
 
       it "the player numbers should exist already in the tournament" do
-        lambda { @t.add_result(2, 1, 4, 'W') }.should raise_error(/player number.*4/)
-        lambda { @t.add_result(2, 5, 2, 'W') }.should raise_error(/player number.*5/)
+        expect { @t.add_result(2, 1, 4, 'W') }.to raise_error(/player number.*4/)
+        expect { @t.add_result(2, 5, 2, 'W') }.to raise_error(/player number.*5/)
       end
 
       it "adding precisely the same result more than once is okay and changes nothing" do
         @t.add_result(1, @p1, @p2, 'L')
         @t.add_result(1, @p1, @p2, 'L')
         @t.add_result(1, @p2, @p1, 'W')
-        @p1.results.size.should == 1
-        @p2.results.size.should == 1
+        expect(@p1.results.size).to eq(1)
+        expect(@p2.results.size).to eq(1)
       end
 
       it "a player cannot have two different results in the same round" do
         @t.add_result(1, @p1, @p2, 'L')
-        lambda { @t.add_result(1, @p1, @p2, 'W') }.should raise_error(/inconsistent/)
-        lambda { @t.add_result(1, @p1, @p3, 'W') }.should raise_error(/inconsistent/)
-        lambda { @t.add_result(1, @p3, @p2, 'W') }.should raise_error(/inconsistent/)
+        expect { @t.add_result(1, @p1, @p2, 'W') }.to raise_error(/inconsistent/)
+        expect { @t.add_result(1, @p1, @p3, 'W') }.to raise_error(/inconsistent/)
+        expect { @t.add_result(1, @p3, @p2, 'W') }.to raise_error(/inconsistent/)
       end
 
       it "players cannot have results against themselves" do
-        lambda { @t.add_result(1, @p1, @p1, 'W') }.should raise_error(/against.*themsel(f|ves)/)
+        expect { @t.add_result(1, @p1, @p1, 'W') }.to raise_error(/against.*themsel(f|ves)/)
       end
     end
 
     context "#rate - corner case - tournament is empy" do
       it "should not throw an exception" do
         @t = ICU::RatedTournament.new
-        lambda { @t.rate! }.should_not raise_error
+        expect { @t.rate! }.not_to raise_error
       end
     end
 
@@ -151,29 +151,29 @@ module ICU
       it "before the tournament is rated" do
         (1..4).each do |num|
           p = @t.player(num)
-          p.expected_score.should == 0.0
-          p.rating_change.should == 0.0
-          p.new_rating.should == p.rating
+          expect(p.expected_score).to eq(0.0)
+          expect(p.rating_change).to eq(0.0)
+          expect(p.new_rating).to eq(p.rating)
         end
       end
 
       it "after the tournament is rated" do
         @t.rate!
 
-        @t.player(1).expected_score.should be_within(0.001).of(2.249)
-        @t.player(2).expected_score.should be_within(0.001).of(1.760)
-        @t.player(3).expected_score.should be_within(0.001).of(1.240)
-        @t.player(4).expected_score.should be_within(0.001).of(0.751)
+        expect(@t.player(1).expected_score).to be_within(0.001).of(2.249)
+        expect(@t.player(2).expected_score).to be_within(0.001).of(1.760)
+        expect(@t.player(3).expected_score).to be_within(0.001).of(1.240)
+        expect(@t.player(4).expected_score).to be_within(0.001).of(0.751)
 
-        @t.player(1).rating_change.should be_within(0.01).of(7.51)
-        @t.player(2).rating_change.should be_within(0.01).of(4.81)
-        @t.player(3).rating_change.should be_within(0.01).of(-7.21)
-        @t.player(4).rating_change.should be_within(0.01).of(-30.05)
+        expect(@t.player(1).rating_change).to be_within(0.01).of(7.51)
+        expect(@t.player(2).rating_change).to be_within(0.01).of(4.81)
+        expect(@t.player(3).rating_change).to be_within(0.01).of(-7.21)
+        expect(@t.player(4).rating_change).to be_within(0.01).of(-30.05)
 
-        @t.player(1).new_rating.should be_within(0.1).of(2207.5)
-        @t.player(2).new_rating.should be_within(0.1).of(2104.8)
-        @t.player(3).new_rating.should be_within(0.1).of(1992.8)
-        @t.player(4).new_rating.should be_within(0.1).of(1870.0)
+        expect(@t.player(1).new_rating).to be_within(0.1).of(2207.5)
+        expect(@t.player(2).new_rating).to be_within(0.1).of(2104.8)
+        expect(@t.player(3).new_rating).to be_within(0.1).of(1992.8)
+        expect(@t.player(4).new_rating).to be_within(0.1).of(1870.0)
       end
     end
 
@@ -229,8 +229,8 @@ module ICU
         ].each do |item|
           num, expected_score, new_rating = item
           p = @t.player(num)
-          p.expected_score.should be_within(0.001).of(expected_score)
-          p.new_rating.should be_within(0.5).of(new_rating)
+          expect(p.expected_score).to be_within(0.001).of(expected_score)
+          expect(p.new_rating).to be_within(0.5).of(new_rating)
         end
       end
 
@@ -245,8 +245,8 @@ module ICU
         ].each do |item|
           num, ytd_performance, tournament_performance = item
           p = @t.player(num)
-          p.performance.should_not be_within(0.5).of(ytd_performance)
-          p.performance.should be_within(0.5).of(tournament_performance)
+          expect(p.performance).not_to be_within(0.5).of(ytd_performance)
+          expect(p.performance).to be_within(0.5).of(tournament_performance)
         end
       end
     end
@@ -263,10 +263,10 @@ module ICU
       end
 
       it "should get same results as ICU rating database" do
-        @t.player(1).expected_score.should be_within(0.001).of(1.689)
-        @t.player(2).expected_score.should be_within(0.001).of(1.311)
-        @t.player(1).new_rating.should be_within(0.5).of(1378)
-        @t.player(2).new_rating.should be_within(0.5).of(1261)
+        expect(@t.player(1).expected_score).to be_within(0.001).of(1.689)
+        expect(@t.player(2).expected_score).to be_within(0.001).of(1.311)
+        expect(@t.player(1).new_rating).to be_within(0.5).of(1378)
+        expect(@t.player(2).new_rating).to be_within(0.5).of(1261)
       end
     end
 
@@ -342,9 +342,9 @@ module ICU
         (3..20).each do |num|
           unless num == 13
             p = @t.player(num)
-            p.expected_score.should_not == 0.0
-            p.should_not respond_to(:rating_change)
-            p.new_rating.should == p.rating
+            expect(p.expected_score).not_to eq(0.0)
+            expect(p).not_to respond_to(:rating_change)
+            expect(p.new_rating).to eq(p.rating)
           end
         end
       end
@@ -371,7 +371,7 @@ module ICU
         ].each do |item|
           num, performance = item
           p = @t.player(num)
-          p.performance.should == performance
+          expect(p.performance).to eq(performance)
         end
       end
 
@@ -379,13 +379,13 @@ module ICU
         af = @t.player(1)
         pc = @t.player(2)
 
-        af.score.should == 4.5
-        af.expected_score.should be_within(0.001).of(6.054)
-        af.new_rating.should be_within(0.5).of(2080)
+        expect(af.score).to eq(4.5)
+        expect(af.expected_score).to be_within(0.001).of(6.054)
+        expect(af.new_rating).to be_within(0.5).of(2080)
 
-        pc.score.should == 4.0
-        pc.expected_score.should be_within(0.001).of(3.685)
-        pc.new_rating.should be_within(0.5).of(1984)
+        expect(pc.score).to eq(4.0)
+        expect(pc.expected_score).to be_within(0.001).of(3.685)
+        expect(pc.new_rating).to be_within(0.5).of(1984)
       end
     end
 
@@ -534,9 +534,9 @@ module ICU
         ].each do |item|
           num, expected_score, new_rating = item
           p = @t.player(num)
-          p.expected_score.should be_within(0.01).of(expected_score)
-          p.new_rating.should be_within(0.5).of(new_rating)
-          p.results.inject(p.rating){ |t,r| t + r.rating_change }.should be_within(0.5).of(new_rating)
+          expect(p.expected_score).to be_within(0.01).of(expected_score)
+          expect(p.new_rating).to be_within(0.5).of(new_rating)
+          expect(p.results.inject(p.rating){ |t,r| t + r.rating_change }).to be_within(0.5).of(new_rating)
         end
       end
 
@@ -547,15 +547,15 @@ module ICU
         ].each do |item|
           num, expected_score, new_rating = item
           p = @t.player(num)
-          p.expected_score.should be_within(0.01).of(expected_score)
-          p.new_rating.should be_within(0.5).of(new_rating)
+          expect(p.expected_score).to be_within(0.01).of(expected_score)
+          expect(p.new_rating).to be_within(0.5).of(new_rating)
         end
       end
 
       it "players who didn't play any rated games should not change their rating" do
         p = @t.player(15)
-        p.expected_score.should == 0
-        p.new_rating.should == p.rating
+        expect(p.expected_score).to eq(0)
+        expect(p.new_rating).to eq(p.rating)
       end
     end
 
@@ -608,8 +608,8 @@ module ICU
         ].each do |item|
           num, expected_score, new_rating = item
           p = @t.player(num)
-          p.expected_score.should be_within(0.01).of(expected_score)
-          p.new_rating.should be_within(0.5).of(new_rating)
+          expect(p.expected_score).to be_within(0.01).of(expected_score)
+          expect(p.new_rating).to be_within(0.5).of(new_rating)
         end
       end
     end
@@ -660,10 +660,10 @@ module ICU
         ].each do |item|
           num, score, expected_score, new_rating, bonus = item
           p = @t.player(num)
-          p.score.should == score
-          p.expected_score.should be_within(0.01).of(expected_score)
-          p.new_rating.should be_within(0.5).of(new_rating)
-          p.bonus.should == bonus
+          expect(p.score).to eq(score)
+          expect(p.expected_score).to be_within(0.01).of(expected_score)
+          expect(p.new_rating).to be_within(0.5).of(new_rating)
+          expect(p.bonus).to eq(bonus)
         end
       end
 
@@ -679,11 +679,11 @@ module ICU
           num, pre_bonus = item
           p = @t.player(num)
           if pre_bonus
-            p.pb_rating.should be_kind_of Fixnum
-            p.pb_performance.should be_kind_of Fixnum
+            expect(p.pb_rating).to be_kind_of Fixnum
+            expect(p.pb_performance).to be_kind_of Fixnum
           else
-            p.pb_rating.should be_nil
-            p.pb_performance.should be_nil
+            expect(p.pb_rating).to be_nil
+            expect(p.pb_performance).to be_nil
           end
         end
       end
@@ -733,22 +733,22 @@ module ICU
         ].each do |item|
           num, score, expected_score, performance = item
           p = @t.player(num)
-          p.score.should == score
-          p.expected_score.should be_within(0.01).of(expected_score)
-          p.performance.should be_within(0.5).of(performance)
+          expect(p.score).to eq(score)
+          expect(p.expected_score).to be_within(0.01).of(expected_score)
+          expect(p.performance).to be_within(0.5).of(performance)
           if num == 1
-            p.new_rating.should be_within(0.5).of(1836)
-            p.bonus.should == 71
+            expect(p.new_rating).to be_within(0.5).of(1836)
+            expect(p.bonus).to eq(71)
           else
-            p.new_rating.should == p.rating
+            expect(p.new_rating).to eq(p.rating)
           end
         end
       end
 
       it "players eligible for a bonus should have pre-bonus data" do
         p = @t.player(1)
-        p.pb_rating.should be_kind_of Fixnum
-        p.pb_performance.should be_kind_of Fixnum
+        expect(p.pb_rating).to be_kind_of Fixnum
+        expect(p.pb_performance).to be_kind_of Fixnum
       end
     end
 
@@ -798,11 +798,11 @@ module ICU
         ].each do |item|
           num, score, expected_score, performance, new_rating, bonus = item
           p = @t.player(num)
-          p.score.should == score
-          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)
+          expect(p.score).to eq(score)
+          expect(p.bonus).to eq(bonus) if bonus
+          expect(p.performance).to be_within(0.5).of(performance)
+          expect(p.expected_score).to be_within(0.01).of(expected_score)
+          expect(p.new_rating).to be_within(0.5).of(new_rating)
         end
       end
     end
@@ -858,11 +858,11 @@ module ICU
         @m.each do |item|
           num, score, expected_score, performance, new_rating, bonus = item
           p = @t.player(num)
-          p.score.should == score
-          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)
+          expect(p.score).to eq(score)
+          expect(p.bonus).to eq(bonus) if bonus
+          expect(p.performance).to be_within(num == 2 ? 0.6 : 0.5).of(performance)
+          expect(p.expected_score).to be_within(0.01).of(expected_score)
+          expect(p.new_rating).to be_within(0.5).of(new_rating)
         end
       end
 
@@ -871,11 +871,11 @@ module ICU
         @m.each do |item|
           num, score, expected_score, performance, new_rating, bonus = item
           p = @t.player(num)
-          p.score.should == score
-          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)
+          expect(p.score).to eq(score)
+          expect(p.bonus).to eq(bonus) if bonus
+          expect(p.performance).to be_within(num == 2 ? 0.6 : 0.5).of(performance)
+          expect(p.expected_score).to be_within(0.01).of(expected_score)
+          expect(p.new_rating).to be_within(0.5).of(new_rating)
         end
       end
 
@@ -885,11 +885,11 @@ module ICU
         @m.each do |item|
           num, score, expected_score, performance, new_rating, bonus = item
           p = @t.player(num)
-          p.score.should == score
-          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)
+          expect(p.score).to eq(score)
+          expect(p.bonus).to eq(0) if bonus
+          expect(p.performance).not_to be_within(1.0).of(performance)
+          expect(p.expected_score).not_to be_within(0.01).of(expected_score)
+          expect(p.new_rating).not_to be_within(1.0).of(new_rating)
         end
       end
     end
@@ -928,16 +928,16 @@ module ICU
         ].each do |item|
           num, expected_score, new_rating = item
           p = @t.player(num)
-          p.expected_score.should be_within(0.01).of(expected_score)
-          p.new_rating.should be_within(0.5).of(new_rating)
+          expect(p.expected_score).to be_within(0.01).of(expected_score)
+          expect(p.new_rating).to be_within(0.5).of(new_rating)
         end
       end
 
       it "should not rate players that have no rateable games" do
         [4, 5, 6].each do |num|
           p = @t.player(num)
-          p.expected_score.should == 0.0
-          p.new_rating.should be_nil
+          expect(p.expected_score).to eq(0.0)
+          expect(p.new_rating).to be_nil
         end
       end
     end
@@ -1006,19 +1006,19 @@ module ICU
 
       it "should behave like the Access system" do
         @t.rate!
-        @p1.new_rating.should be_within(0.5).of(1511)
-        @p1.expected_score.should be_within(0.001).of(2.868)
-        @p1.bonus.should == 0
-        @p2.new_rating.should be_within(0.5).of(1705)
+        expect(@p1.new_rating).to be_within(0.5).of(1511)
+        expect(@p1.expected_score).to be_within(0.001).of(2.868)
+        expect(@p1.bonus).to eq(0)
+        expect(@p2.new_rating).to be_within(0.5).of(1705)
       end
 
       it "should behave like ratings.ciu.ie" do
         @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)
-        @p1.bonus.should be_within(1).of(63)
-        @p2.new_rating.should be_within(0.5).of(1722)
+        expect(@p1.new_rating).to be_within(0.5).of(1603)
+        expect(@p1.expected_score).to be_within(0.001).of(2.868)
+        expect(@p1.bonus).to be_within(1).of(63)
+        expect(@p2.new_rating).to be_within(0.5).of(1722)
       end
     end
 
@@ -1222,69 +1222,69 @@ module ICU
       end
 
       it "should be setup properly" do
-        @p.desc.should  == "Jonathon Peoples"
-        @o1.desc.should == "Ross Beatty"
-        @o2.desc.should == "Shane Melaugh"
-        @o3.desc.should == "Piotr Baczkowski"
-        @o4.desc.should == "Tom McGrath"
-        @o5.desc.should == "Joe McEntegert"
-        @o6.desc.should == "David Halpenny"
+        expect(@p.desc).to  eq("Jonathon Peoples")
+        expect(@o1.desc).to eq("Ross Beatty")
+        expect(@o2.desc).to eq("Shane Melaugh")
+        expect(@o3.desc).to eq("Piotr Baczkowski")
+        expect(@o4.desc).to eq("Tom McGrath")
+        expect(@o5.desc).to eq("Joe McEntegert")
+        expect(@o6.desc).to eq("David Halpenny")
 
-        @p.type.should  == :unrated
-        @o1.type.should == :provisional
-        @o2.type.should == :rated
-        @o3.type.should == :provisional
-        @o4.type.should == :rated
-        @o5.type.should == :unrated
-        @o6.type.should == :provisional
+        expect(@p.type).to  eq(:unrated)
+        expect(@o1.type).to eq(:provisional)
+        expect(@o2.type).to eq(:rated)
+        expect(@o3.type).to eq(:provisional)
+        expect(@o4.type).to eq(:rated)
+        expect(@o5.type).to eq(:unrated)
+        expect(@o6.type).to eq(:provisional)
 
-        @o2.rating.should == 683
-        @o4.rating.should == 1058
+        expect(@o2.rating).to eq(683)
+        expect(@o4.rating).to eq(1058)
 
-        @t.iterations1.should be_nil
-        @t.iterations2.should be_nil
+        expect(@t.iterations1).to be_nil
+        expect(@t.iterations2).to be_nil
       end
 
       it "should produce inconsistent results with original algorithm" do
         @t.rate!
 
-        @p.new_rating.should be_within(0.5).of(763)  # the original calculation
+        expect(@p.new_rating).to be_within(0.5).of(763)  # the original calculation
 
-        @o1.new_rating.should == @o1.performance
-        @o2.bonus.should == 0
-        @o3.new_rating.should == @o3.performance
-        @o4.bonus.should == 0
-        @o5.new_rating.should == @o5.performance
-        @o6.new_rating.should == @o6.performance
+        expect(@o1.new_rating).to eq(@o1.performance)
+        expect(@o2.bonus).to eq(0)
+        expect(@o3.new_rating).to eq(@o3.performance)
+        expect(@o4.bonus).to eq(0)
+        expect(@o5.new_rating).to eq(@o5.performance)
+        expect(@o6.new_rating).to eq(@o6.performance)
 
         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)
+        expect(average_of_ratings).not_to be_within(0.5).of(@p.new_rating)
 
-        @t.iterations1.should be > 1
-        @t.iterations2.should == 1
+        expect(@t.iterations1).to be > 1
+        expect(@t.iterations2).to eq(1)
       end
 
       it "should produce consistent results with version 1 algorithm" do
         @t.rate!(version: 1)
 
-        @p.new_rating.should_not be_within(0.5).of(763)  # the new calculation is different
+        expect(@p.new_rating).not_to be_within(0.5).of(763)  # the new calculation is different
 
-        @o1.new_rating.should == @o1.performance
-        @o2.bonus.should == 0
-        @o3.new_rating.should == @o3.performance
-        @o4.bonus.should == 0
-        @o5.new_rating.should == @o5.performance
-        @o6.new_rating.should == @o6.performance
+        expect(@o1.new_rating).to eq(@o1.performance)
+        expect(@o2.bonus).to eq(0)
+        expect(@o3.new_rating).to eq(@o3.performance)
+        expect(@o4.bonus).to eq(0)
+        expect(@o5.new_rating).to eq(@o5.performance)
+        expect(@o6.new_rating).to eq(@o6.performance)
 
         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)
+        expect(average_of_ratings).to be_within(0.5).of(@p.new_rating)
 
-        @t.iterations1.should be > 1
-        @t.iterations2.should be > 1
+        expect(@t.iterations1).to be > 1
+        expect(@t.iterations2).to be > 1
       end
     end
 
@@ -1998,111 +1998,111 @@ module ICU
       end
 
       it "should be setup properly" do
-        @p.desc.should  == "Sasha-Ettore Faleschini"
-        @o1.desc.should == "John P. Dunne"
-        @o2.desc.should == "Jack Fitzgerald"
-        @o3.desc.should == "Mikolaj Glegolski"
-        @o4.desc.should == "Daniel Boland"
-        @o5.desc.should == "Noel Keating"
-        @o6.desc.should == "Cathal Minnock"
-
-        @p.type.should  == :unrated
-        @o1.type.should == :rated
-        @o2.type.should == :rated
-        @o3.type.should == :rated
-        @o4.type.should == :rated
-        @o5.type.should == :rated
-        @o6.type.should == :rated
-
-        @o1.rating.should == 946
-        @o2.rating.should == 913
-        @o3.rating.should == 841
-        @o4.rating.should == 793
-        @o5.rating.should == 667
-        @o6.rating.should == 917
-
-        @t.iterations1.should be_nil
-        @t.iterations2.should be_nil
+        expect(@p.desc).to  eq("Sasha-Ettore Faleschini")
+        expect(@o1.desc).to eq("John P. Dunne")
+        expect(@o2.desc).to eq("Jack Fitzgerald")
+        expect(@o3.desc).to eq("Mikolaj Glegolski")
+        expect(@o4.desc).to eq("Daniel Boland")
+        expect(@o5.desc).to eq("Noel Keating")
+        expect(@o6.desc).to eq("Cathal Minnock")
+
+        expect(@p.type).to  eq(:unrated)
+        expect(@o1.type).to eq(:rated)
+        expect(@o2.type).to eq(:rated)
+        expect(@o3.type).to eq(:rated)
+        expect(@o4.type).to eq(:rated)
+        expect(@o5.type).to eq(:rated)
+        expect(@o6.type).to eq(:rated)
+
+        expect(@o1.rating).to eq(946)
+        expect(@o2.rating).to eq(913)
+        expect(@o3.rating).to eq(841)
+        expect(@o4.rating).to eq(793)
+        expect(@o5.rating).to eq(667)
+        expect(@o6.rating).to eq(917)
+
+        expect(@t.iterations1).to be_nil
+        expect(@t.iterations2).to be_nil
       end
 
       it "should produce inconsistent results with original algorithm" do
         @t.rate!
 
-        @p.new_rating.should == @p.performance
+        expect(@p.new_rating).to eq(@p.performance)
 
-        @o1.bonus.should == 16
-        @o2.bonus.should == 0
-        @o3.bonus.should == 0
-        @o4.bonus.should == 0
-        @o5.bonus.should == 0
-        @o6.bonus.should == 0
+        expect(@o1.bonus).to eq(16)
+        expect(@o2.bonus).to eq(0)
+        expect(@o3.bonus).to eq(0)
+        expect(@o4.bonus).to eq(0)
+        expect(@o5.bonus).to eq(0)
+        expect(@o6.bonus).to eq(0)
 
         ratings = [@o1, @o2, @o3, @o4, @o5, @o6].map { |o| o.bonus == 0 ? o.rating : o.new_rating }
 
         performance = ratings.inject(0.0){ |m,r| m = m + r } / 6.0 - 400.0 / 3.0
-        performance.should_not be_within(0.5).of(@p.new_rating)
+        expect(performance).not_to be_within(0.5).of(@p.new_rating)
 
-        @t.iterations1.should be > 1
-        @t.iterations2.should == 1
+        expect(@t.iterations1).to be > 1
+        expect(@t.iterations2).to eq(1)
       end
 
       it "should produce inconsistent results with version 1 algorithm" do
         @t.rate!(version: 1)
 
-        @p.new_rating.should == @p.performance
+        expect(@p.new_rating).to eq(@p.performance)
 
-        @o1.bonus.should == 16
-        @o2.bonus.should == 0
-        @o3.bonus.should == 0
-        @o4.bonus.should == 0
-        @o5.bonus.should == 0
-        @o6.bonus.should == 0
+        expect(@o1.bonus).to eq(16)
+        expect(@o2.bonus).to eq(0)
+        expect(@o3.bonus).to eq(0)
+        expect(@o4.bonus).to eq(0)
+        expect(@o5.bonus).to eq(0)
+        expect(@o6.bonus).to eq(0)
 
         ratings = [@o1, @o2, @o3, @o4, @o5, @o6].map { |o| o.bonus == 0 ? o.rating : o.new_rating }
 
         performance = ratings.inject(0.0){ |m,r| m = m + r } / 6.0 - 400.0 / 3.0
-        performance.should_not be_within(0.5).of(@p.new_rating)
+        expect(performance).not_to be_within(0.5).of(@p.new_rating)
 
-        @t.iterations1.should be > 1
-        @t.iterations2.should be > 1
+        expect(@t.iterations1).to be > 1
+        expect(@t.iterations2).to be > 1
       end
 
       it "should produce consistent results with version 2 algorithm" do
         @t.rate!(version: 2)
 
-        @o1.bonus.should == 0  # no bonus this time because it comes from 2nd phase
-        @o2.bonus.should == 0
-        @o3.bonus.should == 0
-        @o4.bonus.should == 0
-        @o5.bonus.should == 0
-        @o6.bonus.should == 0
+        expect(@o1.bonus).to eq(0)  # no bonus this time because it comes from 2nd phase
+        expect(@o2.bonus).to eq(0)
+        expect(@o3.bonus).to eq(0)
+        expect(@o4.bonus).to eq(0)
+        expect(@o5.bonus).to eq(0)
+        expect(@o6.bonus).to eq(0)
 
         ratings = [@o1, @o2, @o3, @o4, @o5, @o6].map { |o| o.bonus == 0 ? o.rating : o.new_rating }
 
         performance = ratings.inject(0.0){ |m,r| m = m + r } / 6.0 - 400.0 / 3.0
-        performance.should be_within(0.5).of(@p.new_rating)
+        expect(performance).to be_within(0.5).of(@p.new_rating)
 
-        @t.iterations1.should be > 1
-        @t.iterations2.should be > 1
+        expect(@t.iterations1).to be > 1
+        expect(@t.iterations2).to be > 1
       end
 
       it "should produce consistent results with version 3 algorithm" do
         @t.rate!(version: 3)
 
-        @o1.bonus.should == 0  # no bonus this time because it comes from 2nd phase
-        @o2.bonus.should == 0
-        @o3.bonus.should == 0
-        @o4.bonus.should == 0
-        @o5.bonus.should == 0
-        @o6.bonus.should == 0
+        expect(@o1.bonus).to eq(0)  # no bonus this time because it comes from 2nd phase
+        expect(@o2.bonus).to eq(0)
+        expect(@o3.bonus).to eq(0)
+        expect(@o4.bonus).to eq(0)
+        expect(@o5.bonus).to eq(0)
+        expect(@o6.bonus).to eq(0)
 
         ratings = [@o1, @o2, @o3, @o4, @o5, @o6].map { |o| o.bonus == 0 ? o.rating : o.new_rating }
 
         performance = ratings.inject(0.0){ |m,r| m = m + r } / 6.0 - 400.0 / 3.0
-        performance.should be_within(0.5).of(@p.new_rating)
+        expect(performance).to be_within(0.5).of(@p.new_rating)
 
-        @t.iterations1.should be > 1
-        @t.iterations2.should be > 1
+        expect(@t.iterations1).to be > 1
+        expect(@t.iterations2).to be > 1
       end
     end
 
@@ -2210,50 +2210,50 @@ module ICU
       end
 
       it "should be setup properly" do
-        @p.desc.should  == "Deirdre Turner"
-        @o1.desc.should == "John P. Dunne"
-        @o2.desc.should == "Jordan O'Sullivan"
-        @o3.desc.should == "Ruairi Freeman"
-        @o4.desc.should == "Joe Cronin"
-        @o5.desc.should == "Jeffrey Alfred"
-        @o6.desc.should == "Roisin MacNamee"
-
-        @p.type.should  == :unrated
-        @o1.type.should == :rated
-        @o2.type.should == :unrated
-        @o3.type.should == :rated
-        @o4.type.should == :rated
-        @o5.type.should == :rated
-        @o6.type.should == :provisional
-
-        @o1.rating.should == 980
-        @o2.should_not respond_to(:rating)
-        @o3.rating.should == 537
-        @o4.rating.should == 682
-        @o5.rating.should == 1320
-        @o6.rating.should == 460
-
-        @t.iterations1.should be_nil
-        @t.iterations2.should be_nil
+        expect(@p.desc).to  eq("Deirdre Turner")
+        expect(@o1.desc).to eq("John P. Dunne")
+        expect(@o2.desc).to eq("Jordan O'Sullivan")
+        expect(@o3.desc).to eq("Ruairi Freeman")
+        expect(@o4.desc).to eq("Joe Cronin")
+        expect(@o5.desc).to eq("Jeffrey Alfred")
+        expect(@o6.desc).to eq("Roisin MacNamee")
+
+        expect(@p.type).to  eq(:unrated)
+        expect(@o1.type).to eq(:rated)
+        expect(@o2.type).to eq(:unrated)
+        expect(@o3.type).to eq(:rated)
+        expect(@o4.type).to eq(:rated)
+        expect(@o5.type).to eq(:rated)
+        expect(@o6.type).to eq(:provisional)
+
+        expect(@o1.rating).to eq(980)
+        expect(@o2).not_to respond_to(:rating)
+        expect(@o3.rating).to eq(537)
+        expect(@o4.rating).to eq(682)
+        expect(@o5.rating).to eq(1320)
+        expect(@o6.rating).to eq(460)
+
+        expect(@t.iterations1).to be_nil
+        expect(@t.iterations2).to be_nil
       end
 
       it "should produce consistent results with version 2 algorithm" do
         @t.rate!(version: 2)
 
-        @p.new_rating.should == @p.performance
+        expect(@p.new_rating).to eq(@p.performance)
 
-        @o1.bonus.should == 23
-        @o3.bonus.should == 0
-        @o4.bonus.should == 0
-        @o5.bonus.should == 0
+        expect(@o1.bonus).to eq(23)
+        expect(@o3.bonus).to eq(0)
+        expect(@o4.bonus).to eq(0)
+        expect(@o5.bonus).to eq(0)
 
         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.1).of(@p.new_rating)
+        expect(performance).to be_within(0.1).of(@p.new_rating)
 
-        @t.iterations1.should be > 1
-        @t.iterations2.should be > 1
+        expect(@t.iterations1).to be > 1
+        expect(@t.iterations2).to be > 1
       end
     end
 
@@ -2393,56 +2393,56 @@ module ICU
       end
 
       it "should be setup properly" do
-        @p.desc.should  == "Kieran O'Riordan"
-        @o1.desc.should == "Jonathan Kiely"
-        @o2.desc.should == "Donal O'Hallahan"
-        @o3.desc.should == "Arnaud, Aoustin"
-        @o4.desc.should == "Ronan Magee"
-        @o5.desc.should == "Barry Foran"
-        @o6.desc.should == "Henk De Jonge"
-
-        @p.type.should  == :rated
-        @o1.type.should == :rated
-        @o2.type.should == :rated
-        @o3.type.should == :rated
-        @o4.type.should == :rated
-        @o5.type.should == :rated
-        @o6.type.should == :rated
-
-        @p.rating.should  == 1883
-        @o1.rating.should == 1113
-        @o2.rating.should == 1465
-        @o3.rating.should == 1984
-        @o4.rating.should == 1957
-        @o5.rating.should == 1417
-        @o6.rating.should == 1977
-
-        @t.iterations1.should be_nil
-        @t.iterations2.should be_nil
+        expect(@p.desc).to  eq("Kieran O'Riordan")
+        expect(@o1.desc).to eq("Jonathan Kiely")
+        expect(@o2.desc).to eq("Donal O'Hallahan")
+        expect(@o3.desc).to eq("Arnaud, Aoustin")
+        expect(@o4.desc).to eq("Ronan Magee")
+        expect(@o5.desc).to eq("Barry Foran")
+        expect(@o6.desc).to eq("Henk De Jonge")
+
+        expect(@p.type).to  eq(:rated)
+        expect(@o1.type).to eq(:rated)
+        expect(@o2.type).to eq(:rated)
+        expect(@o3.type).to eq(:rated)
+        expect(@o4.type).to eq(:rated)
+        expect(@o5.type).to eq(:rated)
+        expect(@o6.type).to eq(:rated)
+
+        expect(@p.rating).to  eq(1883)
+        expect(@o1.rating).to eq(1113)
+        expect(@o2.rating).to eq(1465)
+        expect(@o3.rating).to eq(1984)
+        expect(@o4.rating).to eq(1957)
+        expect(@o5.rating).to eq(1417)
+        expect(@o6.rating).to eq(1977)
+
+        expect(@t.iterations1).to be_nil
+        expect(@t.iterations2).to be_nil
       end
 
       it "player should not get a bonus because his pre-bonus performance is lower than his post-bonus rating" do
         @t.rate!(version: 2)
 
-        @p.new_rating.should be_within(0.5).of(1924)
+        expect(@p.new_rating).to be_within(0.5).of(1924)
 
-        @p.bonus.should  == 0
-        @o1.bonus.should == 0
-        @o2.bonus.should == 0
-        @o3.bonus.should == 0
-        @o4.bonus.should == 0
-        @o5.bonus.should == 0
-        @o6.bonus.should == 0
+        expect(@p.bonus).to  eq(0)
+        expect(@o1.bonus).to eq(0)
+        expect(@o2.bonus).to eq(0)
+        expect(@o3.bonus).to eq(0)
+        expect(@o4.bonus).to eq(0)
+        expect(@o5.bonus).to eq(0)
+        expect(@o6.bonus).to eq(0)
 
         threshold = @p.rating + 32 + 3 * (@p.results.size - 4)
 
         # He would have got a bonus ...
         pre_cap_bonus = ((@p.pb_rating - threshold).round * 1.25).round
-        pre_cap_bonus.should be > 0
+        expect(pre_cap_bonus).to be > 0
 
         # ... if it wasn't for his low performance.
         post_cap_bonus = @p.pb_performance - @p.pb_rating
-        post_cap_bonus.should be < 0
+        expect(post_cap_bonus).to be < 0
       end
     end
 
@@ -2614,11 +2614,11 @@ module ICU
       end
 
       it "should not converge with version 2 settings" do
-        lambda { @t.rate!(version: 2) }.should raise_error(/performance rating estimation did not converge/)
+        expect { @t.rate!(version: 2) }.to raise_error(/performance rating estimation did not converge/)
       end
 
       it "should converge with version 3 settings (higher maximum number of iterations)" do
-        lambda { @t.rate!(version: 3) }.should_not raise_error
+        expect { @t.rate!(version: 3) }.not_to raise_error
       end
     end
   end