gobstones 0.0.1.1 → 0.0.2

data/spec/parser/procedure_calls_spec.rb

@@ -1,36 +1,36 @@
 describe Gobstones::Parser, "procedure calls" do
 
-  it "should parse a procedure call without args" do
+  it "parses a procedure call without args" do
     expect('P1()').to be_parsed_as(:command).and_return(ProcedureCall.new('P1'))
   end
 
-  it "should not parse a procedure call without a valid identifier" do
+  it "does not parse a procedure call without a valid identifier" do
     expect('p1()').to be_parsed_as(:command).and_fail
   end
 
-  it "should parse a procedure call with one arg" do
-    expected = ProcedureCall.new 'Proc1', [Verde.new]
+  it "parses a procedure call with one arg" do
+    expected = ProcedureCall.new 'Proc1', [verde]
     expect('Proc1(Verde)').to be_parsed_as(:command).and_return(expected)
   end
 
-  it "should parse a procedure with many args" do
+  it "parses a procedure with many args" do
     first_arg = 42.to_gbs_num
-    second_arg = NroBolitas.new Verde.new
-    third_arg = Norte.new
+    second_arg = NroBolitas.new verde
+    third_arg = norte
     expected = ProcedureCall.new 'Proc1', [first_arg, second_arg, third_arg]
 
     expect('Proc1(42, nroBolitas(Verde), Norte)').
       to be_parsed_as(:command).and_return(expected)
   end
 
-  it "should parse a complex procedure call" do
-    or_expr = Or.new VarName.new('a'), VarName.new('b')
-    paren_expr = ParenthesesExpr.new Div.new(10.to_gbs_num, VarName.new('c'))
+  it "parses a complex procedure call" do
+    or_expr = Or.new 'a'.to_var_name, 'b'.to_var_name
+    paren_expr = EnclosedByParensExpression.new Div.new(10.to_gbs_num, 'c'.to_var_name)
     num_expr = Mul.new 5.to_gbs_num, paren_expr
-    func_call = FunctionCall.new 'func', [Verde.new, Opuesto.new(Norte.new)]
+    func_call = FunctionCall.new 'func', [verde, Opuesto.new(norte)]
     proc_call = ProcedureCall.new 'Proc1', [or_expr, num_expr, func_call]
     expect('Proc1(a || b, 5*(10 div c), func(Verde, opuesto(Norte)))').
       to be_parsed_as(:command).and_return(proc_call)
   end
 
-end
+end

data/spec/parser/procedure_definitions_spec.rb

@@ -1,29 +1,23 @@
 describe Gobstones::Parser, "procedure definitions" do
 
-  let(:body) { CmdBlock.empty }
-
-  it "should parse an empty procedure def without args" do
-    args = VarTuple.new []
-    proc_def = Procedure.new 'MyProc', args, body
+  it "parses an empty procedure def without args" do
+    proc_def = Procedure.new 'MyProc', no_arguments, empty_body
 
     expect('procedure MyProc() {}').
       to be_parsed_as(:definition).and_return(proc_def)
   end
 
-  it "should parse an empty procedure with some args" do
-    first_arg = VarName.new 'firstArg'
-    second_arg = VarName.new 'secondArg'
-    third_arg = VarName.new 'thirdArg'
-    args = VarTuple.new [first_arg, second_arg, third_arg]
-    proc_def = Procedure.new 'MyProc', args, body
+  it "parses an empty procedure with some args" do
+    args = VarTuple.new ['firstArg'.to_var_name, 'secondArg'.to_var_name, 'thirdArg'.to_var_name]
+    proc_def = Procedure.new 'MyProc', args, empty_body
 
     expect('procedure MyProc (firstArg, secondArg, thirdArg) {}').
       to be_parsed_as(:definition).and_return(proc_def)
   end
 
-  it "should parse a procedure with some statements" do
-    args = VarTuple.new [VarName.new('arg')]
-    body = CmdBlock.new [Poner.new(Verde.new)]
+  it "parses a procedure with some statements" do
+    args = VarTuple.new ['arg'.to_var_name]
+    body = CommandBlock.new [Poner.new(verde)]
     proc_def = Procedure.new 'MyProc', args, body
 
     expect('procedure MyProc(arg)
@@ -32,8 +26,8 @@ describe Gobstones::Parser, "procedure definitions" do
 }').to be_parsed_as(:definition).and_return(proc_def)
   end
 
