rubywarrior 0.1.3 → 0.2.0

data/spec/ruby_warrior/abilities/base_spec.rb

@@ -5,34 +5,34 @@ describe RubyWarrior::Abilities::Base do
     @unit = stub
     @ability = RubyWarrior::Abilities::Base.new(@unit)
   end
-  
+
   it "should have offset for directions" do
-    @ability.offset(:forward).should == [1, 0]
-    @ability.offset(:right).should == [0, 1]
-    @ability.offset(:backward).should == [-1, 0]
-    @ability.offset(:left).should == [0, -1]
+    expect(@ability.offset(:forward)).to eq([1, 0])
+    expect(@ability.offset(:right)).to eq([0, 1])
+    expect(@ability.offset(:backward)).to eq([-1, 0])
+    expect(@ability.offset(:left)).to eq([0, -1])
   end
-  
+
   it "should have offset for relative forward/right amounts" do
-    @ability.offset(:forward, 2).should == [2, 0]
-    @ability.offset(:forward, 2, 1).should == [2, -1]
-    @ability.offset(:right, 2, 1).should == [1, 2]
-    @ability.offset(:backward, 2, 1).should == [-2, 1]
-    @ability.offset(:left, 2, 1).should == [-1, -2]
+    expect(@ability.offset(:forward, 2)).to eq([2, 0])
+    expect(@ability.offset(:forward, 2, 1)).to eq([2, -1])
+    expect(@ability.offset(:right, 2, 1)).to eq([1, 2])
+    expect(@ability.offset(:backward, 2, 1)).to eq([-2, 1])
+    expect(@ability.offset(:left, 2, 1)).to eq([-1, -2])
   end
-  
+
   it "should fetch unit at given direction with distance" do
     @ability.expects(:space).with(:right, 3, 1).returns(stub(:unit => 'unit'))
-    @ability.unit(:right, 3, 1).should == 'unit'
+    expect(@ability.unit(:right, 3, 1)).to eq('unit')
   end
-  
+
   it "should have no description" do
-    @ability.description.should be_nil
+    expect(@ability.description).to be_nil
   end
-  
+
   it "should raise an exception if direction isn't recognized" do
-    lambda {
+    expect {
       @ability.verify_direction(:foo)
-    }.should raise_error("Unknown direction :foo. Should be :forward, :backward, :left or :right.")
+    }.to raise_error("Unknown direction :foo. Should be :forward, :backward, :left or :right.")
   end
 end

data/spec/ruby_warrior/abilities/bind_spec.rb

@@ -4,16 +4,16 @@ describe RubyWarrior::Abilities::Bind do
   before(:each) do
     @bind = RubyWarrior::Abilities::Bind.new(stub(:say => nil))
   end
-  
+
   it "should bind recipient" do
     receiver = RubyWarrior::Units::Base.new
     @bind.stubs(:unit).returns(receiver)
     @bind.perform
-    receiver.should be_bound
+    expect(receiver).to be_bound
   end
-  
+
   it "should do nothing if no recipient" do
     @bind.stubs(:unit).returns(nil)
-    lambda { @bind.perform }.should_not raise_error
+    expect { @bind.perform }.to_not raise_error
   end
 end

data/spec/ruby_warrior/abilities/direction_of_spec.rb

@@ -5,9 +5,9 @@ describe RubyWarrior::Abilities::DirectionOf do
     @position = stub
     @distance = RubyWarrior::Abilities::DirectionOf.new(stub(:position => @position, :say => nil))
   end
-  
+
   it "should return relative direction of given space" do
     @position.stubs(:relative_direction_of).with(:space).returns(:left)
-    @distance.perform(:space).should == :left
+    expect(@distance.perform(:space)).to eq(:left)
   end
 end

data/spec/ruby_warrior/abilities/direction_of_stairs_spec.rb

@@ -5,9 +5,9 @@ describe RubyWarrior::Abilities::DirectionOfStairs do
     @position = stub
     @distance = RubyWarrior::Abilities::DirectionOfStairs.new(stub(:position => @position, :say => nil))
   end
