rubywarrior 0.1.2 → 0.2.0

data/spec/ruby_warrior/position_spec.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/../spec_helper'
+require 'spec_helper'
 
 describe RubyWarrior::Position do
   before(:each) do
@@ -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

data/spec/ruby_warrior/profile_spec.rb

@@ -1,83 +1,83 @@
-require File.dirname(__FILE__) + '/../spec_helper'
+require 'spec_helper'
 
 describe RubyWarrior::Profile do
   before(:each) do
     @profile = RubyWarrior::Profile.new
   end
-  
+
   it "should have warrior name" do
     @profile.warrior_name = 'Joe'
-    @profile.warrior_name.should == 'Joe'
+    expect(@profile.warrior_name).to eq('Joe')
   end
-  
+
   it "should start level number at 0" do
-    @profile.level_number.should be_zero
+    expect(@profile.level_number).to be_zero
   end
-  
+
   it "should start score at 0 and allow it to increment" do
-    @profile.score.should be_zero
+    expect(@profile.score).to be_zero
     @profile.score += 5
-    @profile.score.should == 5
+    expect(@profile.score).to eq(5)
   end
-  
+
   it "should have no abilities and allow adding" do
-    @profile.abilities.should == []
+    expect(@profile.abilities).to eq([])
     @profile.abilities += [:foo, :bar]
-    @profile.abilities.should == [:foo, :bar]
+    expect(@profile.abilities).to eq([:foo, :bar])
   end
-  
+
   it "should encode with marshal + base64" do
-    @profile.encode.should == Base64.encode64(Marshal.dump(@profile))
+    expect(@profile.encode).to eq(Base64.encode64(Marshal.dump(@profile)))
   end
-  
+
   it "should decode with marshal + base64" do
-    RubyWarrior::Profile.decode(@profile.encode).warrior_name.should == @profile.warrior_name
+    expect(RubyWarrior::Profile.decode(@profile.encode).warrior_name).to eq(@profile.warrior_name)
   end
-  
+
   it "load should read file, decode and set player path" do
     profile = 'profile'
     profile.expects(:player_path=).with('path/to')
     File.expects(:read).with('path/to/.profile').returns('encoded_profile')
     RubyWarrior::Profile.expects(:decode).with('encoded_profile').returns(profile)
-    RubyWarrior::Profile.load('path/to/.profile').should == profile
+    expect(RubyWarrior::Profile.load('path/to/.profile')).to eq(profile)
   end
 
-  
+
   it "should add abilities and remove duplicates" do
     @profile.add_abilities(:foo, :bar, :blah, :bar)
-    @profile.abilities.should == [:foo, :bar, :blah]
+    expect(@profile.abilities).to eq([:foo, :bar, :blah])
   end
-    
+
   it "should fetch new level with current number" do
     @profile.level_number = 1
-    @profile.current_level.number.should == 1
+    expect(@profile.current_level.number).to eq(1)
   end
 
   it "should fetch next level" do
     @profile.level_number = 1
-    @profile.next_level.number.should == 2
+    expect(@profile.next_level.number).to eq(2)
   end
 
   it "should enable epic mode and reset scores if nil" do
     @profile.epic_score = nil
     @profile.current_epic_score = nil
     @profile.enable_epic_mode
-    @profile.should be_epic
-    @profile.epic_score.should be_zero
-    @profile.current_epic_score.should be_zero
+    expect(@profile).to be_epic
+    expect(@profile.epic_score).to be_zero
+    expect(@profile.current_epic_score).to be_zero
   end
-  
+
   it "should override epic score with current one if it is higher" do
     @profile.enable_epic_mode
-    @profile.epic_score.should be_zero
-    @profile.average_grade.should be_nil
+    expect(@profile.epic_score).to be_zero
+    expect(@profile.average_grade).to be_nil
     @profile.current_epic_score = 123
     @profile.current_epic_grades = { 1 => 0.7, 2 => 0.9 }
     @profile.update_epic_score
-    @profile.epic_score.should == 123
-    @profile.average_grade.should == 0.8
+    expect(@profile.epic_score).to eq(123)
+    expect(@profile.average_grade).to eq(0.8)
   end
-  
+
   it "should not override epic score with current one if it is lower" do
     @profile.enable_epic_mode
     @profile.epic_score = 124
@@ -85,20 +85,20 @@ describe RubyWarrior::Profile do
     @profile.current_epic_score = 123
     @profile.current_epic_grades = { 1 => 0.7, 2 => 0.9 }
     @profile.update_epic_score
-    @profile.epic_score.should == 124
-    @profile.average_grade.should == 0.9
+    expect(@profile.epic_score).to eq(124)
+    expect(@profile.average_grade).to eq(0.9)
   end
-  
+
   it "should not calculate average grade if no grades are present" do
     @profile.enable_epic_mode
     @profile.current_epic_grades = {}
