gobstones 0.0.2 → 0.0.3

data/spec/parser/procedure_definitions_spec.rb

@@ -1,24 +1,22 @@
-describe Gobstones::Parser, "procedure definitions" do
+RSpec.describe Gobstones::Parser, 'procedure definitions' do
+  it 'parses an empty procedure def without args' do
+    proc_def = Procedure.new('MyProc', no_arguments, empty_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)
+    expect('procedure MyProc() {}').to be_parsed_as(:definition).and_return(proc_def)
   end
 
-  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
+  it 'parses an empty procedure with some args' do
+    args = VarTuple.with_names(%w[firstArg secondArg thirdArg])
+    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 "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
+  it 'parses a procedure with some statements' do
+    args = VarTuple.with_names(%w[arg])
+    body = CommandBlock.with_just(Poner.new(verde))
+    proc_def = Procedure.new('MyProc', args, body)
 
     expect('procedure MyProc(arg)
 {
@@ -26,8 +24,7 @@ describe Gobstones::Parser, "procedure definitions" do
 }').to be_parsed_as(:definition).and_return(proc_def)
   end
 
-  it "does 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

data/spec/parser/repeat_with_command_spec.rb

@@ -1,20 +1,20 @@
-describe Gobstones::Parser, "repeatWith statements" do
-
-  it "parses an empty statement" do
-    min_range, max_range = 1.to_gbs_num, 10.to_gbs_num
-    rw_cmd = RepeatWithCmd.new 'i'.to_var_name, min_range, max_range, empty_body
+RSpec.describe Gobstones::Parser, 'repeatWith statements' do
+  it 'parses an empty statement' do
+    min_range = 1.to_gbs_num
+    max_range = 10.to_gbs_num
+    rw_cmd = RepeatWith.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 "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
+  it 'parses an statement with any expressions in the range' do
+    min_range = MinDir.new
+    max_range = Siguiente.new(rojo)
+    cmd_block = CommandBlock.with_just(Poner.new(verde))
+    rw_cmd = RepeatWith.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

data/spec/parser/simple_commands_spec.rb

@@ -1,62 +1,48 @@
-require 'gobstones/lang/commands/ir_al_origen_cmd'
-require 'gobstones/lang/commands/vaciar_tablero_cmd'
-
-describe Gobstones::Parser, "simple commands" do
-
-  describe "primitives" do
-
-    it "parses a Skip cmd" do
-      skip_cmd = Skip.new
-      expect('Skip').to be_parsed_as(:command).and_return(skip_cmd)
+RSpec.describe Gobstones::Parser, 'simple commands' do
+  describe 'primitives' do
+    it 'parses a Skip cmd' do
+      expect('Skip').to be_parsed_as(:command).and_return(Skip.new)
     end
 
-    it "parses a BOOM cmd" do
-      boom_cmd = Boom.new 'the message'
+    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)
       expect('BOOM( "the message" )').to be_parsed_as(:command).and_return(boom_cmd)
     end
 
-    ['Poner', 'Sacar', 'Mover'].each do |command|
-
+    %w[Poner Sacar Mover].each do |command|
       describe "#{command}() cmd" do
+        it 'is parsed ok with a primitive as argument' do
+          cmd = Kernel.const_get(command).new(verde)
 
-        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 "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 'is parsed ok with a simple expression as argument' do
+          cmd = Kernel.const_get(command).new(MinColor.new)
 
-        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)
+          expect("#{command}(minColor())").to be_parsed_as(:command).and_return(cmd)
         end
 
-      end
+        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)
+        end
+      end
     end
 
-    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)
+    it 'parses a IrAlOrigen cmd' do
+      expect('IrAlOrigen()').to be_parsed_as(:command).and_return(IrAlOrigen.new)
     end
 
-    it "parses a VaciarTablero cmd" do
-      vaciar_tablero_cmd = VaciarTablero.new
-      expect('VaciarTablero()').to be_parsed_as(:command).
-        and_return(vaciar_tablero_cmd)
+    it 'parses a VaciarTablero cmd' do
+      expect('VaciarTablero()').to be_parsed_as(:command).and_return(VaciarTablero.new)
     end
-
   end
-
 end

data/spec/parser/treetop_parser_spec.rb

@@ -1,110 +1,114 @@
-describe Gobstones::Parser do
+RSpec.describe Gobstones::Parser do
+  let_it_be(:parser) { TreetopParser.new }
 
-  before(:all) { @parser = TreetopParser.new }
-
-  describe "removing comments of a gobstones piece of code" do
-
-    it "removes a one-line comment with // characters for a single line" do
+  describe 'removing comments of a gobstones piece of code' 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
+      code_without_comments = parser.remove_comments_from(code_with_comments)
+
       expect(code_without_comments).to eq('Poner(Verde) ')
     end
 