-  
+
   it "should return relative direction of stairs" do
     @position.stubs(:relative_direction_of_stairs).returns(:left)
-    @distance.perform.should == :left
+    expect(@distance.perform).to eq(:left)
   end
 end

data/spec/ruby_warrior/abilities/distance_of_spec.rb

@@ -5,9 +5,9 @@ describe RubyWarrior::Abilities::DistanceOf do
     @position = stub
     @distance = RubyWarrior::Abilities::DistanceOf.new(stub(:position => @position, :say => nil))
   end
-  
+
   it "should return distance from stairs" do
     @position.stubs(:distance_of).with(:space).returns(5)
-    @distance.perform(:space).should == 5
+    expect(@distance.perform(:space)).to eq(5)
   end
 end

data/spec/ruby_warrior/abilities/explode_spec.rb

@@ -9,24 +9,24 @@ describe RubyWarrior::Abilities::Explode do
     @floor.add(@captive, 0, 0)
     @explode = RubyWarrior::Abilities::Explode.new(@captive)
   end
-  
+
   it "should subtract 100 health from each unit on the floor" do
     unit = RubyWarrior::Units::Base.new
     unit.health = 20
     @floor.add(unit, 0, 1)
     @captive.health = 10
     @explode.perform
-    @captive.health.should == -90
-    unit.health.should == -80
+    expect(@captive.health).to eq(-90)
+    expect(unit.health).to eq(-80)
   end
-  
+
   it "should explode when bomb time reaches zero" do
     @captive.health = 10
     @explode.time = 3
     @explode.pass_turn
     @explode.pass_turn
-    @captive.health.should == 10
+    expect(@captive.health).to eq(10)
     @explode.pass_turn
-    @captive.health.should == -90
+    expect(@captive.health).to eq(-90)
   end
 end

data/spec/ruby_warrior/abilities/form_spec.rb

@@ -9,40 +9,40 @@ describe RubyWarrior::Abilities::Form do
     @floor.add(@warrior, 0, 0, :east)
     @form = RubyWarrior::Abilities::Form.new(@warrior)
   end
-  
+
   it "should form a golem in front of warrior" do
     @form.perform
-    @floor.get(1, 0).should be_kind_of(RubyWarrior::Units::Golem)
+    expect(@floor.get(1, 0)).to be_kind_of(RubyWarrior::Units::Golem)
   end
-  
+
   it "should form a golem in given direction" do
     @form.perform(:right)
-    @floor.get(0, 1).should be_kind_of(RubyWarrior::Units::Golem)
+    expect(@floor.get(0, 1)).to be_kind_of(RubyWarrior::Units::Golem)
   end
-  
+
   it "should not form golem if space isn't empty" do
     @floor.add(RubyWarrior::Units::Base.new, 1, 0)
     @form.perform(:forward)
     @form.perform(:left)
-    @floor.units.size.should == 2
+    expect(@floor.units.size).to eq(2)
   end
-  
+
   it "should reduce warrior's health by half (rounding down) and give it to the golem" do
     @warrior.health = 19
     @form.perform
-    @warrior.health.should == 10
-    @floor.get(1, 0).max_health.should == 9
+    expect(@warrior.health).to eq(10)
+    expect(@floor.get(1, 0).max_health).to eq(9)
   end
-  
+
   it "should add passed block as golem's turn block" do
     @passed = nil
     @form.perform(:forward) { |turn| @passed = turn }
     @floor.get(1, 0).play_turn(:turn)
-    @passed.should == :turn
+    expect(@passed).to eq(:turn)
   end
-  
+
   it "should start in same direction as warrior" do
     @form.perform(:right)
-    @floor.get(0, 1).position.direction.should == :east
+    expect(@floor.get(0, 1).position.direction).to eq(:east)
   end
 end

data/spec/ruby_warrior/abilities/health_spec.rb

