icu_tournament 1.9.3 → 1.10.0

data/spec/result_spec.rb

@@ -5,137 +5,137 @@ module ICU
   describe Result do
     context "a typical result" do
       it "should have a round, player number and score plus optional opponent number, colour and rateable flag" do
-        lambda { Result.new(3, 5, 'W', :opponent => 11, :colour => 'W') }.should_not raise_error
+        expect { Result.new(3, 5, 'W', :opponent => 11, :colour => 'W') }.not_to raise_error
       end
     end
 
     context "round number" do
       it "should be a positive integer" do
-        lambda { Result.new(-2, 2, 0) }.should raise_error(/invalid positive integer/)
-        lambda { Result.new(0, 2, 0) }.should raise_error(/invalid positive integer/)
-        Result.new(1, 2, 0).round.should == 1
-        Result.new(' 3 ', 2, 0).round.should == 3
+        expect { Result.new(-2, 2, 0) }.to raise_error(/invalid positive integer/)
+        expect { Result.new(0, 2, 0) }.to raise_error(/invalid positive integer/)
+        expect(Result.new(1, 2, 0).round).to eq(1)
+        expect(Result.new(' 3 ', 2, 0).round).to eq(3)
       end
     end
 
     context "player number" do
       it "should be an integer" do
-        lambda { Result.new(1, '  ', 0) }.should raise_error(/invalid integer/)
-        Result.new(1, 2, 0).player.should == 2
-        Result.new(1, ' 0 ', 0).player.should == 0
-        Result.new(1, -5, 0).player.should == -5
-        Result.new(1, " 9 ", 0).player.should == 9
+        expect { Result.new(1, '  ', 0) }.to raise_error(/invalid integer/)
+        expect(Result.new(1, 2, 0).player).to eq(2)
+        expect(Result.new(1, ' 0 ', 0).player).to eq(0)
+        expect(Result.new(1, -5, 0).player).to eq(-5)
+        expect(Result.new(1, " 9 ", 0).player).to eq(9)
       end
     end
 
     context "score" do
       [1, 1.0, 'W', 'w', '+'].each do |score|
         it "should be 'W' for #{score}, #{score.class}" do
-          Result.new(1, 2, score).score.should == 'W'
+          expect(Result.new(1, 2, score).score).to eq('W')
         end
       end
       [0, 0.0, 'L', 'l', '-'].each do |score|
         it "should be 'L' for #{score}, #{score.class}" do
-          Result.new(1, 2, score).score.should == 'L'
+          expect(Result.new(1, 2, score).score).to eq('L')
         end
       end
       ['½', 0.5, 'D', 'd', '='].each do |score|
         it "should be 'L' for #{score}, #{score.class}" do
-          Result.new(1, 2, score).score.should == 'D'
+          expect(Result.new(1, 2, score).score).to eq('D')
         end
       end
       ['', ' ', 'x', 2, -1.0, nil].each do |score|
         it "should raise error for invalid score (#{score})" do
-          lambda { Result.new(1, 2, score) }.should raise_error(/invalid score/)
+          expect { Result.new(1, 2, score) }.to raise_error(/invalid score/)
         end
       end
       it "should be expressable as a number" do
-        Result.new(1, 2, 'W').points.should == 1.0
-        Result.new(1, 2, 'L').points.should == 0.0
-        Result.new(1, 2, 'D').points.should == 0.5
+        expect(Result.new(1, 2, 'W').points).to eq(1.0)
+        expect(Result.new(1, 2, 'L').points).to eq(0.0)
+        expect(Result.new(1, 2, 'D').points).to eq(0.5)
       end
     end
 
     context "colour" do
       it "should be 'W' or 'B' or nil (unknown)" do