-  it "should not parse a procedure without a valid identifier" do
+  it "does not parse a procedure without a valid identifier" do
     expect('procedure myWrongProc() {}').to be_parsed_as(:definition).and_fail
   end
 
-end
+end

data/spec/parser/repeat_with_command_spec.rb

@@ -1,23 +1,20 @@
 describe Gobstones::Parser, "repeatWith statements" do
 
-  it "should parse an empty statement" do
-    var_name = VarName.new 'i'
+  it "parses an empty statement" do
     min_range, max_range = 1.to_gbs_num, 10.to_gbs_num
-    cmd_block = CmdBlock.empty
-    rw_cmd = RepeatWithCmd.new var_name, min_range, max_range, cmd_block
+    rw_cmd = RepeatWithCmd.new 'i'.to_var_name, min_range, max_range, empty_body
 
     expect('repeatWith i in 1..10 {}').to be_parsed_as(:command).and_return(rw_cmd)
   end
 
-  it "should parse an statement with any expressions in the range" do
-    var_name = VarName.new 'myDir'
-    min_range, max_range = MinDir.new, Siguiente.new(Rojo.new)
-    cmd_block = CmdBlock.new [Poner.new(Verde.new)]
-    rw_cmd = RepeatWithCmd.new var_name, min_range, max_range, cmd_block
+  it "parses an statement with any expressions in the range" do
+    min_range, max_range = MinDir.new, Siguiente.new(rojo)
+    cmd_block = CommandBlock.new [Poner.new(verde)]
+    rw_cmd = RepeatWithCmd.new 'myDir'.to_var_name, min_range, max_range, cmd_block
 
     expect('repeatWith myDir in minDir() .. siguiente(Rojo) {
       Poner(Verde)
     }').to be_parsed_as(:command).and_return(rw_cmd)
   end
 
-end
+end

data/spec/parser/simple_commands_spec.rb

@@ -5,12 +5,12 @@ describe Gobstones::Parser, "simple commands" do
 
   describe "primitives" do
 
-    it "should parse a Skip cmd" do
+    it "parses a Skip cmd" do
       skip_cmd = Skip.new
       expect('Skip').to be_parsed_as(:command).and_return(skip_cmd)
     end
 
-    it "should parse a BOOM cmd" do
+    it "parses a BOOM cmd" do
       boom_cmd = Boom.new 'the message'
       expect('BOOM("the message")').to be_parsed_as(:command).and_return(boom_cmd)
       expect('BOOM  ("the message")').to be_parsed_as(:command).and_return(boom_cmd)
@@ -21,21 +21,21 @@ describe Gobstones::Parser, "simple commands" do
 
       describe "#{command}() cmd" do
 
-        it "should be parsed ok with a primitive as argument" do
-          cmd = Kernel.const_get(command).new Verde.new
+        it "is parsed ok with a primitive as argument" do
+          cmd = Kernel.const_get(command).new verde
           expect("#{command}(Verde)").to be_parsed_as(:command).and_return(cmd)
           expect("#{command} (Verde)").to be_parsed_as(:command).and_return(cmd)
           expect("#{command}( Verde )").to be_parsed_as(:command).and_return(cmd)
         end
 
-        it "should be parsed ok with a simple expression as argument" do
+        it "is parsed ok with a simple expression as argument" do
           cmd = Kernel.const_get(command).new MinColor.new
           expect("#{command}(minColor())").
             to be_parsed_as(:command).and_return(cmd)
         end
 
-        it "should be parsed ok with a complex expression as argument" do
-          func_call = FunctionCall.new 'funcCall', [Norte.new, 42.to_gbs_num]
+        it "is parsed ok with a complex expression as argument" do
+          func_call = FunctionCall.new 'funcCall', [norte, 42.to_gbs_num]
           cmd = Kernel.const_get(command).new Opuesto.new(func_call)
           expect("#{command}(opuesto(funcCall(Norte, 42)))").
             to be_parsed_as(:command).and_return(cmd)
@@ -45,13 +45,13 @@ describe Gobstones::Parser, "simple commands" do
 
     end
 