@@ -5,9 +5,9 @@ describe RubyWarrior::Abilities::Health do
     @warrior = RubyWarrior::Units::Warrior.new
     @health = RubyWarrior::Abilities::Health.new(@warrior)
   end
-  
+
   it "should return the amount of health" do
     @warrior.health = 10
-    @health.perform.should == 10
+    expect(@health.perform).to eq(10)
   end
 end

data/spec/ruby_warrior/abilities/listen_spec.rb

@@ -9,9 +9,9 @@ describe RubyWarrior::Abilities::Listen do
     @floor.add(@warrior, 0, 0)
     @listen = RubyWarrior::Abilities::Listen.new(@warrior)
   end
-  
+
   it "should return an array of spaces which have units on them besides main unit" do
     @floor.add(RubyWarrior::Units::Base.new, 0, 1)
-    @listen.perform.should have(1).record
+    expect(@listen.perform.size).to eq(1)
   end
 end

data/spec/ruby_warrior/abilities/look_spec.rb

@@ -5,11 +5,11 @@ describe RubyWarrior::Abilities::Look do
     @unit = stub(:position => stub, :say => nil)
     @feel = RubyWarrior::Abilities::Look.new(@unit)
   end
-  
+
   it "should get 3 objects at position from offset" do
     @unit.position.expects(:relative_space).with(1, 0).returns(1)
     @unit.position.expects(:relative_space).with(2, 0).returns(2)
     @unit.position.expects(:relative_space).with(3, 0).returns(3)
-    @feel.perform(:forward).should == [1, 2, 3]
+    expect(@feel.perform(:forward)).to eq([1, 2, 3])
   end
 end

data/spec/ruby_warrior/abilities/rescue_spec.rb

@@ -5,7 +5,7 @@ describe RubyWarrior::Abilities::Rescue do
     @warrior = RubyWarrior::Units::Warrior.new
     @rescue = RubyWarrior::Abilities::Rescue.new(@warrior)
   end
-  
+
   it "should rescue captive" do
     captive = RubyWarrior::Units::Captive.new
     captive.position = stub
@@ -13,9 +13,9 @@ describe RubyWarrior::Abilities::Rescue do
     @rescue.expects(:unit).with(:forward).returns(captive)
     @warrior.expects(:earn_points).with(20)
     @rescue.perform
-    captive.position.should be_nil
+    expect(captive.position).to be_nil
   end
-  
+
   it "should do nothing to other unit if not bound" do
     unit = RubyWarrior::Units::Base.new
     unit.position = stub
@@ -23,9 +23,9 @@ describe RubyWarrior::Abilities::Rescue do
     @rescue.expects(:unit).with(:forward).never
     @warrior.expects(:earn_points).never
     @rescue.perform
-    unit.position.should_not be_nil
+    expect(unit.position).to_not be_nil
   end
-  
+
   it "should release other unit when bound" do
     unit = RubyWarrior::Units::Base.new
     unit.bind
@@ -34,7 +34,7 @@ describe RubyWarrior::Abilities::Rescue do
     @rescue.expects(:unit).with(:forward).returns(unit)
     @warrior.expects(:earn_points).never
     @rescue.perform
-    unit.should_not be_bound
-    unit.position.should_not be_nil
+    expect(unit).to_not be_bound
+    expect(unit.position).to_not be_nil
   end
 end

data/spec/ruby_warrior/abilities/rest_spec.rb

@@ -5,25 +5,25 @@ describe RubyWarrior::Abilities::Rest do
     @warrior = RubyWarrior::Units::Warrior.new
     @rest = RubyWarrior::Abilities::Rest.new(@warrior)
   end
-  
+
   it "should give 10% health back" do
     @warrior.stubs(:max_health).returns(20)
     @warrior.health = 10
     @rest.perform
-    @warrior.health.should == 12
+    expect(@warrior.health).to eq(12)
   end
-  
+
   it "should add health when at max" do
     @warrior.stubs(:max_health).returns(20)
     @warrior.health = 20
     @rest.perform
-    @warrior.health.should == 20
+    expect(@warrior.health).to eq(20)
   end
