rubywarrior 0.1.2 → 0.2.0

data/spec/ruby_warrior/turn_spec.rb

@@ -1,31 +1,31 @@
-require File.dirname(__FILE__) + '/../spec_helper'
+require 'spec_helper'
 
 describe RubyWarrior::Turn do
   describe "with actions" 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

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

data/spec/ruby_warrior/units/archer_spec.rb

@@ -1,23 +1,23 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
+require 'spec_helper'
 
 describe RubyWarrior::Units::Archer do
   before(:each) do
     @archer = RubyWarrior::Units::Archer.new
   end
-  
+
   it "should have look and shoot abilities" do
-    @archer.abilities.keys.to_set.should == [:shoot!, :look].to_set
+    expect(@archer.abilities.keys.to_set).to eq([:shoot!, :look].to_set)
   end
-  
+
   it "should have shoot power of 3" do
-    @archer.shoot_power.should == 3
+    expect(@archer.shoot_power).to eq(3)
   end
-  
+
   it "should have 7 max health" do
-    @archer.max_health.should == 7
+    expect(@archer.max_health).to eq(7)
   end
-  
+
   it "should appear as a on map" do
-    @archer.character.should == "a"
+    expect(@archer.character).to eq("a")
   end
 end

data/spec/ruby_warrior/units/base_spec.rb

@@ -1,70 +1,70 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
+require 'spec_helper'
 
 describe RubyWarrior::Units::Base do
   before(:each) do
     @unit = RubyWarrior::Units::Base.new
   end
-  
+
   it "should have an attack power which defaults to zero" do
-    @unit.attack_power.should be_zero
+    expect(@unit.attack_power).to be_zero
   end
-  
+
   it "should consider itself dead when no position" do
-    @unit.position.should be_nil
-    @unit.should_not be_alive
+    expect(@unit.position).to be_nil
+    expect(@unit).to_not be_alive
   end
-  
+
   it "should consider itself alive with position" do
     @unit.position = stub
-    @unit.should be_alive
+    expect(@unit).to be_alive
   end
-  
+
   it "should default max health to 10" do
-    @unit.max_health.should be_zero
+    expect(@unit.max_health).to be_zero
   end
-  
+
   it "should do nothing when earning points" do
-    lambda { @unit.earn_points(10) }.should_not raise_error
+    expect { @unit.earn_points(10) }.to_not raise_error
   end
-  
+
   it "should default health to max health" do
     @unit.stubs(:max_health).returns(10)
-    @unit.health.should == 10
+    expect(@unit.health).to eq(10)
   end
-  
+
   it "should subtract health when taking damage" do
     @unit.stubs(:max_health).returns(10)
     @unit.take_damage(3)
-    @unit.health.should == 7
+    expect(@unit.health).to eq(7)
   end
-  
+
   it "should do nothing when taking damage if health isn't set" do
-    lambda { @unit.take_damage(3) }.should_not raise_error
+    expect { @unit.take_damage(3) }.to_not raise_error
   end
-  
+
   it "should set position to nil when running out of health" do
     @unit.position = stub
     @unit.stubs(:max_health).returns(10)
     @unit.take_damage(10)
-    @unit.position.should be_nil
+    expect(@unit.position).to be_nil
   end
-  
+
   it "should print out line with name when speaking" do
     RubyWarrior::UI.expects(:puts_with_delay).with("Base foo")
     @unit.say "foo"
   end
-  
+
   it "should return name in to_s" do
-    @unit.name.should == 'Base'
-    @unit.to_s.should == 'Base'
+    expect(@unit.name).to eq('Base')
+    expect(@unit.to_s).to eq('Base')
   end
-  
+
   it "should prepare turn by calling play_turn with next turn object" do
     @unit.stubs(:next_turn).returns('next_turn')
     @unit.expects(:play_turn).with('next_turn')
     @unit.prepare_turn
   end
-  
+
   it "should perform action when calling perform on turn" do
     @unit.position = stub
     RubyWarrior::Abilities::Walk.any_instance.expects(:perform).with(:backward)
@@ -74,7 +74,7 @@ describe RubyWarrior::Units::Base do
     @unit.prepare_turn
     @unit.perform_turn
   end
-  
+
   it "should not perform action when dead (no position)" do
     @unit.position = nil
     RubyWarrior::Abilities::Walk.any_instance.stubs(:perform).raises("action should not be called")
@@ -84,42 +84,42 @@ describe RubyWarrior::Units::Base do
     @unit.prepare_turn
     @unit.perform_turn
   end
-  
+
   it "should not raise an exception when calling perform_turn when there's no action" do
     @unit.prepare_turn
-    lambda { @unit.perform_turn }.should_not raise_error
+    expect { @unit.perform_turn }.to_not raise_error
   end
-  
+
   it "should pass abilities to new turn when calling next_turn" do
-    RubyWarrior::Turn.expects(:new).with(:walk! => nil, :attack! => nil, :feel => nil).returns('turn')
+    RubyWarrior::Turn.expects(:new).with({:walk! => nil, :attack! => nil, :feel => nil}).returns('turn')
     @unit.stubs(:abilities).returns(:walk! => nil, :attack! => nil, :feel => nil)
