icu_tournament 1.9.3 → 1.10.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a381a56e723de1cfb4dd03d9b48d30bec0392949664a0ec79fb8436c293e0eef
+  data.tar.gz: c3e6cb085ec3023bed84e7b9a1a081b542572150e63ee17a8c518cb37c36a46c
+SHA512:
+  metadata.gz: 79f24f02e5cc402a54b88dc3843666277ea05ce0713b3ed3130294518a04579693a8779fe0a5e38b8890ee69b604d79b4864ab830226db40812812b3d15d3d37
+  data.tar.gz: 6d3db507492a9cccbdab10be94fc1fbd8de9b2a3f436c3746443c053eeec1b9157797fb23ee3dc3b4765110ce427b49d5a5e4ca53101f723828517af454063c5

data/README.rdoc

@@ -4,7 +4,7 @@ For reading or writing files of chess tournament data. Original project name on
 
 == Install
 
-For Ruby 1.9.2, 1.9.3, 2.0.0 (version 1.1.2 was the last compatible with Ruby 1.8.7).
+For Ruby 1.9.2, 1.9.3, 2.0.0, 2.2.1 (version 1.1.2 was the last compatible with Ruby 1.8.7).
 
   gem install icu_tournament
 
@@ -74,3 +74,7 @@ On error, the _parse_ method returns _nil_ and an error message can be retrieved
 == Author
 
 Mark Orr, rating officer for the Irish Chess Union (ICU[http://icu.ie]).
+
+== Current Maintainer
+
+David Murray, rating officer for the Irish Chess Union. Contact ratings@icu.ie.

data/lib/icu_tournament/player.rb

@@ -119,7 +119,6 @@ module ICU
     # Canonicalise and set the first name(s).
     def first_name=(first_name)
       name = Name.new(first_name, 'Last')
-      raise "invalid first name" unless name.first.length > 0
       @first_name = name.first
     end
 
@@ -235,4 +234,4 @@ module ICU
       end
     end
   end
-end
+end

data/lib/icu_tournament/result.rb

@@ -129,7 +129,7 @@ module ICU
     def opponent=(opponent)
       @opponent = case opponent
         when nil     then nil
-        when Fixnum  then opponent
+        when Integer then opponent
         when /^\s*$/ then nil
         else opponent.to_i
       end
@@ -198,4 +198,4 @@ module ICU
       true
     end
   end
-end
+end

data/lib/icu_tournament/tournament.rb

@@ -379,6 +379,44 @@ module ICU
       self
     end
 
+    # Make an educated guess at round dates.
+    # If only one round, it is on the start date
+    # If start and end date match, all rounds are on that day
+    # If there are exactly two rounds, round 1 on the start day, round 2 on the finish day
+    # If there are between n and 2n rounds in n consecutive days, then
+    #    start with one round a day, switch to two rounds a day when that's needed
+    # If there are 7 rounds Saturday - Sunday > 1 week: two on the first 3 weekend dates, one on the final Sunday
+    # This covers most Irish tournaments. Returns an empty array if it could not guess
+    def guess_round_dates
+      return [@start] if rounds == 1
+      return [] if @finish.nil?
+
+      round_dates = []
+      start_date = ::Date.parse(@start)
+      finish_date = ::Date.parse(@finish)
+      ndays = (finish_date - start_date).to_i + 1
+      if ndays == 1
+        rounds.times { round_dates << start }
+      elsif rounds == 2
+        round_dates << start
+        round_dates << finish
+      elsif ndays <= rounds and rounds <= ndays * 2
+        double_rounds = rounds - ndays
+        (0...ndays).each do |r|
+          round_dates << start_date + r
+          if r >= (ndays - double_rounds)
+            round_dates << start_date + r
+          end
+        end
+      elsif rounds == 7 and start_date.wday == 6 and finish_date.wday == 0 and ndays > 7
+        2.times { round_dates << start_date }
+        2.times { round_dates << start_date + 1 }
+        2.times { round_dates << finish_date - 1 }
+        round_dates << finish_date
+      end
+      return round_dates
+    end
+
     # Is a tournament invalid? Either returns false (if it's valid) or an error message.
     # Has the same _rerank_ option as validate!.
     def invalid(options={})

data/lib/icu_tournament/tournament_fcsv.rb

@@ -336,7 +336,7 @@ module ICU
             if old_player.id
               old_player.merge(opponent)
               old_result = @player.find_result(@round)
-              raise "missing result for player (#{@player.name}) in round #{@round}" unless old_result
+              raise "result for player (#{@player.name}) in round #{@round} does not match previous result for opponent (#{old_player.name})" unless old_result
               raise "mismatched results for player (#{old_player.name}): #{result.inspect} #{old_result.inspect}" unless result.eql?(old_result)
             else
               old_result = old_player.find_result(@round)

data/lib/icu_tournament/tournament_krause.rb

@@ -326,9 +326,13 @@ module ICU
           krause << "\n"
         end
         rounds = t.last_round
-        if t.round_dates.size == rounds && rounds > 0
+        round_dates = t.round_dates
+        if round_dates.empty?
+          round_dates = t.guess_round_dates.map { |d| d.to_s }
+        end
+        if round_dates.size == rounds && rounds > 0
           krause << "132 #{' ' * 85}"
-          t.round_dates.each{ |d| krause << d.sub(/^../, '  ') }
+          round_dates.each{ |d| krause << d.sub(/^../, '  ') }
           krause << "\n"
         end
         t.players.each{ |p| krause << p.to_krause(rounds, arg) }
@@ -433,11 +437,18 @@ module ICU
           full_byes << round
           return 0.0
         end
-        data = "#{data} -" if data.match(/^\d+ (w|b|-)$/)
-        raise "invalid result '#{data}'" unless data.match(/^(0{1,4}|[1-9]\d{0,3}) (w|b|-) (1|0|=|\+|-)$/)
-        opponent = $1.to_i
-        colour   = $2
-        score    = $3
+        data = "#{data} -" if data.match(/^(\d+)? (w|b|-)$/)
+        if data.match(/^(0{1,4}|[1-9]\d{0,3}) (w|b|-) (1|0|=|\+|-)$/)
+          opponent = $1.to_i
+          colour   = $2
+          score    = $3
+        elsif data.match(/- (1|0|=|\+|-)$/)
+          opponent = 0
+          colour = "-"
+          score = $1
+        else
+          raise "invalid result '#{data}'"
+        end
         options  = Hash.new
         options[:opponent] = opponent unless opponent == 0
         options[:colour]   = colour   unless colour == '-'
@@ -459,7 +470,7 @@ module ICU
         return false unless total <= sum + full_byes.size * 1.0 + half_byes.size * 0.5
         full_byes.each_index do |i|
           bye = full_byes[i]
-          if bye.class == Fixnum
+          if bye.class == Integer
             # Round number - create a half-point bye in that round.
             result = Result.new(bye, player, '=')
             @results << ['none', player, "extra bye for player #{player} in round #{bye}", result]

data/lib/icu_tournament/util.rb

@@ -72,7 +72,7 @@ module ICU
         names.each do |name|
           attr_accessor(name) do |val|
             tmp = val.to_i
-            raise "invalid integer (#{val}) for #{name}" unless val.is_a?(Fixnum) || (val.is_a?(::String) && val.include?(tmp.to_s))
+            raise "invalid integer (#{val}) for #{name}" unless val.is_a?(Integer) || (val.is_a?(::String) && val.include?(tmp.to_s))
             tmp
           end
         end
@@ -83,7 +83,7 @@ module ICU
           attr_accessor(name) do |val|
             tmp = case val
               when nil      then nil
-              when Fixnum   then val
+              when Integer   then val
               when /^\s*$/  then nil
               else val.to_i
             end
@@ -108,7 +108,7 @@ module ICU
           attr_accessor(name) do |val|
             tmp = case val
               when nil      then nil
-              when Fixnum   then val
+              when Integer   then val
               when /^\s*$/  then nil
               else val.to_i
             end
@@ -166,4 +166,4 @@ module ICU
       end
     end
   end
-end
+end

data/lib/icu_tournament/version.rb

@@ -2,6 +2,6 @@
 
 module ICU
   class Tournament
-    VERSION = "1.9.3"
+    VERSION = "1.10.0"
   end
 end

data/spec/player_spec.rb

@@ -4,213 +4,211 @@ module ICU
   describe Player do
     context "a typical player" do
       it "should have a name, number and some results" do
-        lambda do
+        expect do
           player = Player.new('Mark', 'Orr', 1)
           player.add_result(Result.new(1, 1, 'W', :opponent => 37, :score => 'W', :colour => 'W'))
           player.add_result(Result.new(2, 1, 'W', :opponent => 13, :score => 'W', :colour => 'B'))
           player.add_result(Result.new(3, 1, 'W', :opponent => 7,  :score => 'D', :colour => 'W'))
-        end.should_not raise_error
+        end.not_to raise_error
       end
     end
 
     context "names" do
       it "should be specified in constructor" do
         p = Player.new('Mark', 'Orr', 1)
-        p.first_name.should == 'Mark'
-        p.last_name.should == 'Orr'
-        p.original_name.should == 'Orr, Mark'
+        expect(p.first_name).to eq('Mark')
+        expect(p.last_name).to eq('Orr')
+        expect(p.original_name).to eq('Orr, Mark')
       end
 
       it "should be resettable via accessors" do
         p = Player.new('Mark', 'Orr', 1)
         p.first_name= 'Gary'
         p.last_name= 'Kasparov'
-        p.first_name.should == 'Gary'
-        p.last_name.should == 'Kasparov'
-        p.original_name.should == 'Orr, Mark'
+        expect(p.first_name).to eq('Gary')
+        expect(p.last_name).to eq('Kasparov')
+        expect(p.original_name).to eq('Orr, Mark')
       end
 
       it "should not contain invalid characters" do
-        lambda { Player.new('12', 'Orr', 1) }.should raise_error(/invalid first name/)
-        lambda { Player.new('Mark', '*!', 1) }.should raise_error(/invalid last name/)
+        expect { Player.new('Mark', '*!', 1) }.to raise_error(/invalid last name/)
       end
 
-      it "should not have empty last name or first name" do
-        lambda { Player.new('Mark', '', 1) }.should raise_error(/invalid last name/)
-        lambda { Player.new('', 'Orr', 1) }.should raise_error(/invalid first name/)
+      it "should not have empty last name" do
+        expect { Player.new('Mark', '', 1) }.to raise_error(/invalid last name/)
       end
 
       it "both names can be returned together" do
         p = Player.new('Mark', 'Orr', 1)
-        p.name.should == 'Orr, Mark'
+        expect(p.name).to eq('Orr, Mark')
       end
 
       it "names should be automatically canonicalised" do
         p = Player.new(' maRk J   l ', '  ORR', 1)
-        p.name.should == 'Orr, Mark J. L.'
+        expect(p.name).to eq('Orr, Mark J. L.')
         p.first_name = 'z'
-        p.name.should == 'Orr, Z.'
+        expect(p.name).to eq('Orr, Z.')
         p.last_name = "  o   meFiSto  "
-        p.name.should == "O'Mefisto, Z."
-        p.original_name.should == 'ORR, maRk J l'
+        expect(p.name).to eq("O'Mefisto, Z.")
+        expect(p.original_name).to eq('ORR, maRk J l')
       end
 
       it "the original name is resetable" do
         p = Player.new('Mark', 'Orr', 1)
-        p.name.should == 'Orr, Mark'
-        p.original_name.should == 'Orr, Mark'
+        expect(p.name).to eq('Orr, Mark')
+        expect(p.original_name).to eq('Orr, Mark')
         p.original_name = 'Cronin, April'
-        p.name.should == 'Orr, Mark'
-        p.original_name.should == 'Cronin, April'
+        expect(p.name).to eq('Orr, Mark')
+        expect(p.original_name).to eq('Cronin, April')
       end
     end
 
     context "number" do
       it "should just be an integer" do
-        Player.new('Mark', 'Orr', 3).num.should == 3
-        Player.new('Mark', 'Orr', -7).num.should == -7
-        Player.new('Mark', 'Orr', '  -4  ').num.should == -4
-        Player.new('Mark', 'Orr', '0').num.should == 0
-        lambda { Player.new('Mark', 'Orr', '  ') }.should raise_error(/invalid integer/)
+        expect(Player.new('Mark', 'Orr', 3).num).to eq(3)
+        expect(Player.new('Mark', 'Orr', -7).num).to eq(-7)
+        expect(Player.new('Mark', 'Orr', '  -4  ').num).to eq(-4)
+        expect(Player.new('Mark', 'Orr', '0').num).to eq(0)
+        expect { Player.new('Mark', 'Orr', '  ') }.to raise_error(/invalid integer/)
       end
     end
 
     context "local ID" do
       it "defaults to nil" do
-        Player.new('Mark', 'Orr', 3).id.should be_nil
+        expect(Player.new('Mark', 'Orr', 3).id).to be_nil
       end
 
       it "should be a positive integer" do
-        Player.new('Mark', 'Orr', 3, :id => 1350).id.should == 1350
-        Player.new('Stephen', 'Brady', 4, :id => ' 90 ').id.should == 90
-        lambda { Player.new('Mark', 'Orr', 3, :id => ' 0 ') }.should raise_error(/invalid positive integer/)
+        expect(Player.new('Mark', 'Orr', 3, :id => 1350).id).to eq(1350)
+        expect(Player.new('Stephen', 'Brady', 4, :id => ' 90 ').id).to eq(90)
+        expect { Player.new('Mark', 'Orr', 3, :id => ' 0 ') }.to raise_error(/invalid positive integer/)
       end
     end
 
     context "FIDE ID" do
       it "defaults to nil" do
-        Player.new('Stephen', 'Brady', 1).fide_id.should be_nil
+        expect(Player.new('Stephen', 'Brady', 1).fide_id).to be_nil
       end
 
       it "should be a positive integer" do
-        Player.new('Stephen', 'Brady', 1, :fide_id => 2500124).fide_id.should == 2500124
-        Player.new('Gary', 'Kasparov', 2, :fide_id => '4100018').fide_id.should == 4100018
-        lambda { Player.new('Mark', 'Orr', 3, :fide_id => ' 0 ') }.should raise_error(/invalid positive integer/)
+        expect(Player.new('Stephen', 'Brady', 1, :fide_id => 2500124).fide_id).to eq(2500124)
+        expect(Player.new('Gary', 'Kasparov', 2, :fide_id => '4100018').fide_id).to eq(4100018)
+        expect { Player.new('Mark', 'Orr', 3, :fide_id => ' 0 ') }.to raise_error(/invalid positive integer/)
       end
     end
 
     context "federation" do
       it "defaults to nil" do
-        Player.new('Mark', 'Orr', 3).fed.should be_nil
-        Player.new('Mark', 'Orr', 3, :fed => '   ').fed.should be_nil
+        expect(Player.new('Mark', 'Orr', 3).fed).to be_nil
+        expect(Player.new('Mark', 'Orr', 3, :fed => '   ').fed).to be_nil
       end
 
       it "should consist of at least three letters" do
-        Player.new('Gary', 'Kasparov', 1, :fed => 'RUS').fed.should == 'RUS'
-        Player.new('Mark', 'Orr', 3, :fed => ' Ireland ').fed.should == 'IRL'
-        lambda { Player.new('Danny', 'Kopec', 3, :fed => 'US') }.should raise_error(/invalid federation/)
+        expect(Player.new('Gary', 'Kasparov', 1, :fed => 'RUS').fed).to eq('RUS')
+        expect(Player.new('Mark', 'Orr', 3, :fed => ' Ireland ').fed).to eq('IRL')
+        expect { Player.new('Danny', 'Kopec', 3, :fed => 'US') }.to raise_error(/invalid federation/)
       end
 
       it "should correct common code errors" do
-        Player.new('Ricardo', 'Calvo', 1, :fed => 'SPA').fed.should == 'ESP'
-        Player.new('Mark', 'Orr', 2, :fed => 'Icu').fed.should == 'IRL'
-        Player.new('Florin', 'Gheorghiu', 3, :fed => 'ROM').fed.should == 'ROU'
+        expect(Player.new('Ricardo', 'Calvo', 1, :fed => 'SPA').fed).to eq('ESP')
+        expect(Player.new('Mark', 'Orr', 2, :fed => 'Icu').fed).to eq('IRL')
+        expect(Player.new('Florin', 'Gheorghiu', 3, :fed => 'ROM').fed).to eq('ROU')
       end
     end
 
     context "title" do
       it "defaults to nil" do
-        Player.new('Mark', 'Orr', 3).title.should be_nil
-        Player.new('Mark', 'Orr', 3, :title => '   ').title.should be_nil
+        expect(Player.new('Mark', 'Orr', 3).title).to be_nil
+        expect(Player.new('Mark', 'Orr', 3, :title => '   ').title).to be_nil
       end
 
       it "should be one of national, candidate, FIDE, international or grand master" do
-        Player.new('Gary', 'Kasparov', 1, :title => 'GM').title.should == 'GM'
-        Player.new('Mark', 'Orr', 2, :title => ' im ').title.should == 'IM'
-        Player.new('Mark', 'Quinn', 2, :title => 'm').title.should == 'IM'
-        Player.new('Pia', 'Cramling', 3, :title => ' wg ').title.should == 'WGM'
-        Player.new('Philip', 'Short', 4, :title => 'F ').title.should == 'FM'
-        Player.new('Gearoidin', 'Ui Laighleis', 5, :title => 'wc').title.should == 'WCM'
-        Player.new('Gearoidin', 'Ui Laighleis', 7, :title => 'wm').title.should == 'WIM'
-        Player.new('Eamon', 'Keogh', 6, :title => 'nm').title.should == 'NM'
-        lambda { Player.new('Mark', 'Orr', 3, :title => 'Dr') }.should raise_error(/invalid chess title/)
+        expect(Player.new('Gary', 'Kasparov', 1, :title => 'GM').title).to eq('GM')
+        expect(Player.new('Mark', 'Orr', 2, :title => ' im ').title).to eq('IM')
+        expect(Player.new('Mark', 'Quinn', 2, :title => 'm').title).to eq('IM')
+        expect(Player.new('Pia', 'Cramling', 3, :title => ' wg ').title).to eq('WGM')
+        expect(Player.new('Philip', 'Short', 4, :title => 'F ').title).to eq('FM')
+        expect(Player.new('Gearoidin', 'Ui Laighleis', 5, :title => 'wc').title).to eq('WCM')
+        expect(Player.new('Gearoidin', 'Ui Laighleis', 7, :title => 'wm').title).to eq('WIM')
+        expect(Player.new('Eamon', 'Keogh', 6, :title => 'nm').title).to eq('NM')
+        expect { Player.new('Mark', 'Orr', 3, :title => 'Dr') }.to raise_error(/invalid chess title/)
       end
     end
 
     context "rating" do
       it "defaults to nil" do
-        Player.new('Mark', 'Orr', 3).rating.should be_nil
-        Player.new('Mark', 'Orr', 3, :rating => '   ').rating.should be_nil
+        expect(Player.new('Mark', 'Orr', 3).rating).to be_nil
+        expect(Player.new('Mark', 'Orr', 3, :rating => '   ').rating).to be_nil
       end
 
       it "should be a positive integer" do
-        Player.new('Gary', 'Kasparov', 1, :rating => 2800).rating.should == 2800
-        Player.new('Mark', 'Orr', 2, :rating => ' 2100 ').rating.should == 2100
-        lambda { Player.new('Mark', 'Orr', 3, :rating => -2100) }.should raise_error(/invalid positive integer/)
-        lambda { Player.new('Mark', 'Orr', 3, :rating => 'IM') }.should raise_error(/invalid positive integer/)
+        expect(Player.new('Gary', 'Kasparov', 1, :rating => 2800).rating).to eq(2800)
+        expect(Player.new('Mark', 'Orr', 2, :rating => ' 2100 ').rating).to eq(2100)
+        expect { Player.new('Mark', 'Orr', 3, :rating => -2100) }.to raise_error(/invalid positive integer/)
+        expect { Player.new('Mark', 'Orr', 3, :rating => 'IM') }.to raise_error(/invalid positive integer/)
       end
     end
 
     context "FIDE rating" do
       it "defaults to nil" do
-        Player.new('Mark', 'Orr', 3).fide_rating.should be_nil
-        Player.new('Mark', 'Orr', 3, :fide_rating => '   ').fide_rating.should be_nil
+        expect(Player.new('Mark', 'Orr', 3).fide_rating).to be_nil
+        expect(Player.new('Mark', 'Orr', 3, :fide_rating => '   ').fide_rating).to be_nil
       end
 
       it "should be a positive integer" do
-        Player.new('Gary', 'Kasparov', 1, :fide_rating => 2800).fide_rating.should == 2800
-        Player.new('Mark', 'Orr', 2, :fide_rating => ' 2200 ').fide_rating.should == 2200
-        lambda { Player.new('Mark', 'Orr', 3, :fide_rating => -2100) }.should raise_error(/invalid positive integer/)
-        lambda { Player.new('Mark', 'Orr', 3, :fide_rating => 'IM') }.should raise_error(/invalid positive integer/)
+        expect(Player.new('Gary', 'Kasparov', 1, :fide_rating => 2800).fide_rating).to eq(2800)
+        expect(Player.new('Mark', 'Orr', 2, :fide_rating => ' 2200 ').fide_rating).to eq(2200)
+        expect { Player.new('Mark', 'Orr', 3, :fide_rating => -2100) }.to raise_error(/invalid positive integer/)
+        expect { Player.new('Mark', 'Orr', 3, :fide_rating => 'IM') }.to raise_error(/invalid positive integer/)
       end
     end
 
     context "rank" do
       it "defaults to nil" do
-        Player.new('Mark', 'Orr', 3).rank.should be_nil
+        expect(Player.new('Mark', 'Orr', 3).rank).to be_nil
       end
 
       it "should be a positive integer" do
-        Player.new('Mark', 'Orr', 3, :rank => 1).rank.should == 1
-        Player.new('Gary', 'Kasparov', 4, :rank => ' 29 ').rank.should == 29
-        lambda { Player.new('Mark', 'Orr', 3, :rank => 0) }.should raise_error(/invalid positive integer/)
-        lambda { Player.new('Mark', 'Orr', 3, :rank => ' -1 ') }.should raise_error(/invalid positive integer/)
+        expect(Player.new('Mark', 'Orr', 3, :rank => 1).rank).to eq(1)
+        expect(Player.new('Gary', 'Kasparov', 4, :rank => ' 29 ').rank).to eq(29)
+        expect { Player.new('Mark', 'Orr', 3, :rank => 0) }.to raise_error(/invalid positive integer/)
+        expect { Player.new('Mark', 'Orr', 3, :rank => ' -1 ') }.to raise_error(/invalid positive integer/)
       end
     end
 
     context "date of birth" do
       it "defaults to nil" do
-        Player.new('Mark', 'Orr', 3).dob.should be_nil
-        Player.new('Mark', 'Orr', 3, :dob => '   ').dob.should be_nil
+        expect(Player.new('Mark', 'Orr', 3).dob).to be_nil
+        expect(Player.new('Mark', 'Orr', 3, :dob => '   ').dob).to be_nil
       end
 
       it "should be a yyyy-mm-dd date" do
-        Player.new('Mark', 'Orr', 3, :dob => '1955-11-09').dob.should == '1955-11-09'
-        lambda { Player.new('Mark', 'Orr', 3, :dob => 'X') }.should raise_error(/invalid.*dob/)
+        expect(Player.new('Mark', 'Orr', 3, :dob => '1955-11-09').dob).to eq('1955-11-09')
+        expect { Player.new('Mark', 'Orr', 3, :dob => 'X') }.to raise_error(/invalid.*dob/)
       end
     end
 
     context "gender" do
       it "defaults to nil" do
-        Player.new('Mark', 'Orr', 3).gender.should be_nil
-        Player.new('Mark', 'Orr', 3, :gender => '   ').gender.should be_nil
+        expect(Player.new('Mark', 'Orr', 3).gender).to be_nil
+        expect(Player.new('Mark', 'Orr', 3, :gender => '   ').gender).to be_nil
       end
 
       it "should be either M or F" do
-        Player.new('Mark', 'Orr', 3, :gender => 'male').gender.should == 'M'
-        Player.new('April', 'Cronin', 3, :gender => 'woman').gender.should == 'F'
+        expect(Player.new('Mark', 'Orr', 3, :gender => 'male').gender).to eq('M')
+        expect(Player.new('April', 'Cronin', 3, :gender => 'woman').gender).to eq('F')
       end
 
       it "should raise an exception if the gender is not specified properly" do
-        lambda { Player.new('Mark', 'Orr', 3, :gender => 'X') }.should raise_error(/invalid gender/)
+        expect { Player.new('Mark', 'Orr', 3, :gender => 'X') }.to raise_error(/invalid gender/)
       end
     end
 
     context "results and points" do
       it "should initialise to an empty array" do
         results = Player.new('Mark', 'Orr', 3).results
-        results.should be_instance_of Array
-        results.size.should == 0
+        expect(results).to be_instance_of Array
+        expect(results.size).to eq(0)
       end
 
       it "can be added to" do
@@ -219,21 +217,21 @@ module ICU
         player.add_result(Result.new(2, 3, 'D', :opponent => 2))
         player.add_result(Result.new(3, 3, 'L', :opponent => 4))
         results = player.results
-        results.should be_instance_of Array
-        results.size.should == 3
-        player.points.should == 1.5
+        expect(results).to be_instance_of Array
+        expect(results.size).to eq(3)
+        expect(player.points).to eq(1.5)
       end
 
       it "should not allow mismatched player numbers" do
         player = Player.new('Mark', 'Orr', 3)
-        lambda { player.add_result(Result.new(1, 4, 'W', :opponent => 1)) }.should raise_error(/player number .* matched/)
+        expect { player.add_result(Result.new(1, 4, 'W', :opponent => 1)) }.to raise_error(/player number .* matched/)
       end
 
       it "should enforce unique round numbers" do
         player = Player.new('Mark', 'Orr', 3)
         player.add_result(Result.new(1, 3, 'W', :opponent => 1))
         player.add_result(Result.new(2, 3, 'D', :opponent => 2))
-        lambda { player.add_result(Result.new(2, 3, 'L', :opponent => 4)) }.should raise_error(/does not match/)
+        expect { player.add_result(Result.new(2, 3, 'L', :opponent => 4)) }.to raise_error(/does not match/)
       end
     end
 
@@ -246,10 +244,10 @@ module ICU
       end
 
       it "should find results by round number" do
-        @p.find_result(1).opponent.should == 37
-        @p.find_result(2).opponent.should == 13
-        @p.find_result(3).opponent.should == 7
-        @p.find_result(4).should be_nil
+        expect(@p.find_result(1).opponent).to eq(37)
+        expect(@p.find_result(2).opponent).to eq(13)
+        expect(@p.find_result(3).opponent).to eq(7)
+        expect(@p.find_result(4)).to be_nil
       end
     end
 
@@ -263,9 +261,9 @@ module ICU
 
       it "should find and remove a result by round number" do
         result = @p.remove_result(1)
-        result.inspect.should == "R1P1O37WWR"
-        @p.results.size.should == 2
-        @p.results.map(&:round).join("|").should == "2|3"
+        expect(result.inspect).to eq("R1P1O37WWR")
+        expect(@p.results.size).to eq(2)
+        expect(@p.results.map(&:round).join("|")).to eq("2|3")
       end
     end
 
@@ -278,12 +276,12 @@ module ICU
 
       it "takes on the ID, rating, title and fed of the other player but not the player number" do
         @p1.merge(@p2)
-        @p1.num.should == 1
-        @p1.id.should == 1350
-        @p1.rating.should == 2100
-        @p1.title.should == 'IM'
-        @p1.fed.should == 'IRL'
-        @p1.fide_id.should == 2500035
+        expect(@p1.num).to eq(1)
+        expect(@p1.id).to eq(1350)
+        expect(@p1.rating).to eq(2100)
+        expect(@p1.title).to eq('IM')
+        expect(@p1.fed).to eq('IRL')
+        expect(@p1.fide_id).to eq(2500035)
       end
 
       it "should have a kind of symmetry" do
@@ -293,7 +291,7 @@ module ICU
       end
 
       it "cannot be done with unequal objects" do
-        lambda { @p1.merge(@p3) }.should raise_error(/cannot merge.*not equal/)
+        expect { @p1.merge(@p3) }.to raise_error(/cannot merge.*not equal/)
       end
     end
 
@@ -306,13 +304,13 @@ module ICU
 
       it "should renumber successfully if the map has the relevant player numbers" do
         map = { 10 => 1, 20 => 2, 30 => 3 }
-        @p.renumber(map).num.should == 1
-        @p.results.map{ |r| r.opponent }.sort.join('').should == '23'
+        expect(@p.renumber(map).num).to eq(1)
+        expect(@p.results.map{ |r| r.opponent }.sort.join('')).to eq('23')
       end
 
       it "should raise exception if a player number is not in the map" do
-        lambda { @p.renumber({ 100 => 1, 20 => 2, 30 => 3 }) }.should raise_error(/player.*10.*not found/)
-        lambda { @p.renumber({ 10 => 1, 200 => 2, 30 => 3 }) }.should raise_error(/opponent.*20.*not found/)
+        expect { @p.renumber({ 100 => 1, 20 => 2, 30 => 3 }) }.to raise_error(/player.*10.*not found/)
+        expect { @p.renumber({ 10 => 1, 200 => 2, 30 => 3 }) }.to raise_error(/opponent.*20.*not found/)
       end
     end
 
@@ -326,21 +324,21 @@ module ICU
       end
 
       it "any player is equal to itself" do
-        (@mark1 == @mark1).should be_true
+        expect(@mark1 == @mark1).to be_truthy
       end
 
       it "two players are equal if their names are the same and their federations do not conflict" do
-        (@mark1 == @mark2).should be_true
+        expect(@mark1 == @mark2).to be_truthy
       end
 
       it "two players cannot be equal if they have different names" do
-        (@mark1 == @mark4).should be_false
-        (@mark1 == @john1).should be_false
+        expect(@mark1 == @mark4).to be_falsey
+        expect(@mark1 == @john1).to be_falsey
       end
 
       it "two players cannot be equal if they have different federations" do
-        (@mark2 == @mark3).should be_false
-        (@mark1 == @mark3).should be_true
+        expect(@mark2 == @mark3).to be_falsey
+        expect(@mark1 == @mark3).to be_truthy
       end
     end
 
@@ -354,21 +352,21 @@ module ICU
       end
 
       it "any player is equal to itself" do
-        @mark1.eql?(@mark1).should be_true
-        @mark1.eql?(@mark1).should be_true
+        expect(@mark1.eql?(@mark1)).to be_truthy
+        expect(@mark1.eql?(@mark1)).to be_truthy
       end
 
       it "two players are equal as long as their ID, rating and title do not conflict" do
-        @mark1.eql?(@mark2).should be_true
-        @mark3.eql?(@mark4).should be_true
-        @mark4.eql?(@mark5).should be_true
+        expect(@mark1.eql?(@mark2)).to be_truthy
+        expect(@mark3.eql?(@mark4)).to be_truthy
+        expect(@mark4.eql?(@mark5)).to be_truthy
       end
 
       it "two players are not equal if their ID, rating or title conflict" do
-        @mark2.eql?(@mark3).should be_false
-        @mark2.eql?(@mark4).should be_false
-        @mark2.eql?(@mark5).should be_false
+        expect(@mark2.eql?(@mark3)).to be_falsey
+        expect(@mark2.eql?(@mark4)).to be_falsey
+        expect(@mark2.eql?(@mark5)).to be_falsey
       end
     end
   end
-end
+end