-  
+
   it "should not go over max health" do
     @warrior.stubs(:max_health).returns(20)
     @warrior.health = 19
     @rest.perform
-    @warrior.health.should == 20
+    expect(@warrior.health).to eq(20)
   end
 end

data/spec/ruby_warrior/abilities/shoot_spec.rb

@@ -5,7 +5,7 @@ describe RubyWarrior::Abilities::Shoot do
     @shooter = stub(:position => stub, :shoot_power => 2, :say => nil)
     @shoot = RubyWarrior::Abilities::Shoot.new(@shooter)
   end
-  
+
   it "should shoot only first unit" do
     receiver = stub(:alive? => true)
     receiver.expects(:take_damage).with(2)
@@ -14,9 +14,9 @@ describe RubyWarrior::Abilities::Shoot do
     @shoot.expects(:multi_unit).with(:forward, anything).returns([nil, receiver, other, nil])
     @shoot.perform
   end
-  
+
   it "should shoot and do nothing if no units in the way" do
     @shoot.expects(:multi_unit).with(:forward, anything).returns([nil, nil])
-    lambda { @shoot.perform }.should_not raise_error
+    expect { @shoot.perform }.to_not raise_error
   end
 end

data/spec/ruby_warrior/abilities/throw_spec.rb

@@ -9,7 +9,7 @@ describe RubyWarrior::Abilities::Detonate do
     @floor.add(@warrior, 0, 0, :south)
     @detonate = RubyWarrior::Abilities::Detonate.new(@warrior)
   end
-  
+
   it "should subtract 8 from forward unit and 4 from surrounding units" do
     target_unit = RubyWarrior::Units::Base.new
     target_unit.health = 15
@@ -18,10 +18,10 @@ describe RubyWarrior::Abilities::Detonate do
     @floor.add(target_unit, 0, 1)
     @floor.add(second_unit, 1, 1)
     @detonate.perform
-    target_unit.health.should == 7
-    second_unit.health.should == 11
+    expect(target_unit.health).to eq(7)
+    expect(second_unit.health).to eq(11)
   end
-  
+
   it "should subtract 8 from left unit and 4 from surrounding units" do
     target_unit = RubyWarrior::Units::Base.new
     target_unit.health = 15
@@ -30,17 +30,17 @@ describe RubyWarrior::Abilities::Detonate do
     @floor.add(target_unit, 1, 0)
     @floor.add(second_unit, 1, 1)
     @detonate.perform(:left)
-    target_unit.health.should == 7
-    second_unit.health.should == 11
+    expect(target_unit.health).to eq(7)
+    expect(second_unit.health).to eq(11)
   end
-  
+
   it "should detonate an explosive if any unit has one" do
     captive = RubyWarrior::Units::Captive.new
     captive.health = 1
     captive.add_abilities :explode!
     @floor.add(captive, 1, 1)
     @detonate.perform
-    captive.health.should == -99
-    @warrior.health.should == -80
+    expect(captive.health).to eq(-99)
+    expect(@warrior.health).to eq(-80)
   end
 end

data/spec/ruby_warrior/abilities/walk_spec.rb

@@ -6,20 +6,20 @@ describe RubyWarrior::Abilities::Walk do
     @position = stub(:relative_space => @space, :move => nil)
     @walk = RubyWarrior::Abilities::Walk.new(stub(:position => @position, :say => nil))
   end
-  
+
   it "should move position forward when calling perform" do
     @position.expects(:move).with(1, 0)
     @walk.perform
   end
-  
+
   it "should move position right if that is direction" do
     @position.expects(:move).with(0, 1)
     @walk.perform(:right)
   end
-  
+
   it "should keep position if something is in the way" do
     @position.stubs(:move).raises("shouldn't be called")
     @space.stubs(:empty?).returns(false)
-    lambda { @walk.perform(:right) }.should_not raise_error
+    expect { @walk.perform(:right) }.to_not raise_error
   end
 end

data/spec/ruby_warrior/core_additions_spec.rb

