gobstones 0.0.1.1

data/spec/parser/var_tuple_spec.rb

@@ -0,0 +1,30 @@
+describe Gobstones::Parser, "var tuples" do
+
+  it "should parse an empty var tuple" do
+    var_tuple = VarTuple.new []
+
+    expect('()').to be_parsed_as(:var_tuple).and_return(var_tuple)
+    expect('(   )').to be_parsed_as(:var_tuple).and_return(var_tuple)
+  end
+
+  it "should parse a var tuple with one arg" do
+    var = VarName.new 'myVar'
+    var_tuple = VarTuple.new [var]
+
+    expect('(myVar)').to be_parsed_as(:var_tuple).and_return(var_tuple)
+    expect('(  myVar )').to be_parsed_as(:var_tuple).and_return(var_tuple)
+  end
+
+  it "should parse a var tuple with many args" do
+    first = VarName.new 'firstVar'
+    second = VarName.new 'secondVar'
+    third = VarName.new 'thirdVar'
+    var_tuple = VarTuple.new [first, second, third]
+
+    expect('(firstVar, secondVar, thirdVar)').
+      to be_parsed_as(:var_tuple).and_return(var_tuple)
+    expect('( firstVar , secondVar,thirdVar )').
+      to be_parsed_as(:var_tuple).and_return(var_tuple)
+  end
+
+end

data/spec/parser/while_command_spec.rb

@@ -0,0 +1,30 @@
+describe Gobstones::Parser, "while statements" do
+
+  it "should parse a statement with a simple boolean and an empty block" do
+    while_cmd = WhileCmd.new True.new, CmdBlock.empty
+
+    expect('while (True) {}').to be_parsed_as(:command).and_return(while_cmd)
+    expect('while (True) {
+    }').to be_parsed_as(:command).and_return(while_cmd)
+    expect('while (True)
+      {}').to be_parsed_as(:command).and_return(while_cmd)
+  end
+
+  it "should parse a statement with a simple boolean and a block with commands" do
+    cmd_block = CmdBlock.new [Poner.new(Verde.new), Skip.new]
+    while_cmd = WhileCmd.new False.new, cmd_block
+
+    expect('while(False){Poner(Verde); Skip}').
+      to be_parsed_as(:command).and_return(while_cmd)
+  end
+
+  it "should parse a statement with a complex boolean expression" do
+    and_expr = And.new VarName.new('a'), False.new
+    exp = Or.new PuedeMover.new(Norte.new), ParenthesesExpr.new(and_expr)
+    while_cmd = WhileCmd.new exp, CmdBlock.empty
+
+    expect('while (puedeMover(Norte) || (a && False)) {}').
+      to be_parsed_as(:command).and_return(while_cmd)
+  end
+
+end

data/spec/runner/board_spec.rb

@@ -0,0 +1,85 @@
+describe Board do
+
+  let(:black)  { Negro.new }
+  let(:blue)   { Azul.new }
+  let(:green)  { Verde.new }
+  let(:red)    { Rojo.new }
+  let(:colors) { [blue, black, red, green] }
+
+  it "can be created with a number of rows and columns" do
+    board = Board.new 8, 5
+    expect(board.rows).to eq(8)
+    expect(board.columns).to eq(5)
+  end
+
+  it "should have cells in every position" do
+    board = Board.new 3, 3
+
+    board.each_cell { |cell| expect(cell).to be_a(Cell) }
+  end
+
+  it "should access cells in a x&y dimension" do
+    board = Board.new 3, 5
+
+    3.times do |x|
+      5.times do |y|
+        expect(board.cell_at(x, y)).to be
+      end
+    end
+  end
+
+  it "should raise errors if it is accessed out of the bounds" do
+    board = Board.new 9, 6
+
+    expect { board.cell_at(9, 4) }.to raise_error(OutOfBoardError)
+    expect { board.cell_at(3, 6) }.to raise_error(OutOfBoardError)
+    expect { board.cell_at(-1, 2) }.to raise_error(OutOfBoardError)
+    expect { board.cell_at(8, -1) }.to raise_error(OutOfBoardError)
+  end
+
+  it "should put balls in a given position" do
+    board = Board.new 5, 5
+
+    2.times { board.put 0, 0, blue }
+    10.times { board.put 2, 3, red }
+
+    expect(board.are_there_balls?(0, 0, blue)).to be_true
+    expect(board.number_of_balls(0, 0, blue)).to eq(2)
+    expect(board.are_there_balls?(2, 3, red)).to be_true
+    expect(board.number_of_balls(2, 3, red)).to eq(10)
+  end
+
+  it "should put and take out balls in a given position" do
+    board = Board.new 2, 2
+
+    3.times { board.put 1, 1, green }
+    3.times { board.take_out 1, 1, green }
+
+    expect(board.are_there_balls?(1, 1, green)).to be_false
+  end
+
+  it "should empty the entire board" do
+    board = Board.new 3, 4
+    board.each_cell { |cell| cell.put colors.sample }
+
+    board.empty!
+
+    board.each_cell do |cell|
+      colors.each do |color|
+        expect(cell.are_there_balls?(color)).to be_false
+      end
+    end
+  end
+
+  it "should be empty if there are no balls" do
+    board = Board.new 3, 4
+    expect(board.empty?).to be_true
+  end
+
+  it "should not be empty if there are balls" do
+    board = Board.new 3, 4
+    board.put 0, 0, black
+    expect(board.empty?).to be_false
+  end
+
+end

data/spec/runner/cell_spec.rb

@@ -0,0 +1,72 @@
+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(: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
+  end
+
+  it "should answer that there are balls of a given color when adding some" do
+    cell.put blue
+    cell.put red
+
+    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
+  end
+
+  it "should answer the number of balls of a given color" do
+    5.times { cell.put green }
+
+    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)
+  end
+
+  it "should allow to take out some balls" do
+    5.times { cell.put blue }
+    3.times { cell.take_out blue }
+
+    expect(cell.are_there_balls?(blue)).to be_true
+    expect(cell.number_of_balls(blue)).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)
+  end
+
+  it "should fail 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
+    colors.each { |color| cell.put color }
+
+    cell.empty!
+
+    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
+  end
+
+  it "should not be empty it it has some balls" do
+    colors.each { |color| cell.put color }
+    expect(cell.empty?).to be_false
+  end
+
+end