-        Result.new(4, 1, 0).colour.should be_nil
-        Result.new(4, 1, 0, :colour => 'W').colour.should == 'W'
-        Result.new(4, 1, 0, :colour => 'white').colour.should == 'W'
-        Result.new(4, 1, 0, :colour => '  b ').colour.should == 'B'
-        Result.new(4, 1, 0, :colour => ' BLACK ').colour.should == 'B'
-        lambda { Result.new(4, 1, 0, :colour => 'red') }.should raise_error(/invalid colour/)
+        expect(Result.new(4, 1, 0).colour).to be_nil
+        expect(Result.new(4, 1, 0, :colour => 'W').colour).to eq('W')
+        expect(Result.new(4, 1, 0, :colour => 'white').colour).to eq('W')
+        expect(Result.new(4, 1, 0, :colour => '  b ').colour).to eq('B')
+        expect(Result.new(4, 1, 0, :colour => ' BLACK ').colour).to eq('B')
+        expect { Result.new(4, 1, 0, :colour => 'red') }.to raise_error(/invalid colour/)
       end
     end
 
     context "opponent number" do
       it "should be nil (the default) or an integer" do
-        Result.new(4, 1, 0).opponent.should be_nil
-        Result.new(4, 1, 0, :opponent => nil).opponent.should be_nil
-        Result.new(4, 1, 0, :opponent => '   ').opponent.should be_nil
-        Result.new(4, 1, 0, :opponent => 0).opponent.should == 0
-        Result.new(4, 1, 0, :opponent => 2).opponent.should == 2
-        Result.new(4, 1, 0, :opponent => -6).opponent.should == -6
-        Result.new(4, 1, 0, :opponent => ' 10 ').opponent.should == 10
-        lambda { Result.new(4, 1, 0, :opponent => 'X') }.should raise_error(/invalid opponent number/)
+        expect(Result.new(4, 1, 0).opponent).to be_nil
+        expect(Result.new(4, 1, 0, :opponent => nil).opponent).to be_nil
+        expect(Result.new(4, 1, 0, :opponent => '   ').opponent).to be_nil
+        expect(Result.new(4, 1, 0, :opponent => 0).opponent).to eq(0)
+        expect(Result.new(4, 1, 0, :opponent => 2).opponent).to eq(2)
+        expect(Result.new(4, 1, 0, :opponent => -6).opponent).to eq(-6)
+        expect(Result.new(4, 1, 0, :opponent => ' 10 ').opponent).to eq(10)
+        expect { Result.new(4, 1, 0, :opponent => 'X') }.to raise_error(/invalid opponent number/)
       end
 
       it "should be different to player number" do
-        lambda { Result.new(4, 1, 0, :opponent => 1) }.should raise_error(/opponent .* player .* different/)
+        expect { Result.new(4, 1, 0, :opponent => 1) }.to raise_error(/opponent .* player .* different/)
       end
     end
 
     context "rateable flag" do
       it "should default to false if there is no opponent" do
-        Result.new(4, 1, 0).rateable.should be_false
+        expect(Result.new(4, 1, 0).rateable).to be_falsey
       end
 
       it "should default to true if there is an opponent" do
-        Result.new(4, 1, 0, :opponent => 10).rateable.should be_true
+        expect(Result.new(4, 1, 0, :opponent => 10).rateable).to be_truthy
       end
 
       it "should change if an opponent is added" do
         r = Result.new(4, 1, 0)
         r.opponent = 5;
-        r.rateable.should be_true
+        expect(r.rateable).to be_truthy
       end
 
       it "should be settable to false from the constructor" do
-        Result.new(4, 1, 0, :opponent => 10, :rateable => false).rateable.should be_false
+        expect(Result.new(4, 1, 0, :opponent => 10, :rateable => false).rateable).to be_falsey
       end
 
       it "should be settable to false using the accessor" do
         r = Result.new(4, 1, 0, :opponent => 10)
         r.rateable= false
-        r.rateable.should be_false
+        expect(r.rateable).to be_falsey
       end
 
       it "should not be settable to true if there is no opponent" do
         r = Result.new(4, 1, 0)
         r.rateable= true
-        r.rateable.should be_false
+        expect(r.rateable).to be_falsey
       end
     end
 
     context "reversed result" do
       it "should be nil if there is no opponent" do