@@ -2,6 +2,6 @@ require 'spec_helper'
 
 describe String do
   it "should wrap text at white space when over a specific character length" do
-    "foo bar blah".hard_wrap(10).should == "foo bar\nblah"
+    expect("foo bar blah".hard_wrap(10)).to eq("foo bar\nblah")
   end
 end

data/spec/ruby_warrior/floor_spec.rb

@@ -7,75 +7,75 @@ describe RubyWarrior::Floor do
       @floor.width = 2
       @floor.height = 3
     end
-  
+
     it "should be able to add a unit and fetch it at that position" do
       unit = RubyWarrior::Units::Base.new
       @floor.add(unit, 0, 1, :north)
-      @floor.get(0, 1).should == unit
+      expect(@floor.get(0, 1)).to eq(unit)
     end
-  
+
     it "should not consider unit on floor if no position" do
       unit = RubyWarrior::Units::Base.new
       @floor.add(unit, 0, 1, :north)
       unit.position = nil
-      @floor.units.should_not include(unit)
+      expect(@floor.units).to_not include(unit)
     end
-  
+
     it "should fetch other units not warrior" do
       unit = RubyWarrior::Units::Base.new
       warrior = RubyWarrior::Units::Warrior.new
       @floor.add(unit, 0, 0, :north)
       @floor.add(warrior, 1, 0, :north)
-      @floor.other_units.should_not include(warrior)
-      @floor.other_units.should include(unit)
+      expect(@floor.other_units).to_not include(warrior)
+      expect(@floor.other_units).to include(unit)
     end
-  
+
     it "should not consider corners out of bounds" do
-      @floor.should_not be_out_of_bounds(0, 0)
-      @floor.should_not be_out_of_bounds(1, 0)
-      @floor.should_not be_out_of_bounds(1, 2)
-      @floor.should_not be_out_of_bounds(0, 2)
+      expect(@floor).to_not be_out_of_bounds(0, 0)
+      expect(@floor).to_not be_out_of_bounds(1, 0)
+      expect(@floor).to_not be_out_of_bounds(1, 2)
+      expect(@floor).to_not be_out_of_bounds(0, 2)
     end
-  
+
     it "should consider out of bounds when going beyond sides" do
-      @floor.should be_out_of_bounds(-1, 0)
-      @floor.should be_out_of_bounds(0, -1)
-      @floor.should be_out_of_bounds(0, 3)
-      @floor.should be_out_of_bounds(2, 0)
+      expect(@floor).to be_out_of_bounds(-1, 0)
+      expect(@floor).to be_out_of_bounds(0, -1)
+      expect(@floor).to be_out_of_bounds(0, 3)
+      expect(@floor).to be_out_of_bounds(2, 0)
     end
-  
+
     it "should return space at the specified location" do
-      @floor.space(0, 0).should be_kind_of(RubyWarrior::Space)
+      expect(@floor.space(0, 0)).to be_kind_of(RubyWarrior::Space)
     end
-  
+
     it "should place stairs and be able to fetch the location" do
       @floor.place_stairs(1, 2)
-      @floor.stairs_location.should == [1, 2]
+      expect(@floor.stairs_location).to eq([1, 2])
     end
   end
-  
+
   describe "3x1" do
     before(:each) do
       @floor = RubyWarrior::Floor.new
       @floor.width = 3
       @floor.height = 1
     end
-  
+
     it "should print map with stairs and unit" do
       @floor.add(RubyWarrior::Units::Warrior.new, 0, 0)
       @floor.place_stairs(2, 0)
-      @floor.character.should == <<-MAP
+      expect(@floor.character).to eq(<<-MAP)
  ---
 |@ >|
  ---
 MAP
     end
-    
+
     it "should return unique units" do
       u1 = RubyWarrior::Units::Base.new
       @floor.add(u1, 0, 0)
       @floor.add(RubyWarrior::Units::Base.new, 1, 0)
-      @floor.unique_units.should == [u1]
+      expect(@floor.unique_units).to eq([u1])
     end
   end
 end