icu_tournament 1.9.3 → 1.9.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0097e631fad6d7e9e793bc42e57eb6576922f11d
+  data.tar.gz: bc46c8a7dd4adac48111f0ad54a01b18b7ed1ebe
+SHA512:
+  metadata.gz: df140048ef0c3e4cacea9cd7f9c46cc09c46dcff49ca9ed656e6ac6b1318f057d4cfe4501263f3070cf2b3b875580f7295e08c767d95b80a06b51e8895605448
+  data.tar.gz: 35bc471b3046552530e58cb0fe62feb936b8fc35be03a50fb54523ca196a0e696bad1deceebd42c650e51efb5f1b2ee725503faf1b90a3ac5fd7eedfa82b56ed

data/lib/icu_tournament/version.rb

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

data/spec/player_spec.rb

@@ -4,213 +4,213 @@ 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('12', 'Orr', 1) }.to raise_error(/invalid first 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/)
+        expect { Player.new('Mark', '', 1) }.to raise_error(/invalid last name/)
+        expect { Player.new('', 'Orr', 1) }.to raise_error(/invalid first 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 +219,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 +246,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 +263,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 +278,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 +293,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 +306,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 +326,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,20 +354,20 @@ 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