-        Result.new(4, 1, 0).reverse.should be_nil
+        expect(Result.new(4, 1, 0).reverse).to be_nil
       end
 
       it "should have player and opponent swapped" do
         r = Result.new(4, 1, 0, :opponent => 2).reverse
-        r.player.should == 2
-        r.opponent.should == 1
+        expect(r.player).to eq(2)
+        expect(r.opponent).to eq(1)
       end
 
       it "should have reversed result" do
-        Result.new(4, 1, 0, :opponent => 2).reverse.score.should == 'W'
-        Result.new(4, 1, 1, :opponent => 2).reverse.score.should == 'L'
-        Result.new(4, 1, '=', :opponent => 2).reverse.score.should == 'D'
+        expect(Result.new(4, 1, 0, :opponent => 2).reverse.score).to eq('W')
+        expect(Result.new(4, 1, 1, :opponent => 2).reverse.score).to eq('L')
+        expect(Result.new(4, 1, '=', :opponent => 2).reverse.score).to eq('D')
       end
 
       it "should preserve rateability" do
-        Result.new(4, 1, 0, :opponent => 2).reverse.rateable.should be_true
-        Result.new(4, 1, 0, :opponent => 2, :rateable => false).reverse.rateable.should be_false
+        expect(Result.new(4, 1, 0, :opponent => 2).reverse.rateable).to be_truthy
+        expect(Result.new(4, 1, 0, :opponent => 2, :rateable => false).reverse.rateable).to be_falsey
       end
     end
 
@@ -147,14 +147,14 @@ module ICU
 
       it "should renumber successfully if the map has the relevant player numbers" do
         map = { 4 => 1, 3 => 2 }
-        @r1.renumber(map).player.should == 1
-        @r2.renumber(map).player.should == 2
-        @r1.opponent.should be_nil
-        @r2.opponent.should == 1
+        expect(@r1.renumber(map).player).to eq(1)
+        expect(@r2.renumber(map).player).to eq(2)
+        expect(@r1.opponent).to be_nil
+        expect(@r2.opponent).to eq(1)
       end
 
       it "should raise exception if a player number is not in the map" do
-        lambda { @r1.renumber({ 5 => 1, 3 => 2 }) }.should raise_error(/player.*4.*not found/)
+        expect { @r1.renumber({ 5 => 1, 3 => 2 }) }.to raise_error(/player.*4.*not found/)
       end
     end
 
@@ -169,19 +169,19 @@ module ICU
       end
 
       it "should only be equal if everything is the same" do
-        @r.eql?(@r).should be_true
-        @r.eql?(@r1).should be_true
-        @r.eql?(@r2).should be_false
-        @r.eql?(@r3).should be_false
-        @r.eql?(@r4).should be_false
-        @r.eql?(@r5).should be_false
+        expect(@r.eql?(@r)).to be_truthy
+        expect(@r.eql?(@r1)).to be_truthy
+        expect(@r.eql?(@r2)).to be_falsey
+        expect(@r.eql?(@r3)).to be_falsey
+        expect(@r.eql?(@r4)).to be_falsey
+        expect(@r.eql?(@r5)).to be_falsey
       end
 
       it "exceptions are allowed" do
-        @r.eql?(@r2, :except => :rateable).should be_true
-        @r.eql?(@r3, :except => "round").should be_true
-        @r.eql?(@r4, :except => :colour).should be_true
-        @r.eql?(@r5, :except => [:colour, :round, :score, "opponent"]).should be_true
+        expect(@r.eql?(@r2, :except => :rateable)).to be_truthy
+        expect(@r.eql?(@r3, :except => "round")).to be_truthy
+        expect(@r.eql?(@r4, :except => :colour)).to be_truthy
+        expect(@r.eql?(@r5, :except => [:colour, :round, :score, "opponent"])).to be_truthy
       end
     end
 
@@ -194,11 +194,11 @@ module ICU
       end
 
       it "should be correct" do
