rubywarrior 0.1.3 → 0.2.0

data/spec/ruby_warrior/profile_spec.rb

@@ -4,80 +4,80 @@ 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('tower').returns('tower')
-      @profile.tower.should == 'tower'
+      expect(@profile.tower).to eq('tower')
     end
   end
 end

data/spec/ruby_warrior/space_spec.rb

@@ -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

@@ -4,12 +4,12 @@ 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

data/spec/ruby_warrior/turn_spec.rb

@@ -5,27 +5,27 @@ describe RubyWarrior::Turn do
     before(:each) do
       @turn = RubyWarrior::Turn.new({:walk! => nil, :attack! => nil})
     end
-    
+
     it "should have no action performed at first" do
-      @turn.action.should be_nil
+      expect(@turn.action).to be_nil
     end
-    
+
     it "should be able to perform action and recall it" do
       @turn.walk!
-      @turn.action.should == [:walk!]
+      expect(@turn.action).to eq([:walk!])
     end
-    
+
     it "should include arguments passed to action" do
       @turn.walk! :forward
-      @turn.action.should == [:walk!, :forward]
+      expect(@turn.action).to eq([:walk!, :forward])
     end
-    
+
     it "should not be able to call multiple actions per turn" do
       @turn.walk! :forward
-      lambda { @turn.attack! }.should raise_error
+      expect { @turn.attack! }.to raise_error("Only one action can be performed per turn.")
     end
   end
-  
+
   describe "with senses" do
     before(:each) do
       @feel = RubyWarrior::Abilities::Feel.new(Object.new)
@@ -33,10 +33,10 @@ describe RubyWarrior::Turn do
       @feel.stubs(:space).with(:backward).returns(Object.new)
       @turn = RubyWarrior::Turn.new({:feel => @feel})
     end
-    
+
     it "should be able to call sense with any argument and return expected results" do
-      @turn.feel.should == @feel.perform
-      @turn.feel(:backward).should == @feel.perform(:backward)
+      expect(@turn.feel).to eq(@feel.perform)
+      expect(@turn.feel(:backward)).to eq(@feel.perform(:backward))
     end
   end
 end

data/spec/ruby_warrior/ui_spec.rb

@@ -9,82 +9,82 @@ describe RubyWarrior::UI do
     @config.out_stream = @out
     @config.in_stream = @in
   end
-  
+
   it "should add puts to out stream" do
     @ui.puts "hello"
-    @out.string.should == "hello\n"
+    expect(@out.string).to eq("hello\n")
   end
-  
+
   it "should add print to out stream without newline" do
     @ui.print "hello"
-    @out.string.should == "hello"
+    expect(@out.string).to eq("hello")
   end
-  
+
   it "should fetch gets from in stream" do
     @in.puts "bar"
     @in.rewind
-    @ui.gets.should == "bar\n"
+    expect(@ui.gets).to eq("bar\n")
   end
-  
+
   it "should gets should return empty string if no input" do
     @config.in_stream = nil
-    @ui.gets.should == ""
+    expect(@ui.gets).to eq("")
   end
-  
+
   it "should request text input" do
     @in.puts "bar"
     @in.rewind
-    @ui.request("foo").should == "bar"
-    @out.string.should == "foo"
+    expect(@ui.request("foo")).to eq("bar")
+    expect(@out.string).to eq("foo")
   end
-  
+
   it "should ask for yes/no and return true when yes" do
     @ui.expects(:request).with('foo? [yn] ').returns('y')
-    @ui.ask("foo?").should be_true
+    expect(@ui.ask("foo?")).to eq(true)
   end
-  
+
   it "should ask for yes/no and return false when no" do
     @ui.stubs(:request).returns('n')
-    @ui.ask("foo?").should be_false
+    expect(@ui.ask("foo?")).to eq(false)
   end
-  
+
   it "should ask for yes/no and return false for any input" do
     @ui.stubs(:request).returns('aklhasdf')
-    @ui.ask("foo?").should be_false
+    expect(@ui.ask("foo?")).to eq(false)
   end
-  
+
   it "should present multiple options and return selected one" do
     @ui.expects(:request).with(includes('item')).returns('2')
-    @ui.choose('item', [:foo, :bar, :test]).should == :bar
-    @out.string.should include('[1] foo')
-    @out.string.should include('[2] bar')
-    @out.string.should include('[3] test')
+    expect(@ui.choose('item', [:foo, :bar, :test])).to eq(:bar)
+    expect(@out.string).to include('[1] foo')
+    expect(@out.string).to include('[2] bar')
+    expect(@out.string).to include('[3] test')
   end
-  
+
   it "choose should accept array as option" do
     @ui.stubs(:request).returns('3')
-    @ui.choose('item', [:foo, :bar, [:tower, 'easy']]).should == :tower
-    @out.string.should include('[3] easy')
+    expect(@ui.choose('item', [:foo, :bar, [:tower, 'easy']])).to eq(:tower)
+    expect(@out.string).to include('[3] easy')
   end
-  
+
   it "choose should return option without prompt if only one item" do
     @ui.expects(:puts).never
     @ui.expects(:gets).never
     @ui.stubs(:request).returns('3')
-    @ui.choose('item', [:foo]).should == :foo
+    expect(@ui.choose('item', [:foo])).to eq(:foo)
   end
-  
+
   it "choose should return first value in array of option if only on item" do
-    @ui.choose('item', [[:foo, :bar]]).should == :foo
+    expect(@ui.choose('item', [[:foo, :bar]])).to eq(:foo)
   end
-  
+
   it "should delay after puts when specified" do
     @config.delay = 1.3
     @ui.expects(:puts).with("foo")
     @ui.expects(:sleep).with(1.3)
     @ui.puts_with_delay("foo")
   end
-  
+
   it "should not delay puts when delay isn't specified" do
     @ui.expects(:puts).with("foo")
     @ui.expects(:sleep).never