gobstones 0.0.2 → 0.0.3

data/spec/runner/cell_spec.rb

@@ -1,26 +1,19 @@
-describe Cell do
+RSpec.describe Cell do
+  subject(:cell) { described_class.new }
 
-  let(:colors) { [azul, negro, rojo, verde] }
-  let(:cell)   { Cell.new }
-
-  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
+  it 'answers that there are no balls of a given color' do
+    expect_no_balls(*colors, on: cell)
   end
 
-  it "answers that there are balls of a given color when adding some" do
+  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?(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
+    expect_balls(azul, rojo, on: cell)
+    expect_no_balls(verde, negro, on: cell)
   end
 
-  it "answers the number of balls of a given color" do
+  it 'answers the number of balls of a given color' do
     5.times { cell.put verde }
 
     expect(cell.number_of_balls(azul)).to eq(0)
@@ -29,11 +22,11 @@ describe Cell do
     expect(cell.number_of_balls(verde)).to eq(5)
   end
 
-  it "allows to take out some balls" do
+  it 'allows to take out some balls' do
     5.times { cell.put azul }
     3.times { cell.take_out azul }
 
-    expect(cell.are_there_balls?(azul)).to be true
+    expect(cell.are_there_balls?(azul)).to be(true)
     expect(cell.number_of_balls(azul)).to eq(2)
   end
 
@@ -41,28 +34,28 @@ describe Cell do
     expect { cell.take_out rojo }.to raise_error(EmptyCellError)
   end
 
-  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
+  it 'fails passing something that is not a color' do
+    expect { cell.put('not a color') }.to raise_error(/is not a color/)
+    expect { cell.take_out(42) }.to raise_error(/is not a color/)
+    expect { cell.are_there_balls?(Norte) }.to raise_error(/is not a color/)
+    expect { cell.number_of_balls(nil) }.to raise_error(/is not a color/)
   end
 
-  it "clears 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 }
+    expect_no_balls(*colors, on: cell)
   end
 
   it "is empty if it doesn't have any balls" do
-    expect(cell.empty?).to be true
+    expect(cell).to be_empty
   end
 
-  it "is not 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
-  end
 
+    expect(cell).not_to be_empty
+  end
 end

data/spec/runner/execution_context_spec.rb

@@ -1,16 +1,14 @@
-describe ExecutionContext do
-
+RSpec.describe ExecutionContext do
   let(:context) { clean_context }
 
-  describe "variables context" do
-
-    it "allows to set/get a variable" do
+  describe 'variables context' do
+    it 'allows to set/get a variable' do
       context.set 'myColor', negro
 
       expect(context.get('myColor')).to eq(negro)
     end
 
-    it "allows 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_value
 
@@ -18,61 +16,46 @@ describe ExecutionContext do
       expect(context.get('bool')).to eq(true_value)
     end
 
-    it "raises an error when trying to get an undefined variable" do
+    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
-
-    it "is the program context itself" do
+    it 'is the program context itself' do
       expect(context.program_context).to eq(context)
     end
-
-    it "has a head" do
-      expect(context.head).to be_a Head
-    end
-
-    it "has a board" do
-      expect(context.board).to be_a Board
-    end
-
   end
 
   describe ProcedureExecutionContext do
+    let(:procedure_context) { described_class.based_on(context) }
 
-    let(:procedure_context) { ProcedureExecutionContext.based_on context }
-
-    it "returns the program context in which it is based" do
+    it 'returns the program context in which it is based' do
       expect(procedure_context.program_context).to eq(context)
     end
 
-    it "shares the head with the outer context" do
+    it 'shares the head with the outer context' do
       expect(procedure_context.head).to eq(context.head)
     end
-
   end
 
   describe FunctionExecutionContext do
+    it 'returns the program context in which it is based' do
+      function_context = described_class.based_on(context)
 
-    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
+      context.head.put(azul)
+      function_context = described_class.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
+      expect_balls(azul)
+      expect_no_balls(verde)
+      expect_balls(azul, on: function_context.head)
+      expect_balls(verde, on: function_context.head)
     end
-
   end
-
 end

data/spec/runner/head_spec.rb

@@ -1,130 +1,124 @@
-describe Head do
+RSpec.describe Head do
+  subject(:head) { described_class.new }
 
-  let(:head)  { Head.new }
-
-  it "has a position, default 0;0" do
+  it 'has a position, default 0;0' do
     expect(head.x_pos).to eq(0)
     expect(head.y_pos).to eq(0)
   end
 
-  it "answers the max size" do
-    expect(Head::MAX_ROWS).to eq(9)
-    expect(Head::MAX_COLS).to eq(9)
+  it 'answers the max size' do
+    expect(described_class::MAX_ROWS).to eq(9)
+    expect(described_class::MAX_COLS).to eq(9)
   end
 
-  it "allows to be created at a random position" do
-    head = Head.at_random
+  it 'allows to be created at a random position' do
+    head = described_class.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 }
+    expect(head.x_pos.between?(0, described_class::MAX_ROWS - 1)).to be(true)
+    expect(head.y_pos.between?(0, described_class::MAX_COLS - 1)).to be(true)
   end
 