-        @r.eql?(@r1).should be_true
-        @r.eql?(@r2).should be_false
-        @r.eql?(@r3).should be_false
-        @r.eql?(@r2, :except => :rateable).should be_true
-        @r.eql?(@r3, :except => [:rateable, :score]).should be_true
+        expect(@r.eql?(@r1)).to be_truthy
+        expect(@r.eql?(@r2)).to be_falsey
+        expect(@r.eql?(@r3)).to be_falsey
+        expect(@r.eql?(@r2, :except => :rateable)).to be_truthy
+        expect(@r.eql?(@r3, :except => [:rateable, :score])).to be_truthy
       end
     end
   end

data/spec/team_spec.rb

@@ -11,49 +11,49 @@ module ICU
       end
       
       it "should have a name" do
-        @t.name.should == 'Wandering Dragons'
+        expect(@t.name).to eq('Wandering Dragons')
       end
       
       it "should have some members" do
-        @t.should have(3).members
-        @t.include?(0).should be_true
-        @t.include?(3).should be_true
-        @t.include?(-7).should be_true
-        @t.include?(7).should be_false
+        expect(@t.members.size).to eq(3)
+        expect(@t.include?(0)).to be_truthy
+        expect(@t.include?(3)).to be_truthy
+        expect(@t.include?(-7)).to be_truthy
+        expect(@t.include?(7)).to be_falsey
       end
       
       it "should match names ignoring case and irrelevant whitespace" do
-        @t.matches('Wandering Dragons').should be_true
-        @t.matches('  wandering  dragons  ').should be_true
-        @t.matches('  wanderingdragons  ').should be_false
-        @t.matches('Blundering Bishops').should be_false
+        expect(@t.matches('Wandering Dragons')).to be_truthy
+        expect(@t.matches('  wandering  dragons  ')).to be_truthy
+        expect(@t.matches('  wanderingdragons  ')).to be_falsey
+        expect(@t.matches('Blundering Bishops')).to be_falsey
       end
       
       it "should have a changeable name with irrelevant whitespace being trimmed" do
         @t.name = '  blue    dragons   '
-        @t.name.should == 'blue dragons'
+        expect(@t.name).to eq('blue dragons')
       end
       
       it "should blowup if an attempt is made to blank the name" do
-        lambda { @t.name = '  ' }.should raise_error(/blank/)
+        expect { @t.name = '  ' }.to raise_error(/blank/)
       end
       
       it "should blowup if an attempt is made to add a non-number" do
-        lambda { @t.add_member('  ') }.should raise_error(/number/)
+        expect { @t.add_member('  ') }.to raise_error(/number/)
       end
 
       it "should blow up if an attempt is made to add a duplicate number" do
-        lambda { @t.add_member(3) }.should raise_error(/duplicate/)
+        expect { @t.add_member(3) }.to raise_error(/duplicate/)
       end
 
       it "should renumber successfully if the map has the relevant player numbers" do
         map = { 0 => 1, 3 => 2, -7 => 3 }
         @t.renumber(map)
-        @t.members.sort.join('').should == '123'
+        expect(@t.members.sort.join('')).to eq('123')
       end
 
       it "should raise exception if a player is missing from the renumber map" do
-        lambda { @t.renumber({ 5 => 1, 3 => 2 }) }.should raise_error(/player.*not found/)
+        expect { @t.renumber({ 5 => 1, 3 => 2 }) }.to raise_error(/player.*not found/)
       end
     end
   end

data/spec/tie_break_spec.rb

@@ -4,84 +4,84 @@ module ICU
   describe TieBreak do
     context "#identify which rule" do
       it "should recognize Buchholz" do
-        TieBreak.identify(:buchholz).id.should == :buchholz
-        TieBreak.identify(" BucholtS ").id.should == :buchholz
-        TieBreak.identify(" bh ").id.should == :buchholz
-        TieBreak.identify(" buccholts ").code.should == "BH"
+        expect(TieBreak.identify(:buchholz).id).to eq(:buchholz)
+        expect(TieBreak.identify(" BucholtS ").id).to eq(:buchholz)
+        expect(TieBreak.identify(" bh ").id).to eq(:buchholz)
+        expect(TieBreak.identify(" buccholts ").code).to eq("BH")
       end
 
       it "should recognize Harkness (Median)" do