-    @profile.calculate_average_grade.should be_nil
+    expect(@profile.calculate_average_grade).to be_nil
   end
 
   it "should remember current level number as last_level_number" do
     @profile.level_number = 7
     @profile.enable_epic_mode
-    @profile.last_level_number.should == 7
+    expect(@profile.last_level_number).to eq(7)
   end
 
   it "should enable normal mode by clearing epic scores and resetting last level number" do
@@ -108,26 +108,26 @@ describe RubyWarrior::Profile do
     @profile.current_epic_grades = { 1 => 100 }
     @profile.average_grade = "C"
     @profile.enable_normal_mode
-    @profile.should_not be_epic
-    @profile.epic_score.should be_zero
-    @profile.current_epic_score.should be_zero
-    @profile.last_level_number.should be_nil
-    @profile.average_grade.should be_nil
-    @profile.current_epic_grades.should == {}
-    @profile.level_number.should == 7
+    expect(@profile).to_not be_epic
+    expect(@profile.epic_score).to be_zero
+    expect(@profile.current_epic_score).to be_zero
+    expect(@profile.last_level_number).to be_nil
+    expect(@profile.average_grade).to be_nil
+    expect(@profile.current_epic_grades).to eq({})
+    expect(@profile.level_number).to eq(7)
   end
 
   it "should be no level after epic if last level isn't specified" do
     @profile.last_level_number = nil
-    @profile.should_not be_level_after_epic
+    expect(@profile).to_not be_level_after_epic
   end
-  
+
   describe "with tower path" do
     before(:each) do
       @profile.warrior_name = "John Smith"
       @profile.tower_path = 'path/to/tower'
     end
-    
+
     it "save should write file with encoded profile" do
       file = stub
       file.expects(:write).with('encoded_profile')
@@ -135,37 +135,37 @@ describe RubyWarrior::Profile do
       @profile.expects(:encode).returns('encoded_profile')
       @profile.save
     end
-    
+
     it "should have a nice string representation" do
       @profile.warrior_name = 'Joe'
-      @profile.to_s.should == "Joe - tower - level 0 - score 0"
+      expect(@profile.to_s).to eq("Joe - tower - level 0 - score 0")
     end
-    
+
     it "should include epic score in string representation" do
       @profile.warrior_name = 'Joe'
       @profile.enable_epic_mode
-      @profile.to_s.should == "Joe - tower - first score 0 - epic score 0"
+      expect(@profile.to_s).to eq("Joe - tower - first score 0 - epic score 0")
     end
-    
+
     it "should include epic score with grade in string representation" do
       @profile.warrior_name = 'Joe'
       @profile.enable_epic_mode
       @profile.average_grade = 0.7
-      @profile.to_s.should == "Joe - tower - first score 0 - epic score 0 (C)"
+      expect(@profile.to_s).to eq("Joe - tower - first score 0 - epic score 0 (C)")
     end
-    
+
     it "should guess at the player path" do
-      @profile.player_path.should == './rubywarrior/john-smith-tower'
+      expect(@profile.player_path).to eq('./rubywarrior/john-smith-tower')
     end
-  
+
     it "should use specified player path" do
       @profile.player_path = "path/to/player"
-      @profile.player_path.should == "path/to/player"
+      expect(@profile.player_path).to eq("path/to/player")
     end
-  
+
     it "should load tower from path" do
-      RubyWarrior::Tower.expects(:new).with('path/to/tower').returns('tower')
-      @profile.tower.should == 'tower'
+      RubyWarrior::Tower.expects(:new).with('tower').returns('tower')
+      expect(@profile.tower).to eq('tower')
     end
   end
 end

data/spec/ruby_warrior/space_spec.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/../spec_helper'
+require 'spec_helper'
 
 describe RubyWarrior::Space do
   before(:each) do
@@ -6,185 +6,185 @@ describe RubyWarrior::Space do
     @floor.width = 2
     @floor.height = 3
   end
-  
+
   describe "with empty space" do
     before(:each) do
       @space = @floor.space(0, 0)
     end
-    
+
     it "should not be enemy" do
-      @space.should_not be_enemy
+      expect(@space).to_not be_enemy
     end
-    
+
     it "should not be warrior" do
-      @space.should_not be_warrior
+      expect(@space).to_not be_warrior
     end
-    
+
     it "should be empty" do
-      @space.should be_empty
+      expect(@space).to be_empty
     end
-    
+
     it "should not be wall" do
-      @space.should_not be_wall
+      expect(@space).to_not be_wall
     end
-    
+
     it "should not be stairs" do
-      @space.should_not be_stairs
+      expect(@space).to_not be_stairs
     end
-    
+
     it "should not be captive" do
-      @space.should_not be_captive
+      expect(@space).to_not be_captive
     end
-    
+
     it "should say 'nothing' as name" do
-      @space.to_s.should == 'nothing'
+      expect(@space.to_s).to eq('nothing')
     end
-    
+
     it "should not be ticking" do