-  describe "movements" do
-
-    context "valid" do
-
-      it "moves north" do
-        expect(head.can_move?(norte)).to be true
-        expect { head.move(norte) }.to_not raise_error
+  describe 'movements' do
+    context 'valid' do
+      it 'moves north' do
+        expect(head.can_move?(norte)).to be(true)
+        expect { head.move(norte) }.not_to raise_error
         expect(head.x_pos).to eq(0)
         expect(head.y_pos).to eq(1)
       end
 
-      it "moves south" do
+      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.can_move?(sur)).to be(true)
+        expect { head.move(sur) }.not_to raise_error
         expect(head.x_pos).to eq(0)
         expect(head.y_pos).to eq(0)
       end
 
-      it "moves east" do
-        expect(head.can_move?(este)).to be true
-        expect { head.move(este) }.to_not raise_error
+      it 'moves east' do
+        expect(head.can_move?(este)).to be(true)
+        expect { head.move(este) }.not_to raise_error
         expect(head.x_pos).to eq(1)
         expect(head.y_pos).to eq(0)
       end
 
-      it "moves west" do
+      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.can_move?(oeste)).to be(true)
+        expect { head.move(oeste) }.not_to raise_error
         expect(head.x_pos).to eq(0)
         expect(head.y_pos).to eq(0)
       end
 
-      it "goes to the origin" do
+      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)
       end
-
     end
 
-    context "non valid" do
+    context 'non valid' do
+      it 'fails moving north' do
+        (Head::MAX_COLS - 1).times { head.move norte }
 
-      it "fails moving north" do
-        (Head::MAX_COLS-1).times { head.move norte }
-
-        expect(head.can_move?(norte)).to be false
+        expect(head.can_move?(norte)).to be(false)
         expect { head.move norte }.to raise_error(OutOfBoardError)
       end
 
-      it "fails moving south" do
-        expect(head.can_move?(sur)).to be false
+      it 'fails moving south' do
+        expect(head.can_move?(sur)).to be(false)
         expect { head.move sur }.to raise_error(OutOfBoardError)
       end
 
-      it "fails moving east" do
-        (Head::MAX_ROWS-1).times { head.move este }
+      it 'fails moving east' do
+        (described_class::MAX_ROWS - 1).times { head.move este }
 
-        expect(head.can_move?(este)).to be false
+        expect(head.can_move?(este)).to be(false)
         expect { head.move este }.to raise_error(OutOfBoardError)
       end
 
-      it "fails moving west" do
-        expect(head.can_move?(oeste)).to be false
+      it 'fails moving west' do
+        expect(head.can_move?(oeste)).to be(false)
         expect { head.move oeste }.to raise_error(OutOfBoardError)
       end
 
-      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_value }.
-          to raise_error(GobstonesTypeError, /is not a direction/)
-        expect { head.move 42 }.
-          to raise_error(GobstonesTypeError, /is not a direction/)
+      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_value }.to raise_error(GobstonesTypeError, /is not a direction/)
+        expect { head.move 42 }.to raise_error(GobstonesTypeError, /is not a direction/)
       end
