gobstones 0.0.1.1 → 0.0.2

data/spec/runner/cell_spec.rb

@@ -1,72 +1,68 @@
 describe Cell do
 
-  let(:black)  { Negro.new }
-  let(:blue)   { Azul.new }
-  let(:green)  { Verde.new }
-  let(:red)    { Rojo.new }
-  let(:colors) { [blue, black, red, green] }
+  let(:colors) { [azul, negro, rojo, verde] }
   let(:cell)   { Cell.new }
 
-  it "should answer that there are no balls of a given color" do
-    expect(cell.are_there_balls?(blue)).to be_false
-    expect(cell.are_there_balls?(black)).to be_false
-    expect(cell.are_there_balls?(red)).to be_false
-    expect(cell.are_there_balls?(green)).to be_false
+  it "answers that there are no balls of a given color" do
+    expect(cell.are_there_balls?(azul)).to be false
+    expect(cell.are_there_balls?(negro)).to be false
+    expect(cell.are_there_balls?(rojo)).to be false
+    expect(cell.are_there_balls?(verde)).to be false
   end
 
-  it "should answer that there are balls of a given color when adding some" do
-    cell.put blue
-    cell.put red
+  it "answers that there are balls of a given color when adding some" do
+    cell.put azul
+    cell.put rojo
 
-    expect(cell.are_there_balls?(blue)).to be_true
-    expect(cell.are_there_balls?(black)).to be_false
-    expect(cell.are_there_balls?(red)).to be_true
-    expect(cell.are_there_balls?(green)).to be_false
+    expect(cell.are_there_balls?(azul)).to be true
+    expect(cell.are_there_balls?(negro)).to be false
+    expect(cell.are_there_balls?(rojo)).to be true
+    expect(cell.are_there_balls?(verde)).to be false
   end
 
-  it "should answer the number of balls of a given color" do
-    5.times { cell.put green }
+  it "answers the number of balls of a given color" do
+    5.times { cell.put verde }
 
-    expect(cell.number_of_balls(blue)).to eq(0)
-    expect(cell.number_of_balls(black)).to eq(0)
-    expect(cell.number_of_balls(red)).to eq(0)
-    expect(cell.number_of_balls(green)).to eq(5)
+    expect(cell.number_of_balls(azul)).to eq(0)
+    expect(cell.number_of_balls(negro)).to eq(0)
+    expect(cell.number_of_balls(rojo)).to eq(0)
+    expect(cell.number_of_balls(verde)).to eq(5)
   end
 
-  it "should allow to take out some balls" do
-    5.times { cell.put blue }
-    3.times { cell.take_out blue }
+  it "allows to take out some balls" do
+    5.times { cell.put azul }
+    3.times { cell.take_out azul }
 
-    expect(cell.are_there_balls?(blue)).to be_true
-    expect(cell.number_of_balls(blue)).to eq(2)
+    expect(cell.are_there_balls?(azul)).to be true
+    expect(cell.number_of_balls(azul)).to eq(2)
   end
 
-  it "should raise an error if it's not possible to take out balls" do
-    expect { cell.take_out red }.to raise_error(EmptyCellError)
+  it "raises an error if it's not possible to take out balls" do
+    expect { cell.take_out rojo }.to raise_error(EmptyCellError)
   end
 
-  it "should fail passing something that is not a color" do
+  it "fails passing something that is not a color" do
     expect { cell.put("not a color") }.to raise_error
     expect { cell.take_out(42) }.to raise_error
     expect { cell.are_there_balls?(Norte) }.to raise_error
     expect { cell.number_of_balls(nil) }.to raise_error
   end
 
-  it "should empty its contents" do
+  it "clears its contents" do
     colors.each { |color| cell.put color }
 
     cell.empty!
 
-    colors.each { |color| expect(cell.are_there_balls?(color)).to be_false }
+    colors.each { |color| expect(cell.are_there_balls?(color)).to be false }
   end
 
-  it "should be empty if it doesn't have any balls" do
-    expect(cell.empty?).to be_true
+  it "is empty if it doesn't have any balls" do
+    expect(cell.empty?).to be true
   end
 