-    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
-// and this is just an entire comment line
-CODE
-      code_without_comments = @parser.remove_comments_from code_with_comments
-      expect(code_without_comments).to eq <<CODE
-Poner(Verde)  
-Poner(Azul)   
-
-CODE
+    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
+        // and this is just an entire comment line
+      CODE
+      code_without_comments = parser.remove_comments_from(code_with_comments)
+
+      expect(code_without_comments).to eq <<~CODE
+        Poner(Verde)  
+        Poner(Azul)   
+        
+      CODE
     end
 
-    it "removes 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
+      code_without_comments = parser.remove_comments_from(code_with_comments)
+
       expect(code_without_comments).to eq('Poner(Verde) ')
     end
 
-    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
--- and this is just an entire comment line
-CODE
-      code_without_comments = @parser.remove_comments_from code_with_comments
-      expect(code_without_comments).to eq <<CODE
-Poner(Verde)  
-Poner(Azul)   
-
-CODE
+    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
+        -- and this is just an entire comment line
+      CODE
+      code_without_comments = parser.remove_comments_from(code_with_comments)
+
+      expect(code_without_comments).to eq <<~CODE
+        Poner(Verde)  
+        Poner(Azul)   
+        
+      CODE
     end
 
-    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
-// and this is just an entire comment line
-if (puedeMover(Norte)) { Mover(Norte) } -- another -- comment
-CODE
-      code_without_comments = @parser.remove_comments_from code_with_comments
-      expect(code_without_comments).to eq <<CODE
-Poner(Verde)  
-Poner(Azul)   
-
-if (puedeMover(Norte)) { Mover(Norte) } 
-CODE
+    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
+        // and this is just an entire comment line
+        if (puedeMover(Norte)) { Mover(Norte) } -- another -- comment
+      CODE
+      code_without_comments = parser.remove_comments_from(code_with_comments)
+
+      expect(code_without_comments).to eq <<~CODE
+        Poner(Verde)  
+        Poner(Azul)   
+        
+        if (puedeMover(Norte)) { Mover(Norte) } 
+      CODE
     end
 
-    it "removes 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)  ')
+      code_without_comments = parser.remove_comments_from(code_with_comments)
 
+      expect(code_without_comments).to eq('Poner(Verde)  ')
     end
 
-    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
-// and this is just an entire comment line
-if (puedeMover(Norte)) { Mover(Norte) -}
-Poner(Rojo)
-CODE
-      code_without_comments = @parser.remove_comments_from code_with_comments
-      expect(code_without_comments).to eq <<CODE
-Poner(Verde)  
-Poner(Azul)   
-Poner(Rojo)
-CODE
+    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
+        // and this is just an entire comment line
+        if (puedeMover(Norte)) { Mover(Norte) -}
+        Poner(Rojo)
+      CODE
+      code_without_comments = parser.remove_comments_from(code_with_comments)
+
+      expect(code_without_comments).to eq <<~CODE
+        Poner(Verde)  
+        Poner(Azul)   
+        Poner(Rojo)
+      CODE
     end
 
-    it "removes 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)  ')
+      code_without_comments = parser.remove_comments_from(code_with_comments)
 
