rubywarrior 0.1.3 → 0.2.0

data/spec/ruby_warrior/game_spec.rb

@@ -4,55 +4,55 @@ describe RubyWarrior::Game do
   before(:each) do
     @game = RubyWarrior::Game.new
   end
-  
+
   # GAME DIR
-  
+
   it "should make game directory if player says so" do
     RubyWarrior::UI.stubs(:ask).returns(true)
     Dir.expects(:mkdir).with('./rubywarrior')
     @game.make_game_directory
   end
-  
+
   it "should not make game and exit if player says no" do
     RubyWarrior::UI.stubs(:ask).returns(false)
     Dir.stubs(:mkdir).raises('should not be called')
-    lambda { @game.make_game_directory }.should raise_error(SystemExit)
+    expect { @game.make_game_directory }.to raise_error(SystemExit)
   end
-  
-  
+
+
   # PROFILES
-  
+
   it "should load profiles for each profile path" do
     RubyWarrior::Profile.expects(:load).with('foo/.profile').returns(1)
     RubyWarrior::Profile.expects(:load).with('bar/.profile').returns(2)
     @game.stubs(:profile_paths).returns(['foo/.profile', 'bar/.profile'])
-    @game.profiles.should == [1, 2]
+    expect(@game.profiles).to eq([1, 2])
   end
-  
+
   it "should find profile paths using Dir[] search" do
     Dir.expects(:[]).with("./rubywarrior/**/.profile")
     @game.profile_paths
   end
-  
+
   it "should try to create profile when no profile paths are specified" do
     @game.stubs(:profiles).returns([])
     @game.expects(:new_profile).returns('profile')
-    @game.profile.should == 'profile'
+    expect(@game.profile).to eq('profile')
   end
-  
+
   it "should ask a player to choose a profile if multiple profiles are available, but only once" do
     RubyWarrior::UI.expects(:choose).with('profile', [:profile1, [:new, 'New Profile']]).returns(:profile1)
     @game.stubs(:profiles).returns([:profile1])
-    2.times { @game.profile.should == :profile1 }
+    2.times { expect(@game.profile).to eq(:profile1) }
   end
-  
+
   it "should ask user to choose a tower when creating a new profile" do
     RubyWarrior::UI.stubs(:gets).returns('')
     @game.stubs(:towers).returns([:tower1, :tower2])
     RubyWarrior::UI.expects(:choose).with('tower', [:tower1, :tower2]).returns(stub(:path => '/foo/bar'))
     @game.new_profile
   end
-  
+
   it "should pass name and selected tower to profile" do
     profile = stub
     RubyWarrior::UI.stubs(:choose).returns(stub(:path => 'tower_path'))
@@ -60,60 +60,60 @@ describe RubyWarrior::Game do
     RubyWarrior::Profile.expects(:new).returns(profile)
     profile.expects(:tower_path=).with('tower_path')
     profile.expects(:warrior_name=).with('name')
-    @game.new_profile.should == profile
+    expect(@game.new_profile).to eq(profile)
   end
-  
-  
+
+
   # TOWERS
-  
+
   it "load towers for each tower path" do
     RubyWarrior::Tower.expects(:new).with('towers/foo').returns(1)
     RubyWarrior::Tower.expects(:new).with('towers/bar').returns(2)
     @game.stubs(:tower_paths).returns(['towers/foo', 'towers/bar'])
-    @game.towers.should == [1, 2]
+    expect(@game.towers).to eq([1, 2])
   end
-  
+
   it "should find tower paths using Dir[] search" do
     Dir.expects(:[]).with(File.expand_path('../../../towers/*', __FILE__))
     @game.tower_paths
   end
-  
-  
+
+
   # LEVEL
-  
+
   it "should fetch current level from profile and cache it" do
     @game.stubs(:profile).returns(stub)
     @game.profile.expects(:current_level).returns('foo')
-    2.times { @game.current_level.should == 'foo' }
+    2.times { expect(@game.current_level).to eq('foo') }
   end
-  
+
   it "should fetch next level from profile and cache it" do
     @game.stubs(:profile).returns(stub)
     @game.profile.expects(:next_level).returns('bar')
-    2.times { @game.next_level.should == 'bar' }
+    2.times { expect(@game.next_level).to eq('bar') }
   end