-    it "should parse a IrAlOrigen cmd" do
+    it "parses a IrAlOrigen cmd" do
       ir_al_origen_cmd = IrAlOrigen.new
       expect('IrAlOrigen()').to be_parsed_as(:command).
         and_return(ir_al_origen_cmd)
     end
 
-    it "should parse a VaciarTablero cmd" do
+    it "parses a VaciarTablero cmd" do
       vaciar_tablero_cmd = VaciarTablero.new
       expect('VaciarTablero()').to be_parsed_as(:command).
         and_return(vaciar_tablero_cmd)
@@ -59,4 +59,4 @@ describe Gobstones::Parser, "simple commands" do
 
   end
 
-end
+end

data/spec/parser/treetop_parser_spec.rb

@@ -4,13 +4,13 @@ describe Gobstones::Parser do
 
   describe "removing comments of a gobstones piece of code" do
 
-    it "should remove a one-line comment with // characters for a single line" do
+    it "removes a one-line comment with // characters for a single line" do
       code_with_comments = 'Poner(Verde) // put a green ball on the board'
       code_without_comments = @parser.remove_comments_from code_with_comments
       expect(code_without_comments).to eq('Poner(Verde) ')
     end
 
-    it "should remove many one-line comments with //" do
+    it "removes many one-line comments with //" do
       code_with_comments = <<CODE
 Poner(Verde)  // put a green ball on the board
 Poner(Azul)   // and a blue one
@@ -24,13 +24,13 @@ Poner(Azul)
 CODE
     end
 
-    it "should remove a one-line comment with -- for a single line" do
+    it "removes a one-line comment with -- for a single line" do
       code_with_comments = 'Poner(Verde) -- put a green ball on the board'
       code_without_comments = @parser.remove_comments_from code_with_comments
       expect(code_without_comments).to eq('Poner(Verde) ')
     end
 
-    it "should remove many one-line comments with --" do
+    it "removes many one-line comments with --" do
       code_with_comments = <<CODE
 Poner(Verde)  -- put a green ball on the board
 Poner(Azul)   -- and a blue one
@@ -44,7 +44,7 @@ Poner(Azul)
 CODE
     end
 
-    it "should remove many one-line comments with // and --" do
+    it "removes many one-line comments with // and --" do
       code_with_comments = <<CODE
 Poner(Verde)  // put a green ball on the board
 Poner(Azul)   -- and a blue one
@@ -60,13 +60,14 @@ if (puedeMover(Norte)) { Mover(Norte) }
 CODE
     end
 
-    it "should remove a multiline comment with {- -}" do
+    it "removes a multiline comment with {- -}" do
       code_with_comments = 'Poner(Verde)  {- this is a comment -}'
       code_without_comments = @parser.remove_comments_from code_with_comments
       expect(code_without_comments).to eq('Poner(Verde)  ')
 
     end