-  it "should not be empty it it has some balls" do
+  it "is not empty it it has some balls" do
     colors.each { |color| cell.put color }
-    expect(cell.empty?).to be_false
+    expect(cell.empty?).to be false
   end
 
-end
+end

data/spec/runner/execution_context_spec.rb

@@ -1,48 +1,40 @@
 describe ExecutionContext do
 
-  let(:context) { ExecutionContext.new }
+  let(:context) { clean_context }
 
   describe "variables context" do
 
-    let(:negro) { Negro.new }
-    let(:norte) { Norte.new }
-
-    it "should allow to set & get a variable" do
+    it "allows to set/get a variable" do
       context.set 'myColor', negro
 
       expect(context.get('myColor')).to eq(negro)
     end
 
-    it "should allow to set/get more than one variable" do
+    it "allows to set/get more than one variable" do
       context.set 'dir', norte
-      context.set 'bool', true.to_gbs_bool
+      context.set 'bool', true_value
 
       expect(context.get('dir')).to eq(norte)
-      expect(context.get('bool')).to eq(true.to_gbs_bool)
+      expect(context.get('bool')).to eq(true_value)
     end
 
-    it "should raise an error when getting an undefined variable" do
-      expect {
-        context.get('undefined')
-      }.to raise_error(UndefinedVariableError)
+    it "raises an error when trying to get an undefined variable" do
+      expect { context.get('undefined') }.to raise_error(UndefinedVariableError)
     end
 
   end
 
   describe ProgramExecutionContext do
 
-    let(:context) { ProgramExecutionContext.for program }
-    let(:program) { Program.new [], nil }
-
-    it "should return self as program_context" do
+    it "is the program context itself" do
       expect(context.program_context).to eq(context)
     end
 
-    it "should have a head" do
+    it "has a head" do
       expect(context.head).to be_a Head
     end
 
-    it "should have a board" do
+    it "has a board" do
       expect(context.board).to be_a Board
     end
 
@@ -50,15 +42,37 @@ describe ExecutionContext do
 
   describe ProcedureExecutionContext do
 
-    it "should return the program_context in which it is based" do
-      program = Program.new [], nil
-      program_context = ProgramExecutionContext.for program
-      procedure_context = ProcedureExecutionContext.based_on program_context
+    let(:procedure_context) { ProcedureExecutionContext.based_on context }
+
+    it "returns the program context in which it is based" do
+      expect(procedure_context.program_context).to eq(context)
+    end
 
-      expect(procedure_context.program_context).to eq(program_context)
+    it "shares the head with the outer context" do
+      expect(procedure_context.head).to eq(context.head)
     end
 
   end
 
-end
+  describe FunctionExecutionContext do
+
+    it "returns the program context in which it is based" do
+      function_context = FunctionExecutionContext.based_on context
+      expect(function_context.program_context).to eq(context)
+    end
 
+    it "has a new head, a copy of the outer context's head" do
+      context.head.put azul
+      function_context = FunctionExecutionContext.based_on context
+      function_context.head.put verde
+
+      expect(function_context.head).not_to eq(context.head)
+      expect(context.head.are_there_balls?(azul)).to be true
+      expect(function_context.head.are_there_balls?(azul)).to be true
+      expect(context.head.are_there_balls?(verde)).to be false
+      expect(function_context.head.are_there_balls?(verde)).to be true
+    end
+
+  end
+
+end

data/spec/runner/head_spec.rb

@@ -1,67 +1,61 @@
 describe Head do
 
-  it "should have a position, default 0;0" do
-    head = Head.new
+  let(:head)  { Head.new }
 
+  it "has a position, default 0;0" do
     expect(head.x_pos).to eq(0)
     expect(head.y_pos).to eq(0)
   end
 
-  it "should answer the max size" do
+  it "answers the max size" do
     expect(Head::MAX_ROWS).to eq(9)
     expect(Head::MAX_COLS).to eq(9)
   end
 