-  
+
   it "should report final grade" do
     profile = RubyWarrior::Profile.new
     profile.current_epic_grades = { 1 => 0.7, 2 => 0.9 }
     @game.stubs(:profile).returns(profile)
     report = @game.final_report
-    report.should include("Your average grade for this tower is: B")
-    report.should include("Level 1: C\n  Level 2: A")
+    expect(report).to include("Your average grade for this tower is: B")
+    expect(report).to include("Level 1: C\n  Level 2: A")
   end
-  
+
   it "should have an empty final report if no epic grades are available" do
     profile = RubyWarrior::Profile.new
     profile.current_epic_grades = {}
     @game.stubs(:profile).returns(profile)
-    @game.final_report.should be_nil
+    expect(@game.final_report).to be_nil
   end
-  
+
   it "should have an empty final report if practice level" do
     RubyWarrior::Config.practice_level = 2
     profile = RubyWarrior::Profile.new
     profile.current_epic_grades = { 1 => 0.7, 2 => 0.9 }
     @game.stubs(:profile).returns(profile)
-    @game.final_report.should be_nil
+    expect(@game.final_report).to be_nil
   end
 end

data/spec/ruby_warrior/level_loader_spec.rb

@@ -7,48 +7,48 @@ describe RubyWarrior::LevelLoader do
       @level = RubyWarrior::Level.new(@profile, 1)
       @loader = RubyWarrior::LevelLoader.new(@level)
     end
-    
+
     it "should be able to add description, tip and clue" do
       @loader.description "foo"
       @loader.tip "bar"
       @loader.clue "clue"
-      @level.description.should == "foo"
-      @level.tip.should == "bar"
-      @level.clue.should == "clue"
+      expect(@level.description).to eq("foo")
+      expect(@level.tip).to eq("bar")
+      expect(@level.clue).to eq("clue")
     end
-    
+
     it "should be able to set size" do
       @loader.size 5, 3
-      @level.floor.width.should == 5
-      @level.floor.height.should == 3
+      expect(@level.floor.width).to eq(5)
+      expect(@level.floor.height).to eq(3)
     end
-    
+
     it "should be able to add stairs" do
       @level.floor.expects(:place_stairs).with(1, 2)
       @loader.stairs 1, 2
     end
-    
+
     it "should yield new unit when building" do
       @loader.unit :base, 1, 2 do |unit|
-        unit.should be_kind_of(RubyWarrior::Units::Base)
-        unit.position.should be_at(1, 2)
+        expect(unit).to be_kind_of(RubyWarrior::Units::Base)
+        expect(unit.position).to be_at(1, 2)
       end
     end
-    
+
     it "should be able to add multi-word units" do
-      lambda { @loader.unit :thick_sludge, 1, 2 }.should_not raise_error
+      expect { @loader.unit :thick_sludge, 1, 2 }.to_not raise_error
     end
-    
+
     it "should build warrior from profile" do
       @loader.warrior 1, 2 do |unit|
-        unit.should be_kind_of(RubyWarrior::Units::Warrior)
-        unit.position.should be_at(1, 2)
+        expect(unit).to be_kind_of(RubyWarrior::Units::Warrior)
+        expect(unit.position).to be_at(1, 2)
       end
     end
-    
+
     it "should be able to set time bonus" do
       @loader.time_bonus 100
-      @level.time_bonus.should == 100
+      expect(@level.time_bonus).to eq(100)
     end
   end
 end

data/spec/ruby_warrior/level_spec.rb

@@ -9,64 +9,64 @@ describe RubyWarrior::Level do
     @level.floor = @floor
     @level.stubs(:failed?).returns(false)
   end
-  
+
   it "should consider passed when warrior is on stairs" do
     @level.warrior = RubyWarrior::Units::Warrior.new
     @floor.add(@level.warrior, 0, 0, :north)
     @floor.place_stairs(0, 0)
-    @level.should be_passed
+    expect(@level).to be_passed
   end
-  
+
   it "should default time bonus to zero" do
-    @level.time_bonus.should be_zero
+    expect(@level.time_bonus).to be_zero
   end
-  
+
   it "should have a grade relative to ace score" do
     @level.ace_score = 100