-        TieBreak.identify(:harkness).id.should == :harkness
-        TieBreak.identify("median").id.should == :harkness
-        TieBreak.identify(" hARKNES ").id.should == :harkness
-        TieBreak.identify("HK").id.should == :harkness
-        TieBreak.identify("MEDIAN").code.should == "HK"
+        expect(TieBreak.identify(:harkness).id).to eq(:harkness)
+        expect(TieBreak.identify("median").id).to eq(:harkness)
+        expect(TieBreak.identify(" hARKNES ").id).to eq(:harkness)
+        expect(TieBreak.identify("HK").id).to eq(:harkness)
+        expect(TieBreak.identify("MEDIAN").code).to eq("HK")
       end
 
       it "should recognize Modified Median" do
-        TieBreak.identify(:modified).id.should == :modified_median
-        TieBreak.identify(" modified  MEDIAN ").id.should == :modified_median
-        TieBreak.identify("MM").code.should == "MM"
+        expect(TieBreak.identify(:modified).id).to eq(:modified_median)
+        expect(TieBreak.identify(" modified  MEDIAN ").id).to eq(:modified_median)
+        expect(TieBreak.identify("MM").code).to eq("MM")
       end
 
       it "should recognize Number of Blacks" do
-        TieBreak.identify(:blacks).id.should == :blacks
-        TieBreak.identify("number\tof\tblacks\n").id.should == :blacks
-        TieBreak.identify("\tnb\t").id.should == :blacks
-        TieBreak.identify("number_blacks").code.should == "NB"
+        expect(TieBreak.identify(:blacks).id).to eq(:blacks)
+        expect(TieBreak.identify("number\tof\tblacks\n").id).to eq(:blacks)
+        expect(TieBreak.identify("\tnb\t").id).to eq(:blacks)
+        expect(TieBreak.identify("number_blacks").code).to eq("NB")
       end
 
       it "should recognize Number of Wins" do
-        TieBreak.identify(:wins).id.should == :wins
-        TieBreak.identify(" number-of-wins ").id.should == :wins
-        TieBreak.identify("NUMBER WINS\r\n").id.should == :wins
-        TieBreak.identify("nw").code.should == "NW"
+        expect(TieBreak.identify(:wins).id).to eq(:wins)
+        expect(TieBreak.identify(" number-of-wins ").id).to eq(:wins)
+        expect(TieBreak.identify("NUMBER WINS\r\n").id).to eq(:wins)
+        expect(TieBreak.identify("nw").code).to eq("NW")
       end
 
       it "should recognize Player's of Name" do
-        TieBreak.identify(:name).id.should == :name
-        TieBreak.identify("Player's Name").id.should == :name
-        TieBreak.identify("players_name").id.should == :name
-        TieBreak.identify("PN").id.should == :name
-        TieBreak.identify("PLAYER-NAME").code.should == "PN"
+        expect(TieBreak.identify(:name).id).to eq(:name)
+        expect(TieBreak.identify("Player's Name").id).to eq(:name)
+        expect(TieBreak.identify("players_name").id).to eq(:name)
+        expect(TieBreak.identify("PN").id).to eq(:name)
+        expect(TieBreak.identify("PLAYER-NAME").code).to eq("PN")
       end
 
       it "should recognize Sonneborn-Berger" do