-    it "should remove many multiline comments with {- -}, in same and different lines" do
+
+    it "removes many multiline comments with {- -}, in same and different lines" do
       code_with_comments = <<CODE
 Poner(Verde)  {- comment 1 -}
 Poner(Azul)   {- start comment 2
@@ -82,13 +83,13 @@ Poner(Rojo)
 CODE
     end
 
-    it "should remove a multiline comment with /* */" do
+    it "removes a multiline comment with /* */" do
       code_with_comments = 'Poner(Verde)  /* this is a comment */'
       code_without_comments = @parser.remove_comments_from code_with_comments
       expect(code_without_comments).to eq('Poner(Verde)  ')
 
     end
-    it "should remove many multiline comments with /* */, in same and different lines" do
+    it "removes many multiline comments with /* */, in same and different lines" do
       code_with_comments = <<CODE
 Poner(Verde)  /* comment 1 */
 Poner(Azul)   /* start comment 2
@@ -106,4 +107,4 @@ CODE
 
   end
 
-end
+end

data/spec/parser/var_tuple_spec.rb

@@ -1,25 +1,21 @@
 describe Gobstones::Parser, "var tuples" do
 
-  it "should parse an empty var tuple" do
-    var_tuple = VarTuple.new []
+  it "parses an empty var tuple" do
+    var_tuple = VarTuple.empty
 
     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]
+  it "parses a var tuple with one arg" do
+    var_tuple = VarTuple.new ['myVar'.to_var_name]
 
     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]
+  it "parses a var tuple with many args" do
+    var_tuple = VarTuple.new ['firstVar'.to_var_name, 'secondVar'.to_var_name, 'thirdVar'.to_var_name]
 
     expect('(firstVar, secondVar, thirdVar)').
       to be_parsed_as(:var_tuple).and_return(var_tuple)
@@ -27,4 +23,4 @@ describe Gobstones::Parser, "var tuples" do
       to be_parsed_as(:var_tuple).and_return(var_tuple)
   end
 
-end
+end

data/spec/parser/while_command_spec.rb

@@ -1,7 +1,7 @@
 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
+  it "parses a statement with a simple boolean and an empty block" do
+    while_cmd = WhileCmd.new true_value, empty_body
 
     expect('while (True) {}').to be_parsed_as(:command).and_return(while_cmd)
     expect('while (True) {
@@ -10,18 +10,18 @@ describe Gobstones::Parser, "while statements" do
       {}').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
+  it "parses a statement with a simple boolean and a block with commands" do
+    cmd_block = CommandBlock.new [Poner.new(verde), Skip.new]
+    while_cmd = WhileCmd.new false_value, 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
+  it "parses a statement with a complex boolean expression" do
+    and_expr = And.new 'a'.to_var_name, false_value
+    exp = Or.new PuedeMover.new(norte), EnclosedByParensExpression.new(and_expr)
+    while_cmd = WhileCmd.new exp, empty_body
 
     expect('while (puedeMover(Norte) || (a && False)) {}').
       to be_parsed_as(:command).and_return(while_cmd)

data/spec/runner/board_spec.rb

@@ -1,10 +1,6 @@
 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] }
+  let(:colors) { [azul, negro, rojo, verde] }
 
   it "can be created with a number of rows and columns" do
     board = Board.new 8, 5
@@ -12,13 +8,13 @@ describe Board do
     expect(board.columns).to eq(5)
   end
 
-  it "should have cells in every position" do
+  it "has 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
+  it "accesses cells in a x&y dimension" do
     board = Board.new 3, 5
 
     3.times do |x|
@@ -28,7 +24,7 @@ describe Board do
     end
   end
 
-  it "should raise errors if it is accessed out of the bounds" do
+  it "raises 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)
@@ -37,28 +33,28 @@ describe Board do
     expect { board.cell_at(8, -1) }.to raise_error(OutOfBoardError)
   end
 
-  it "should put balls in a given position" do
+  it "puts 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 }
+    2.times { board.put 0, 0, azul }
+    10.times { board.put 2, 3, rojo }
 
-    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)
+    expect(board.are_there_balls?(0, 0, azul)).to be true
+    expect(board.number_of_balls(0, 0, azul)).to eq(2)
+    expect(board.are_there_balls?(2, 3, rojo)).to be true
+    expect(board.number_of_balls(2, 3, rojo)).to eq(10)
   end
 
-  it "should put and take out balls in a given position" do
+  it "puts and takes 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 }
+    3.times { board.put 1, 1, verde }
+    3.times { board.take_out 1, 1, verde }
 
-    expect(board.are_there_balls?(1, 1, green)).to be_false
+    expect(board.are_there_balls?(1, 1, verde)).to be false
   end
 
-  it "should empty the entire board" do
+  it "clears the entire board" do
     board = Board.new 3, 4
     board.each_cell { |cell| cell.put colors.sample }
 
@@ -66,20 +62,20 @@ describe Board do
 
     board.each_cell do |cell|
       colors.each do |color|
-        expect(cell.are_there_balls?(color)).to be_false
+        expect(cell.are_there_balls?(color)).to be false
       end
     end
   end
 
-  it "should be empty if there are no balls" do
+  it "is empty if there are no balls" do
     board = Board.new 3, 4
-    expect(board.empty?).to be_true
+    expect(board.empty?).to be true
   end
 
-  it "should not be empty if there are balls" do
+  it "is not empty if there are balls" do
     board = Board.new 3, 4
-    board.put 0, 0, black
-    expect(board.empty?).to be_false
+    board.put 0, 0, negro
+    expect(board.empty?).to be false
   end
 
-end
+end