-      @space.should_not be_ticking
+      expect(@space).to_not be_ticking
     end
   end
-  
+
   describe "out of bounds" do
     before(:each) do
       @space = @floor.space(-1, 1)
     end
-  
+
     it "should be wall" do
-      @space.should be_wall
+      expect(@space).to be_wall
     end
-  
+
     it "should not be empty" do
-      @space.should_not be_empty
+      expect(@space).to_not be_empty
     end
-    
+
     it "should have name of 'wall'" do
-      @space.to_s.should == 'wall'
+      expect(@space.to_s).to eq('wall')
     end
   end
-  
+
   describe "with warrior" do
     before(:each) do
       warrior = RubyWarrior::Units::Warrior.new
       @floor.add(warrior, 0, 0)
       @space = @floor.space(0, 0)
     end
-    
+
     it "should be warrior" do
-      @space.should be_warrior
+      expect(@space).to be_warrior
     end
-    
+
     it "should be player" do
-      @space.should be_warrior
+      expect(@space).to be_warrior
     end
-    
+
     it "should not be enemy" do
-      @space.should_not be_enemy
+      expect(@space).to_not be_enemy
     end
-    
+
     it "should not be empty" do
-      @space.should_not be_enemy
+      expect(@space).to_not be_enemy
     end
-    
+
     it "should know what unit is on that space" do
-      @space.unit.should be_kind_of(RubyWarrior::Units::Warrior)
+      expect(@space.unit).to be_kind_of(RubyWarrior::Units::Warrior)
     end
   end
-  
+
   describe "with enemy" do
     before(:each) do
       @floor.add(RubyWarrior::Units::Sludge.new, 0, 0)
       @space = @floor.space(0, 0)
     end
-    
+
     it "should be enemy" do
-      @space.should be_enemy
+      expect(@space).to be_enemy
     end
-    
+
     it "should not be warrior" do
-      @space.should_not be_warrior
+      expect(@space).to_not be_warrior
     end
-    
+
     it "should not be empty" do
-      @space.should_not be_empty
+      expect(@space).to_not be_empty
     end
-    
+
     it "should have name of unit" do
-      @space.to_s.should == "Sludge"
+      expect(@space.to_s).to eq("Sludge")
     end
-    
+
     describe "bound" do
       before(:each) do
         @space.unit.bind
       end
-      
+
       it "should be captive" do
-        @space.should be_captive
+        expect(@space).to be_captive
       end
-      
+
       it "should not look like enemy" do
-        @space.should_not be_enemy
+        expect(@space).to_not be_enemy
       end
     end
   end
-  
+
   describe "with captive" do
     before(:each) do
       @captive = RubyWarrior::Units::Captive.new
       @floor.add(@captive, 0, 0)
       @space = @floor.space(0, 0)
     end
-    
+
     it "should be captive" do
-      @space.should be_captive
+      expect(@space).to be_captive
     end
-    
+
     it "should not be enemy" do
-      @space.should_not be_enemy
+      expect(@space).to_not be_enemy
     end
-    
+
     it "should be ticking if captive has time bomb" do
       @captive.add_abilities :explode!
-      @space.should be_ticking
+      expect(@space).to be_ticking
     end
-    
+
     it "should not be ticking if captive does not have time bomb" do
-      @space.should_not be_ticking
+      expect(@space).to_not be_ticking
     end
   end
-  
+
   describe "with golem" do
     before(:each) do
       @golem = RubyWarrior::Units::Golem.new
       @floor.add(@golem, 0, 0)
       @space = @floor.space(0, 0)
     end
-    
+
     it "should be golem" do
-      @space.should be_golem
+      expect(@space).to be_golem
     end
-    
+
     it "should not be enemy" do
-      @space.should_not be_enemy
+      expect(@space).to_not be_enemy
     end
-    
+
     it "should be player" do
-      @space.should be_player
+      expect(@space).to be_player
     end
   end
-  
+
   describe "at stairs" do
     before(:each) do
       @floor.place_stairs(0, 0)
       @space = @floor.space(0, 0)
     end
-    
+
     it "should be empty" do
-      @space.should be_empty
+      expect(@space).to be_empty
     end
-    
+
     it "should be stairs" do
-      @space.should be_stairs
+      expect(@space).to be_stairs
     end
   end
 end

data/spec/ruby_warrior/tower_spec.rb

@@ -1,15 +1,15 @@
-require File.dirname(__FILE__) + '/../spec_helper'
+require 'spec_helper'
 
 describe RubyWarrior::Tower do
   before(:each) do
     @tower = RubyWarrior::Tower.new('path/to/tower')
   end
-  
+
   it "should consider last part of path as name" do
-    @tower.name.should == 'tower'
+    expect(@tower.name).to eq('tower')
   end
-  
+
   it "should use name when converting to string" do
-    @tower.to_s.should == @tower.name
+    expect(@tower.to_s).to eq(@tower.name)
   end
 end