-    @level.grade_for(110).should == "S"
-    @level.grade_for(100).should == "S"
-    @level.grade_for(99).should == "A"
-    @level.grade_for(89).should == "B"
-    @level.grade_for(79).should == "C"
-    @level.grade_for(69).should == "D"
-    @level.grade_for(59).should == "F"
+    expect(@level.grade_for(110)).to eq("S")
+    expect(@level.grade_for(100)).to eq("S")
+    expect(@level.grade_for(99)).to eq("A")
+    expect(@level.grade_for(89)).to eq("B")
+    expect(@level.grade_for(79)).to eq("C")
+    expect(@level.grade_for(69)).to eq("D")
+    expect(@level.grade_for(59)).to eq("F")
   end
-  
+
   it "should have no grade if there is no ace score" do
-    @level.ace_score.should be_nil
-    @level.grade_for(100).should be_nil
+    expect(@level.ace_score).to be_nil
+    expect(@level.grade_for(100)).to be_nil
   end
-  
+
   it "should load file contents into level" do
     @level.stubs(:load_path).returns('path/to/level.rb')
     File.expects(:read).with('path/to/level.rb').returns("description 'foo'")
     @level.load_level
-    @level.description.should == 'foo'
+    expect(@level.description).to eq('foo')
   end
-  
+
   it "should have a player path from profile" do
     @profile.stubs(:player_path).returns('path/to/player')
-    @level.player_path.should == 'path/to/player'
+    expect(@level.player_path).to eq('path/to/player')
   end
-  
+
   it "should have a load path from profile tower with level number in it" do
     @profile.stubs(:tower_path).returns('path/to/tower')
-    @level.load_path.should == File.expand_path('towers/tower/level_001.rb')
+    expect(@level.load_path).to eq(File.expand_path('towers/tower/level_001.rb'))
   end
-  
+
   it "should exist if file exists" do
     @level.stubs(:load_path).returns('/foo/bar')
     File.expects(:exist?).with('/foo/bar').returns(true)
-    @level.exists?.should be_true
+    expect(@level.exists?).to eq(true)
   end
-  
+
   it "should load player and player path" do
     @level.stubs(:player_path).returns('player/path')
     $:.expects(:<<).with('player/path')
     @level.expects(:load).with('player.rb')
     @level.load_player
   end
-  
+
   it "should generate player files" do
     @level.expects(:load_level)
     generator = stub
@@ -74,31 +74,31 @@ describe RubyWarrior::Level do
     RubyWarrior::PlayerGenerator.expects(:new).with(@level).returns(generator)
     @level.generate_player_files
   end
-  
+
   it "should setup warrior with profile abilities" do
     @profile.abilities = [:foo, :bar]
     warrior = stub_everything
     warrior.expects(:add_abilities).with(:foo, :bar)
     @level.setup_warrior(warrior)
   end
-  
+
   it "should setup warrior with profile name" do
     @profile.warrior_name = "Joe"
     warrior = stub_everything
     warrior.expects(:name=).with("Joe")
     @level.setup_warrior(warrior)
   end
-  
+
   describe "playing" do
     before(:each) do
       @level.stubs(:load_level)
     end
-    
+
     it "should load level once when playing multiple turns" do
       @level.expects(:load_level)
       @level.play(2)
     end
-    
+
     it "should call prepare_turn and play_turn on each object specified number of times" do
       object = RubyWarrior::Units::Base.new
       object.expects(:prepare_turn).times(2)
@@ -106,7 +106,7 @@ describe RubyWarrior::Level do
       @floor.add(object, 0, 0, :north)
       @level.play(2)
     end
-  
+
     it "should return immediately when passed" do
       object = RubyWarrior::Units::Base.new
       object.expects(:turn).times(0)
@@ -114,90 +114,90 @@ describe RubyWarrior::Level do
       @level.stubs(:passed?).returns(true)
       @level.play(2)
     end
-  
+
     it "should yield to block in play method for each turn" do
       int = 0
       @level.play(2) do
         int += 1
       end
-      int.should == 2
+      expect(int).to eq(2)
     end
-  
+
     it "should count down time_bonus once each turn" do
       @level.time_bonus = 10
       @level.play(3)
-      @level.time_bonus.should == 7
+      expect(@level.time_bonus).to eq(7)
     end
-  
+
     it "should count down time_bonus below 0" do
       @level.time_bonus = 2
       @level.play(5)