-        TieBreak.identify(:sonneborn_berger).id.should == :neustadtl
-        TieBreak.identify(:neustadtl).id.should == :neustadtl
-        TieBreak.identify("  SONNEBORN\nberger").id.should == :neustadtl
-        TieBreak.identify("\t  soneborn_berger  \t").id.should == :neustadtl
-        TieBreak.identify("sb").id.should == :neustadtl
-        TieBreak.identify("NESTADL").code.should == "SB"
+        expect(TieBreak.identify(:sonneborn_berger).id).to eq(:neustadtl)
+        expect(TieBreak.identify(:neustadtl).id).to eq(:neustadtl)
+        expect(TieBreak.identify("  SONNEBORN\nberger").id).to eq(:neustadtl)
+        expect(TieBreak.identify("\t  soneborn_berger  \t").id).to eq(:neustadtl)
+        expect(TieBreak.identify("sb").id).to eq(:neustadtl)
+        expect(TieBreak.identify("NESTADL").code).to eq("SB")
       end
 
       it "should recognize Sum of Progressive Scores" do
-        TieBreak.identify(:progressive).id.should == :progressive
-        TieBreak.identify("CUMULATIVE").id.should == :progressive
-        TieBreak.identify("sum of progressive scores").id.should == :progressive
-        TieBreak.identify("SUM-cumulative_SCORE").id.should == :progressive
-        TieBreak.identify(:cumulative_score).id.should == :progressive
-        TieBreak.identify("SumOfCumulative").id.should == :progressive
-        TieBreak.identify("SP").code.should == "SP"
+        expect(TieBreak.identify(:progressive).id).to eq(:progressive)
+        expect(TieBreak.identify("CUMULATIVE").id).to eq(:progressive)
+        expect(TieBreak.identify("sum of progressive scores").id).to eq(:progressive)
+        expect(TieBreak.identify("SUM-cumulative_SCORE").id).to eq(:progressive)
+        expect(TieBreak.identify(:cumulative_score).id).to eq(:progressive)
+        expect(TieBreak.identify("SumOfCumulative").id).to eq(:progressive)
+        expect(TieBreak.identify("SP").code).to eq("SP")
       end
 
       it "should recognize Sum of Opponents' Ratings" do
-        TieBreak.identify(:ratings).id.should == :ratings
-        TieBreak.identify("sum of opponents ratings").id.should == :ratings
-        TieBreak.identify("Opponents' Ratings").id.should == :ratings
-        TieBreak.identify("SR").id.should == :ratings
-        TieBreak.identify("SUMOPPONENTSRATINGS").code.should == "SR"
+        expect(TieBreak.identify(:ratings).id).to eq(:ratings)
+        expect(TieBreak.identify("sum of opponents ratings").id).to eq(:ratings)
+        expect(TieBreak.identify("Opponents' Ratings").id).to eq(:ratings)
+        expect(TieBreak.identify("SR").id).to eq(:ratings)
+        expect(TieBreak.identify("SUMOPPONENTSRATINGS").code).to eq("SR")
       end
 
       it "should recognize player's name" do
-        TieBreak.identify(:name).id.should == :name
-        TieBreak.identify(" player's  NAME ").id.should == :name
-        TieBreak.identify("pn").code.should == "PN"
+        expect(TieBreak.identify(:name).id).to eq(:name)
+        expect(TieBreak.identify(" player's  NAME ").id).to eq(:name)
+        expect(TieBreak.identify("pn").code).to eq("PN")
       end
 
       it "should return nil for unrecognized tie breaks" do
-        TieBreak.identify("XYZ").should be_nil
-        TieBreak.identify(nil).should be_nil
+        expect(TieBreak.identify("XYZ")).to be_nil
+        expect(TieBreak.identify(nil)).to be_nil
       end
     end
     
@@ -91,9 +91,9 @@ module ICU
       end
 
       it "should be an array in a specific order" do
-        @rules.size.should == 9
-        @rules.first.name.should == "Buchholz"
-        @rules.map(&:code).join("|").should == "BH|HK|MM|NB|NW|PN|SB|SR|SP"
+        expect(@rules.size).to eq(9)
+        expect(@rules.first.name).to eq("Buchholz")
+        expect(@rules.map(&:code).join("|")).to eq("BH|HK|MM|NB|NW|PN|SB|SR|SP")
       end
     end
   end