-    @unit.next_turn.should == 'turn'
+    expect(@unit.next_turn).to eq('turn')
   end
-  
+
   it "should add ability" do
     RubyWarrior::Abilities::Walk.expects(:new).with(@unit).returns('walk')
     @unit.add_abilities(:walk!)
-    @unit.abilities.should == { :walk! => 'walk' }
+    expect(@unit.abilities).to eq({ :walk! => 'walk' })
   end
-  
+
   it "should appear as question mark on map" do
-    @unit.character.should == "?"
+    expect(@unit.character).to eq("?")
   end
-  
+
   it "should be released from bonds when taking damage" do
     @unit.stubs(:max_health).returns(10)
     @unit.bind
-    @unit.should be_bound
+    expect(@unit).to be_bound
     @unit.take_damage(2)
-    @unit.should_not be_bound
+    expect(@unit).to_not be_bound
   end
-  
+
   it "should be released from bonds when calling release" do
     @unit.bind
     @unit.unbind
-    @unit.should_not be_bound
+    expect(@unit).to_not be_bound
   end
-  
+
   it "should not perform action when bound" do
     @unit.position = stub
     @unit.bind

data/spec/ruby_warrior/units/captive_spec.rb

@@ -1,23 +1,23 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
+require 'spec_helper'
 
 describe RubyWarrior::Units::Captive do
   before(:each) do
     @captive = RubyWarrior::Units::Captive.new
   end
-  
+
   it "should have 1 max health" do
-    @captive.max_health.should == 1
+    expect(@captive.max_health).to eq(1)
   end
-  
+
   it "should appear as C on map" do
-    @captive.character.should == "C"
+    expect(@captive.character).to eq("C")
   end
-  
+
   it "should be bound by default" do
-    @captive.should be_bound
+    expect(@captive).to be_bound
   end
-  
+
   it "should not have explode ability by default (this should be added when needed)" do
-    @captive.abilities.should_not include(:explode!)
+    expect(@captive.abilities).to_not include(:explode!)
   end
 end

data/spec/ruby_warrior/units/golem_spec.rb

@@ -1,28 +1,28 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
+require 'spec_helper'
 
 describe RubyWarrior::Units::Golem do
   before(:each) do
     @golem = RubyWarrior::Units::Golem.new
   end
-  
+
   it "should execute turn proc when playing turn" do
     proc = Object.new
     proc.expects(:call).with(:turn)
     @golem.turn = proc
     @golem.play_turn(:turn)
   end
-  
+
   it "should set max health and update current health" do
     @golem.max_health = 10
-    @golem.max_health.should == 10
-    @golem.health.should == 10
+    expect(@golem.max_health).to eq(10)
+    expect(@golem.health).to eq(10)
   end
-  
+
   it "should have attack power of 3" do
-    @golem.attack_power.should == 3
+    expect(@golem.attack_power).to eq(3)
   end
-  
+
   it "should appear as G on map" do
-    @golem.character.should == "G"
+    expect(@golem.character).to eq("G")
   end
 end

data/spec/ruby_warrior/units/sludge_spec.rb

@@ -1,27 +1,27 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
+require 'spec_helper'
 
 describe RubyWarrior::Units::Sludge do
   before(:each) do
     @sludge = RubyWarrior::Units::Sludge.new
   end
-  
+
   it "should have attack action" do
-    @sludge.abilities.keys.should include(:attack!)
+    expect(@sludge.abilities.keys).to include(:attack!)
   end
-  
+
   it "should have feel sense" do
-    @sludge.abilities.keys.should include(:feel)
+    expect(@sludge.abilities.keys).to include(:feel)
   end
-  
+
   it "should have attack power of 3" do
-    @sludge.attack_power.should == 3
+    expect(@sludge.attack_power).to eq(3)
   end
-  
+
   it "should have 12 max health" do
-    @sludge.max_health.should == 12
+    expect(@sludge.max_health).to eq(12)
   end
-  
+
   it "should appear as s on map" do
-    @sludge.character.should == "s"
+    expect(@sludge.character).to eq("s")
   end
 end

data/spec/ruby_warrior/units/thick_sludge_spec.rb

@@ -1,19 +1,19 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
+require 'spec_helper'
 
 describe RubyWarrior::Units::ThickSludge do
   before(:each) do
     @sludge = RubyWarrior::Units::ThickSludge.new
   end
-  
+
   it "should have 24 max health" do
-    @sludge.max_health.should == 24
+    expect(@sludge.max_health).to eq(24)
   end
-  
+
   it "should appear as S on map" do
-    @sludge.character.should == "S"
+    expect(@sludge.character).to eq("S")
   end
-  
+
   it "should have the name of 'Thick Sludge'" do
-    @sludge.name.should == "Thick Sludge"
+    expect(@sludge.name).to eq("Thick Sludge")
   end
 end