-      @level.time_bonus.should be_zero
+      expect(@level.time_bonus).to be_zero
     end
-    
+
     it "should have a pretty score calculation" do
-      @level.score_calculation(123, 45).should == "123 + 45 = 168"
+      expect(@level.score_calculation(123, 45)).to eq("123 + 45 = 168")
     end
-    
+
     it "should not have a score calculation when starting score is zero" do
-      @level.score_calculation(0, 45).should == "45"
+      expect(@level.score_calculation(0, 45)).to eq("45")
     end
   end
-  
+
   describe "tallying points" do
     before(:each) do
       @warrior = stub(:score => 0, :abilities => {})
       @level.stubs(:warrior).returns(@warrior)
       @level.floor.stubs(:other_units).returns([stub])
     end
-    
+
     it "should add warrior score to profile" do
       @warrior.stubs(:score).returns(30)
       @level.tally_points
-      @profile.score.should == 30
+      expect(@profile.score).to eq(30)
     end
-    
+
     it "should add warrior score to profile for epic mode" do
       @profile.enable_epic_mode
       @warrior.stubs(:score).returns(30)
       @level.tally_points
-      @profile.current_epic_score.should == 30
+      expect(@profile.current_epic_score).to eq(30)
     end
-    
+
     it "should add level grade percent to profile for epic mode" do
       @level.ace_score = 100
       @profile.enable_epic_mode
       @warrior.stubs(:score).returns(30)
       @level.tally_points
-      @profile.current_epic_grades.should == { 1 => 0.3 }
+      expect(@profile.current_epic_grades).to eq({ 1 => 0.3 })
     end
-    
+
     it "should not add level grade if ace score is not set" do
       @level.ace_score = nil
       @profile.enable_epic_mode
       @warrior.stubs(:score).returns(30)
       @level.tally_points
-      @profile.current_epic_grades.should == {}
+      expect(@profile.current_epic_grades).to eq({})
     end
-    
+
     it "should apply warrior abilities to profile" do
       @warrior.stubs(:abilities).returns({:foo => nil, :bar => nil})
       @level.tally_points
-      @profile.abilities.to_set.should == [:foo, :bar].to_set
+      expect(@profile.abilities.to_set).to eq([:foo, :bar].to_set)
     end
-    
+
     it "should apply time bonus to profile score" do
       @level.time_bonus = 20
       @level.tally_points
-      @profile.score.should == 20
+      expect(@profile.score).to eq(20)
     end
-    
+
     it "should give 20% bonus when no other units left" do
       @level.floor.stubs(:other_units).returns([])
       @warrior.stubs(:score).returns(10)
       @level.time_bonus = 10
       @level.tally_points
-      @profile.score.should == 24
+      expect(@profile.score).to eq(24)
     end
   end
 end

data/spec/ruby_warrior/player_generator_spec.rb

@@ -5,8 +5,8 @@ describe RubyWarrior::PlayerGenerator do
     @level = RubyWarrior::Level.new(RubyWarrior::Profile.new, 15)
     @generator = RubyWarrior::PlayerGenerator.new(@level)
   end
-  
+
   it "should know templates path" do
-    @generator.templates_path.should == File.expand_path("../../../templates", __FILE__)
+    expect(@generator.templates_path).to eq(File.expand_path("../../../templates", __FILE__))
   end
 end

data/spec/ruby_warrior/position_spec.rb

@@ -9,100 +9,100 @@ describe RubyWarrior::Position do
     @floor.add(@unit, 1, 2, :north)
     @position = @unit.position
   end
-  
+
   it "should rotate clockwise" do
-    @position.direction.should == :north
+    expect(@position.direction).to eq(:north)
     [:east, :south, :west, :north, :east].each do |dir|
       @position.rotate(1)
-      @position.direction.should == dir
+      expect(@position.direction).to eq(dir)
     end
   end
-  
+
   it "should rotate counterclockwise" do
-    @position.direction.should == :north
+    expect(@position.direction).to eq(:north)
     [:west, :south, :east, :north, :west].each do |dir|
       @position.rotate(-1)
-      @position.direction.should == dir
+      expect(@position.direction).to eq(dir)
     end
   end
-  
+
   it "should get relative space in front" do
     unit = RubyWarrior::Units::Base.new
     @floor.add(unit, 1, 1)