-
     end
-
   end
 
-  describe "board actions" do
-
-    it "puts balls across the board" do
+  describe 'board actions' do
+    it 'puts balls across the board' do
       3.times { head.put negro }
-      expect(head.are_there_balls?(negro)).to be true
+
+      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 "takes out balls across the board" do
+    it 'takes out balls across the board' do
       4.times { head.put negro }
       4.times { head.take_out negro }
 
-      expect(head.are_there_balls?(negro)).to be false
+      expect(head.are_there_balls?(negro)).to be(false)
     end
-
   end
-
 end

data/spec/spec_helper.rb

@@ -2,6 +2,8 @@ require 'coveralls'
 Coveralls.wear!
 
 require 'simplecov'
+require 'test_prof'
+require 'test_prof/recipes/rspec/let_it_be'
 
 require 'matchers/parse_matcher'
 
@@ -11,8 +13,15 @@ require 'gobstones/runner/all'
 require 'gobstones/parser/treetop_parser'
 
 include Gobstones::Lang
+include Gobstones::Lang::Commands
 include Gobstones::Runner
 include Gobstones::Parser
 
-require 'gobstones_lang_test_objects'
+require 'support/gobstones_lang_test_objects'
 include GobstonesLangTestObjects
+require 'support/board_assertions'
+include BoardAssertions
+
+RSpec.configure(&:disable_monkey_patching!)
+
+TestProf::BeforeAll.adapter = OpenStruct.new(begin_transaction: nil, rollback_transaction: nil)

data/spec/support/board_assertions.rb

@@ -0,0 +1,18 @@
+module BoardAssertions
+  def expect_balls(*colors, on: context.head)
+    colors.each do |color|
+      expect(on.are_there_balls?(color)).to be(true)
+    end
+  end
+
+  def expect_no_balls(*colors, on: context.head)
+    colors.each do |color|
+      expect(on.are_there_balls?(color)).to be(false)
+    end
+  end
+
+  def expect_positioned_at(x_pos, y_pos)
+    expect(context.head.x_pos).to eq(x_pos)
+    expect(context.head.y_pos).to eq(y_pos)
+  end
+end

data/spec/{gobstones_lang_test_objects.rb → support/gobstones_lang_test_objects.rb}

@@ -1,17 +1,16 @@
 module GobstonesLangTestObjects
-
   # Programs, contexts and definitions
 
   def clean_context
-    program_context_for empty_program
+    program_context_for(empty_program)
   end
 
   def program_context_for(program)
-    ProgramExecutionContext.for program
+    ProgramExecutionContext.for(program)
   end
 
   def empty_program
-    Program.new no_definitions, no_return_statement
+    Program.new(no_definitions, no_return_statement)
   end
 
   def no_definitions
@@ -72,4 +71,7 @@ module GobstonesLangTestObjects
     Oeste.new
   end
 
+  def colors
+    [azul, negro, rojo, verde]
+  end
 end

data/spec/type_checker_spec.rb

@@ -1,37 +1,31 @@
-describe Gobstones, "type checker" do
+RSpec.describe Gobstones, 'type checker' do
+  describe 'board expressions' do
+    describe 'puedeMover()' do
+      it 'allows a direction as argument' do
+        [norte, sur, este, oeste].each do |dir|
+          result = PuedeMover.new(dir).type_check
 
-  describe "board expressions" do
+          expect(result.ok?).to be(true)
+        end
+      end
 
-    describe "puedeMover()" do
+      it 'does not allow a number as argument' do
+        result = PuedeMover.new(42.to_gbs_num).type_check
 
-      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
-          end
+        expect(result.ok?).to be(false)
       end
 
-      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
-      end
+      it 'does not allow a color as argument' do
+        result = PuedeMover.new(verde).type_check
 
-      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 "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
-      end
+      it 'does not allow a boolean as argument' do
+        result = PuedeMover.new(true_value).type_check
 
+        expect(result.ok?).to be(false)
+      end
     end
-
   end
-
 end