-    end
-    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
-// and this is just an entire comment line
-if (puedeMover(Norte)) { Mover(Norte) */
-Poner(Rojo)
-CODE
-      code_without_comments = @parser.remove_comments_from code_with_comments
-      expect(code_without_comments).to eq <<CODE
-Poner(Verde)  
-Poner(Azul)   
-Poner(Rojo)
-CODE
+      expect(code_without_comments).to eq('Poner(Verde)  ')
     end
 
+    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
+        // and this is just an entire comment line
+        if (puedeMover(Norte)) { Mover(Norte) */
+        Poner(Rojo)
+      CODE
+      code_without_comments = parser.remove_comments_from(code_with_comments)
+
+      expect(code_without_comments).to eq <<~CODE
+        Poner(Verde)  
+        Poner(Azul)   
+        Poner(Rojo)
+      CODE
+    end
   end
-
 end

data/spec/parser/var_tuple_spec.rb

@@ -1,26 +1,22 @@
-describe Gobstones::Parser, "var tuples" do
-
-  it "parses an empty var tuple" do
+RSpec.describe Gobstones::Parser, 'var tuples' do
+  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 "parses a var tuple with one arg" do
-    var_tuple = VarTuple.new ['myVar'.to_var_name]
+  it 'parses a var tuple with one arg' do
+    var_tuple = VarTuple.with_names(%w[myVar])
 
     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 "parses a var tuple with many args" do
-    var_tuple = VarTuple.new ['firstVar'.to_var_name, 'secondVar'.to_var_name, 'thirdVar'.to_var_name]
+  it 'parses a var tuple with many args' do
+    var_tuple = VarTuple.with_names(%w[firstVar secondVar thirdVar])
 
-    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)
+    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

@@ -1,7 +1,6 @@
-describe Gobstones::Parser, "while statements" do
-
-  it "parses a statement with a simple boolean and an empty block" do
-    while_cmd = WhileCmd.new true_value, empty_body
+RSpec.describe Gobstones::Parser, 'while statements' do
+  it 'parses a statement with a simple boolean and an empty block' do
+    while_cmd = While.new(true_value, empty_body)
 
     expect('while (True) {}').to be_parsed_as(:command).and_return(while_cmd)
     expect('while (True) {
@@ -10,21 +9,19 @@ describe Gobstones::Parser, "while statements" do
       {}').to be_parsed_as(:command).and_return(while_cmd)
   end
 
-  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
+  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 = While.new(false_value, cmd_block)
 
-    expect('while(False){Poner(Verde); Skip}').
-      to be_parsed_as(:command).and_return(while_cmd)
+    expect('while(False){Poner(Verde); Skip}').to be_parsed_as(:command).and_return(while_cmd)
   end
 
-  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
+  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 = While.new(exp, empty_body)
 
     expect('while (puedeMover(Norte) || (a && False)) {}').
       to be_parsed_as(:command).and_return(while_cmd)
   end
-
 end

data/spec/runner/board_spec.rb

@@ -1,31 +1,29 @@
-describe Board do
+RSpec.describe Board do
+  it 'can be created with a number of rows and columns' do
+    board = described_class.new(8, 5)
 
-  let(:colors) { [azul, negro, rojo, verde] }
-
-  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 "has cells in every position" do
-    board = Board.new 3, 3
+  it 'has cells in every position' do
+    board = described_class.new(3, 3)
 
     board.each_cell { |cell| expect(cell).to be_a(Cell) }
   end
 
-  it "accesses cells in a x&y dimension" do
-    board = Board.new 3, 5
+  it 'accesses cells in a x&y dimension' do
+    board = described_class.new(3, 5)
 
     3.times do |x|
       5.times do |y|
-        expect(board.cell_at(x, y)).to be
+        expect(board.cell_at(x, y)).not_to be_nil
       end
     end
   end
 
-  it "raises errors if it is accessed out of the bounds" do
-    board = Board.new 9, 6
+  it 'raises errors if it is accessed out of the bounds' do
+    board = described_class.new(9, 6)
 
     expect { board.cell_at(9, 4) }.to raise_error(OutOfBoardError)
     expect { board.cell_at(3, 6) }.to raise_error(OutOfBoardError)
@@ -33,49 +31,46 @@ describe Board do
     expect { board.cell_at(8, -1) }.to raise_error(OutOfBoardError)
   end
 
-  it "puts balls in a given position" do
-    board = Board.new 5, 5
+  it 'puts balls in a given position' do
+    board = described_class.new(5, 5)
 
     2.times { board.put 0, 0, azul }
     10.times { board.put 2, 3, rojo }
 
-    expect(board.are_there_balls?(0, 0, azul)).to be true
+    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.are_there_balls?(2, 3, rojo)).to be(true)
     expect(board.number_of_balls(2, 3, rojo)).to eq(10)
   end
 
-  it "puts and takes out balls in a given position" do
-    board = Board.new 2, 2
+  it 'puts and takes out balls in a given position' do
+    board = described_class.new(2, 2)
 
     3.times { board.put 1, 1, verde }
     3.times { board.take_out 1, 1, verde }
 
-    expect(board.are_there_balls?(1, 1, verde)).to be false
+    expect(board.are_there_balls?(1, 1, verde)).to be(false)
   end
 
-  it "clears the entire board" do
-    board = Board.new 3, 4
+  it 'clears the entire board' do
+    board = described_class.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
+    board.each_cell { |cell| expect_no_balls(*colors, on: cell) }
   end
 
-  it "is empty if there are no balls" do
-    board = Board.new 3, 4
-    expect(board.empty?).to be true
+  it 'is empty if there are no balls' do
+    board = described_class.new(3, 4)
+
+    expect(board).to be_empty
   end
 
-  it "is not empty if there are balls" do
-    board = Board.new 3, 4
+  it 'is not empty if there are balls' do
+    board = described_class.new(3, 4)
     board.put 0, 0, negro
-    expect(board.empty?).to be false
-  end
 
+    expect(board).not_to be_empty
+  end
 end