data/spec/runner/execution_context_spec.rb

@@ -0,0 +1,64 @@
+describe ExecutionContext do
+
+  let(:context) { ExecutionContext.new }
+
+  describe "variables context" do
+
+    let(:negro) { Negro.new }
+    let(:norte) { Norte.new }
+
+    it "should allow 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
+      context.set 'dir', norte
+      context.set 'bool', true.to_gbs_bool
+
+      expect(context.get('dir')).to eq(norte)
+      expect(context.get('bool')).to eq(true.to_gbs_bool)
+    end
+
+    it "should raise an error when getting 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
+      expect(context.program_context).to eq(context)
+    end
+
+    it "should have a head" do
+      expect(context.head).to be_a Head
+    end
+
+    it "should have a board" do
+      expect(context.board).to be_a Board
+    end
+
+  end
+
+  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
+
+      expect(procedure_context.program_context).to eq(program_context)
+    end
+
+  end
+
+end
+

data/spec/runner/head_spec.rb

@@ -0,0 +1,139 @@
+describe Head do
+
+  it "should have a position, default 0;0" do
+    head = Head.new
+
+    expect(head.x_pos).to eq(0)
+    expect(head.y_pos).to eq(0)
+  end
+
+  it "should answer 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
+    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 }
+  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
+        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
+        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
+        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
+        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
+        head.go_to_origin
+        expect(head.x_pos).to eq(0)
+        expect(head.y_pos).to eq(0)
+      end
+
+    end
+
+    context "non valid" do
+
+      it "should fail moving north" do
+        (Head::MAX_COLS-1).times { head.move north }
+
+        expect(head.can_move?(north)).to be_false
+        expect { head.move north }.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)
+      end
+
+      it "should fail moving east" do
+        (Head::MAX_ROWS-1).times { head.move east }
+
+        expect(head.can_move?(east)).to be_false
+        expect { head.move east }.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)
+      end
+
+      it "should fail if the argument is not a direction" do
+        expect { head.move Azul.new }.
+          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 }.
+          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
+
+    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)
+    end
+
+    it "should take out balls across the board" do
+      4.times { head.put black }
+      4.times { head.take_out black }
+
+      expect(head.are_there_balls?(black)).to be_false
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,15 @@
+require 'coveralls'
+Coveralls.wear!
+
+require 'simplecov'
+
+require 'matchers/parse_matcher'
+
+require 'gobstones/extensions/all'
+require 'gobstones/lang/all'
+require 'gobstones/runner/all'
+require 'gobstones/parser/treetop_parser'
+
+include Gobstones::Lang
+include Gobstones::Runner
+include Gobstones::Parser

data/spec/type_checker_spec.rb

@@ -0,0 +1,37 @@
+describe Gobstones, "type checker" do
+
+  describe "board expressions" do
+
+    describe "puedeMover()" do
+
+      it "should allow a direction as argument" do
+        [Norte.new, Sur.new, Este.new, Oeste.new].each do |dir|
+            puede_mover_dir = PuedeMover.new dir
+            result = puede_mover_dir.type_check
+            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)
+        result = puede_mover_number.type_check
+        expect(result.ok?).to be_false
+      end
+
+      it "should not allow a color as argument" do
+        puede_mover_color = PuedeMover.new Verde.new
+        result = puede_mover_color.type_check
+        expect(result.ok?).to be_false
+      end
+
+      it "should not allow a boolean as argument" do
+        puede_mover_bool = PuedeMover.new True.new
+        result = puede_mover_bool.type_check
+        expect(result.ok?).to be_false
+      end
+
+    end
+
+  end
+
+end