-  it "should allow to be created at a random position" do
+  it "allows to be created at a random position" do
     head = Head.at_random
 
-    100.times { expect(head.x_pos.between?(0, Head::MAX_ROWS-1)).to be_true }
-    100.times { expect(head.y_pos.between?(0, Head::MAX_COLS-1)).to be_true }
+    100.times { expect(head.x_pos.between?(0, Head::MAX_ROWS-1)).to be true }
+    100.times { expect(head.y_pos.between?(0, Head::MAX_COLS-1)).to be true }
   end
 
   describe "movements" do
 
-    let(:head)  { Head.new }
-    let(:north) { Norte.new }
-    let(:south) { Sur.new }
-    let(:east)  { Este.new }
-    let(:west)  { Oeste.new }
-
     context "valid" do
 
-      it "should move north" do
-        expect(head.can_move?(north)).to be_true
-        expect { head.move(north) }.to_not raise_error
+      it "moves north" do
+        expect(head.can_move?(norte)).to be true
+        expect { head.move(norte) }.to_not raise_error
         expect(head.x_pos).to eq(0)
         expect(head.y_pos).to eq(1)
       end
 
-      it "should move south" do
-        head.move north
-        expect(head.can_move?(south)).to be_true
-        expect { head.move(south) }.to_not raise_error
+      it "moves south" do
+        head.move norte
+        expect(head.can_move?(sur)).to be true
+        expect { head.move(sur) }.to_not raise_error
         expect(head.x_pos).to eq(0)
         expect(head.y_pos).to eq(0)
       end
 
-      it "should move east" do
-        expect(head.can_move?(east)).to be_true
-        expect { head.move(east) }.to_not raise_error
+      it "moves east" do
+        expect(head.can_move?(este)).to be true
+        expect { head.move(este) }.to_not raise_error
         expect(head.x_pos).to eq(1)
         expect(head.y_pos).to eq(0)
       end
 
-      it "should move west" do
-        head.move east
-        expect(head.can_move?(west)).to be_true
-        expect { head.move(west) }.to_not raise_error
+      it "moves west" do
+        head.move este
+        expect(head.can_move?(oeste)).to be true
+        expect { head.move(oeste) }.to_not raise_error
         expect(head.x_pos).to eq(0)
         expect(head.y_pos).to eq(0)
       end
 
-      it "should go to the origin" do
-        head.move east
-        head.move north
+      it "goes to the origin" do
+        head.move este
+        head.move norte
         head.go_to_origin
         expect(head.x_pos).to eq(0)
         expect(head.y_pos).to eq(0)
@@ -71,36 +65,36 @@ describe Head do
 
     context "non valid" do
 
-      it "should fail moving north" do
-        (Head::MAX_COLS-1).times { head.move north }
+      it "fails moving north" do
+        (Head::MAX_COLS-1).times { head.move norte }
 
-        expect(head.can_move?(north)).to be_false
-        expect { head.move north }.to raise_error(OutOfBoardError)
+        expect(head.can_move?(norte)).to be false
+        expect { head.move norte }.to raise_error(OutOfBoardError)
       end
 
-      it "should fail moving south" do
-        expect(head.can_move?(south)).to be_false
-        expect { head.move south }.to raise_error(OutOfBoardError)
+      it "fails moving south" do
+        expect(head.can_move?(sur)).to be false
+        expect { head.move sur }.to raise_error(OutOfBoardError)
       end
 
-      it "should fail moving east" do
-        (Head::MAX_ROWS-1).times { head.move east }
+      it "fails moving east" do
+        (Head::MAX_ROWS-1).times { head.move este }
 
-        expect(head.can_move?(east)).to be_false
-        expect { head.move east }.to raise_error(OutOfBoardError)
+        expect(head.can_move?(este)).to be false
+        expect { head.move este }.to raise_error(OutOfBoardError)
       end
 
-      it "should fail moving west" do
-        expect(head.can_move?(west)).to be_false
-        expect { head.move west }.to raise_error(OutOfBoardError)
+      it "fails moving west" do
+        expect(head.can_move?(oeste)).to be false
+        expect { head.move oeste }.to raise_error(OutOfBoardError)
       end
 