data/spec/ruby_warrior/units/warrior_spec.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
+require 'spec_helper'
 
 class Player
   def turn(warrior)
@@ -9,57 +9,57 @@ describe RubyWarrior::Units::Warrior do
   before(:each) do
     @warrior = RubyWarrior::Units::Warrior.new
   end
-  
+
   it "should default name to warrior" do
-    @warrior.name.should == "Warrior"
+    expect(@warrior.name).to eq("Warrior")
     @warrior.name = ''
-    @warrior.name.should == "Warrior"
+    expect(@warrior.name).to eq("Warrior")
   end
-  
+
   it "should be able to set name" do
     @warrior.name = "Joe"
-    @warrior.name.should == "Joe"
-    @warrior.to_s.should == "Joe"
+    expect(@warrior.name).to eq("Joe")
+    expect(@warrior.to_s).to eq("Joe")
   end
-  
+
   it "should have 20 max health" do
-    @warrior.max_health.should == 20
+    expect(@warrior.max_health).to eq(20)
   end
-  
+
   it "should have 0 score at beginning and be able to earn points" do
-    @warrior.score.should be_zero
+    expect(@warrior.score).to be_zero
     @warrior.earn_points(5)
-    @warrior.score.should == 5
+    expect(@warrior.score).to eq(5)
   end
-  
+
   it "should call player.play_turn and pass turn to player" do
     player = stub
     player.expects(:play_turn).with('turn')
     @warrior.stubs(:player).returns(player)
     @warrior.play_turn('turn')
   end
-  
+
   it "should call Player.new the first time loading player, and return same object next time" do
     Player.expects(:new).returns('player').times(1)
     2.times do
-      @warrior.player.should == 'player'
+      expect(@warrior.player).to eq('player')
     end
   end
-  
+
   it "should have an attack power of 5" do
-    @warrior.attack_power.should == 5
+    expect(@warrior.attack_power).to eq(5)
   end
-  
+
   it "should have an shoot power of 3" do
-    @warrior.shoot_power.should == 3
+    expect(@warrior.shoot_power).to eq(3)
   end
-  
+
   it "should appear as @ on map" do
-    @warrior.character.should == "@"
+    expect(@warrior.character).to eq("@")
   end
-  
+
   it "should be able to add golem abilities which are used on base golem" do
     @warrior.add_golem_abilities :walk!
-    @warrior.base_golem.abilities.keys.should == [:walk!]
+    expect(@warrior.base_golem.abilities.keys).to eq([:walk!])
   end
 end

data/spec/ruby_warrior/units/wizard_spec.rb

@@ -1,23 +1,23 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
+require 'spec_helper'
 
 describe RubyWarrior::Units::Wizard do
   before(:each) do
     @wizard = RubyWarrior::Units::Wizard.new
   end
-  
+
   it "should have look and shoot abilities" do
-    @wizard.abilities.keys.to_set.should == [:shoot!, :look].to_set
+    expect(@wizard.abilities.keys.to_set).to eq([:shoot!, :look].to_set)
   end
-  
+
   it "should have shoot power of 11" do
-    @wizard.shoot_power.should == 11
+    expect(@wizard.shoot_power).to eq(11)
   end
-  
+
   it "should have 3 max health" do
-    @wizard.max_health.should == 3
+    expect(@wizard.max_health).to eq(3)
   end
-  
+
   it "should appear as w on map" do
-    @wizard.character.should == "w"
+    expect(@wizard.character).to eq("w")
   end
 end

data/spec/spec_helper.rb

@@ -1,10 +1,11 @@
 require 'rubygems'
-require 'spec'
+require 'rspec'
 require File.dirname(__FILE__) + '/../lib/ruby_warrior'
 
-Spec::Runner.configure do |config|
+RSpec.configure do |config|
   config.mock_with :mocha
   config.before(:each) do
     RubyWarrior::Config.reset
   end
+  config.raise_errors_for_deprecations!
 end

data/towers/beginner/level_002.rb

@@ -3,7 +3,7 @@
 #  --------
 
 description "It is too dark to see anything, but you smell sludge nearby."
-tip "Use warrior.feel.empty? to see if there's anything in front of you, and warrior.attack! to fight it. Remember, you can only do one action (ending in !) per turn."
+tip "Use warrior.feel.empty? to see if there is anything in front of you, and warrior.attack! to fight it. Remember, you can only do one action (ending in !) per turn."
 clue "Add an if/else condition using warrior.feel.empty? to decide whether to warrior.attack! or warrior.walk!."
 
 time_bonus 20

data/towers/beginner/level_003.rb

@@ -4,7 +4,7 @@
 
 description "The air feels thicker than before. There must be a horde of sludge."
 tip "Be careful not to die! Use warrior.health to keep an eye on your health, and warrior.rest! to earn 10% of max health back."
-clue "When there's no enemy ahead of you, call warrior.rest! until health is full before walking forward."
+clue "When there is no enemy ahead of you call warrior.rest! until health is full before walking forward."
 
 time_bonus 35
 ace_score 71