-    @position.relative_space(1).should_not be_empty
+    expect(@position.relative_space(1)).to_not be_empty
   end
-  
+
   it "should get relative object in front when rotated" do
     unit = RubyWarrior::Units::Base.new
     @floor.add(unit, 2, 2)
     @position.rotate(1)
-    @position.relative_space(1).should_not be_empty
+    expect(@position.relative_space(1)).to_not be_empty
   end
-  
+
   it "should get relative object diagonally" do
     unit = RubyWarrior::Units::Base.new
     @floor.add(unit, 0, 1)
-    @position.relative_space(1, -1).should_not be_empty
+    expect(@position.relative_space(1, -1)).to_not be_empty
   end
-  
+
   it "should get relative object diagonally when rotating" do
     unit = RubyWarrior::Units::Base.new
     @floor.add(unit, 0, 1)
     @position.rotate(2)
-    @position.relative_space(-1, 1).should_not be_empty
+    expect(@position.relative_space(-1, 1)).to_not be_empty
   end
-  
+
   it "should move object on floor relatively" do
-    @floor.get(1, 2).should == @unit
+    expect(@floor.get(1, 2)).to eq(@unit)
     @position.move(-1, 2)
-    @floor.get(1, 2).should be_nil
-    @floor.get(3, 3).should == @unit
+    expect(@floor.get(1, 2)).to be_nil
+    expect(@floor.get(3, 3)).to eq(@unit)
     @position.rotate(1)
     @position.move(-1)
-    @floor.get(3, 3).should be_nil
-    @floor.get(2, 3).should == @unit
+    expect(@floor.get(3, 3)).to be_nil
+    expect(@floor.get(2, 3)).to eq(@unit)
   end
-  
+
   it "should return distance from stairs as 0 when on stairs" do
     @floor.place_stairs(1, 2)
-    @position.distance_from_stairs.should == 0
+    expect(@position.distance_from_stairs).to eq(0)
   end
-  
+
   it "should return distance from stairs in both directions" do
     @floor.place_stairs(0, 3)
-    @position.distance_from_stairs.should == 2
+    expect(@position.distance_from_stairs).to eq(2)
   end
-  
+
   it "should return relative direction of stairs" do
     @floor.place_stairs(0, 0)
-    @position.relative_direction_of_stairs.should == :forward
+    expect(@position.relative_direction_of_stairs).to eq(:forward)
   end
-  
+
   it "should return relative direction of given space" do
-    @position.relative_direction_of(@floor.space(5, 3)).should == :right
+    expect(@position.relative_direction_of(@floor.space(5, 3))).to eq(:right)
     @position.rotate 1
-    @position.relative_direction_of(@floor.space(1, 4)).should == :right
+    expect(@position.relative_direction_of(@floor.space(1, 4))).to eq(:right)
   end
-  
+
   it "should be able to determine relative direction" do
-    @position.relative_direction(:north).should == :forward
-    @position.relative_direction(:south).should == :backward
-    @position.relative_direction(:west).should == :left
-    @position.relative_direction(:east).should == :right
+    expect(@position.relative_direction(:north)).to eq(:forward)
+    expect(@position.relative_direction(:south)).to eq(:backward)
+    expect(@position.relative_direction(:west)).to eq(:left)
+    expect(@position.relative_direction(:east)).to eq(:right)
     @position.rotate 1
-    @position.relative_direction(:north).should == :left
+    expect(@position.relative_direction(:north)).to eq(:left)
     @position.rotate 1
-    @position.relative_direction(:north).should == :backward
+    expect(@position.relative_direction(:north)).to eq(:backward)
     @position.rotate 1
-    @position.relative_direction(:north).should == :right
+    expect(@position.relative_direction(:north)).to eq(:right)
   end
-  
+
   it "should return a space at the same location as position" do
-    @position.space.location.should == [1, 2]
+    expect(@position.space.location).to eq([1, 2])
   end
-  
+
   it "should return distance of given space" do
-    @position.distance_of(@floor.space(5, 3)).should == 5
-    @position.distance_of(@floor.space(4, 2)).should == 3
+    expect(@position.distance_of(@floor.space(5, 3))).to eq(5)
+    expect(@position.distance_of(@floor.space(4, 2))).to eq(3)
   end
 end