-      it "should fail if the argument is not a direction" do
-        expect { head.move Azul.new }.
+      it "fails if the argument is not a direction" do
+        expect { head.move azul }.
           to raise_error(GobstonesTypeError, /is not a direction/)
         expect { head.move "not a direction" }.
           to raise_error(GobstonesTypeError, /is not a direction/)
-        expect { head.move True.new }.
+        expect { head.move true_value }.
           to raise_error(GobstonesTypeError, /is not a direction/)
         expect { head.move 42 }.
           to raise_error(GobstonesTypeError, /is not a direction/)
@@ -112,26 +106,23 @@ describe Head do
 
   describe "board actions" do
 
-    let(:head) { Head.new }
-    let(:black) { Negro.new }
-
-    it "should put balls across the board" do
-      3.times { head.put black }
-      expect(head.are_there_balls?(black)).to be_true
-      expect(head.number_of_balls(black)).to eq(3)
-      head.move Norte.new
-      2.times { head.put black }
-      expect(head.number_of_balls(black)).to eq(2)
-      head.move Este.new
-      5.times { head.put black }
-      expect(head.number_of_balls(black)).to eq(5)
+    it "puts balls across the board" do
+      3.times { head.put negro }
+      expect(head.are_there_balls?(negro)).to be true
+      expect(head.number_of_balls(negro)).to eq(3)
+      head.move norte
+      2.times { head.put negro }
+      expect(head.number_of_balls(negro)).to eq(2)
+      head.move este
+      5.times { head.put negro }
+      expect(head.number_of_balls(negro)).to eq(5)
     end
 
-    it "should take out balls across the board" do
-      4.times { head.put black }
-      4.times { head.take_out black }
+    it "takes out balls across the board" do
+      4.times { head.put negro }
+      4.times { head.take_out negro }
 
-      expect(head.are_there_balls?(black)).to be_false
+      expect(head.are_there_balls?(negro)).to be false
     end
 
   end

data/spec/spec_helper.rb

@@ -12,4 +12,7 @@ require 'gobstones/parser/treetop_parser'
 
 include Gobstones::Lang
 include Gobstones::Runner
-include Gobstones::Parser
+include Gobstones::Parser
+
+require 'gobstones_lang_test_objects'
+include GobstonesLangTestObjects

data/spec/type_checker_spec.rb

@@ -4,34 +4,34 @@ describe Gobstones, "type checker" do
 
     describe "puedeMover()" do
 
-      it "should allow a direction as argument" do
-        [Norte.new, Sur.new, Este.new, Oeste.new].each do |dir|
+      it "allows a direction as argument" do
+        [norte, sur, este, oeste].each do |dir|
             puede_mover_dir = PuedeMover.new dir
             result = puede_mover_dir.type_check
-            expect(result.ok?).to be_true
+            expect(result.ok?).to be true
           end
       end
 
-      it "should not allow a number as argument" do
-        puede_mover_number = PuedeMover.new Number.new(42)
+      it "does not allow a number as argument" do
+        puede_mover_number = PuedeMover.new 42.to_gbs_num
         result = puede_mover_number.type_check
-        expect(result.ok?).to be_false
+        expect(result.ok?).to be false
       end
 
-      it "should not allow a color as argument" do
-        puede_mover_color = PuedeMover.new Verde.new
+      it "does not allow a color as argument" do
+        puede_mover_color = PuedeMover.new verde
         result = puede_mover_color.type_check
-        expect(result.ok?).to be_false
+        expect(result.ok?).to be false
       end
 
-      it "should not allow a boolean as argument" do
-        puede_mover_bool = PuedeMover.new True.new
+      it "does not allow a boolean as argument" do
+        puede_mover_bool = PuedeMover.new true_value
         result = puede_mover_bool.type_check
-        expect(result.ok?).to be_false
+        expect(result.ok?).to be false
       end
 
     end
 
   end
 
-end
+end