gobstones 0.0.1.1

data/spec/parser/main_definition_spec.rb

@@ -0,0 +1,42 @@
+describe Gobstones::Parser, "main definition" do
+
+  it "should parse a valid Main definition without return nor commands" do
+    main = Main.new CmdBlock.new([]), NoReturnStatement.new
+
+    expect('procedure Main() {}').to be_parsed_as(:definition).and_fail
+    expect('procedure Main() {}').to be_parsed_as(:main).and_return(main)
+  end
+
+  it "should parse a valid main procedure with a return of var names" do
+    return_tuple = VarTuple.new [VarName.new('x'), VarName.new('y')]
+    main = Main.new CmdBlock.new([]), ReturnFromMain.new(return_tuple)
+
+    expect('procedure Main() { return (x, y); }').
+      to be_parsed_as(:main).and_return(main)
+  end
+
+  it "should parse a valid main procedure with commands and return" do
+    return_tuple = VarTuple.new [VarName.new('x'), VarName.new('y')]
+    cmd_block = CmdBlock.new [Mover.new(Oeste.new), Skip.new]
+    main = Main.new cmd_block, ReturnFromMain.new(return_tuple)
+
+    expect('procedure Main() {
+       Mover(Oeste)
+       Skip
+       return (x, y)
+    }').to be_parsed_as(:main).and_return(main)
+  end
+
+  it "should not parse a main procedure with an invalid identifier" do
+    expect('procedure NotMain() {}').to be_parsed_as(:main).and_fail
+  end
+
+  it "should not parse a main procedure with a return of expressions" do
+    expect('procedure Main() { return (3+4) }').to be_parsed_as(:main).and_fail
+  end
+
+  it "should not parse a main procedure with args" do
+    expect('procedure Main(arg1, arg2) {}').to be_parsed_as(:main).and_fail
+  end
+
+end

data/spec/parser/nested_expressions_spec.rb

@@ -0,0 +1,39 @@
+describe Gobstones::Parser, "nested expressions" do
+
+  it "should parse literals between ()" do
+    expect('(  42 )').to be_parsed_as(:expression).
+      and_return(ParenthesesExpr.new(42.to_gbs_num))
+    expect('(True )').to be_parsed_as(:expression).
+      and_return(ParenthesesExpr.new(True.new))
+    expect('(Rojo )').to be_parsed_as(:expression).
+      and_return(ParenthesesExpr.new(Rojo.new))
+    expect('(Verde)').to be_parsed_as(:expression).
+      and_return(ParenthesesExpr.new(Verde.new))
+  end
+
+  it "should parse primitive functions between ()" do
+    puede_mover = ParenthesesExpr.new(PuedeMover.new(Norte.new))
+    expect('(puedeMover(Norte))').
+      to be_parsed_as(:expression).and_return(puede_mover)
+  end
+
+  it "should parse nested arithmetic expressions between ()" do
+    paren_expr = ParenthesesExpr.new Add.new(3.to_gbs_num, 5.to_gbs_num)
+    expected = Mul.new paren_expr, 6.to_gbs_num
+    expect('(3 + 5) * 6').to be_parsed_as(:expression).and_return(expected)
+  end
+
+  it "should parse a nested expressions with many ()" do
+    b = VarName.new 'b'
+    c = VarName.new 'c'
+    or_expr = Or.new b, c
+    a = VarName.new 'a'
+    inner_paren = ParenthesesExpr.new or_expr
+    and_expr = And.new a, inner_paren
+    outer_paren = ParenthesesExpr.new and_expr
+    d = VarName.new 'd'
+    result = And.new outer_paren, d
+    expect('(a && (b || c)) && d').to be_parsed_as(:expression).and_return(result)
+  end
+
+end

data/spec/parser/primitive_expressions_spec.rb

@@ -0,0 +1,105 @@
+describe Gobstones::Parser, "primitive expressions" do
+
+  describe "variable identifiers" do
+
+    it "should parse valid var names" do
+      expect('v').to be_parsed_as(:expression).and_return(VarName.new('v'))
+      expect('var1').to be_parsed_as(:expression).and_return(VarName.new('var1'))
+      expect('a_var').to be_parsed_as(:expression).and_return(VarName.new('a_var'))
+      expect('vAR').to be_parsed_as(:expression).and_return(VarName.new('vAR'))
+    end
+
+    it "should not parse invalid var names" do
+      expect('1').not_to be_parsed_as(:expression).and_return(VarName.new('1'))
+      expect('_var').to be_parsed_as(:expression).and_fail
+      expect('Var').to be_parsed_as(:expression).and_fail
+    end
+
+    it "should not parse reserved words as var names" do
+      literals = %w{True False Rojo Negro Azul Verde Norte Oeste Este Sur}
+      (RESERVED_IDS - literals).each do |id|
+        expect(id).to be_parsed_as(:expression).and_fail
+      end
+    end
+
+  end
+
+  describe "type bounds functions" do
+
+    it "should parse the minBool() function" do
+      expect('minBool()').to be_parsed_as(:expression).and_return(MinBool.new)
+    end
+
+    it "should parse the maxBool() function" do
+      expect('maxBool()').to be_parsed_as(:expression).and_return(MaxBool.new)
+    end
+
+    it "should parse the minColor() function" do
+      expect('minColor()').to be_parsed_as(:expression).and_return(MinColor.new)
+    end
+
+    it "should parse the maxColor() function" do
+      expect('maxColor()').to be_parsed_as(:expression).and_return(MaxColor.new)
+    end
+
+    it "should parse the minDir() function" do
+      expect('minDir()').to be_parsed_as(:expression).and_return(MinDir.new)
+    end
+
+    it "should parse the maxDir() function" do
+      expect('maxDir()').to be_parsed_as(:expression).and_return(MaxDir.new)
+    end
+
+  end
+
+  describe "other type functions" do
+
+    it "should parse the siguiente() function " do
+      arg = VarName.new 'x'
+      func = Siguiente.new arg
+      expect('siguiente(x)').to be_parsed_as(:expression).and_return(func)
+      expect('siguiente(x    )').to be_parsed_as(:expression).and_return(func)
+    end
+
+    it "should parse the previo() function" do
+      arg = VarName.new 'y'
+      func = Previo.new arg
+      expect('previo(y)').to be_parsed_as(:expression).and_return(func)
+      expect('previo(   y )').to be_parsed_as(:expression).and_return(func)
+    end
+
+    it "should parse the opuesto() function" do
+      arg = VarName.new 'z'
+      func = Opuesto.new arg
+      expect('opuesto(z)').to be_parsed_as(:expression).and_return(func)
+      expect('opuesto(   z )').to be_parsed_as(:expression).and_return(func)
+    end
+
+  end
+
+  describe "board primitive functions" do
+
+    it "should parse the nroBolitas(exp) function" do
+      arg = VarName.new 'color'
+      func = NroBolitas.new arg
+      expect('nroBolitas(color)').to be_parsed_as(:expression).and_return(func)
+      expect('nroBolitas( color  )').to be_parsed_as(:expression).and_return(func)
+    end
+
+    it "should parse the hayBolitas(exp) function" do
+      arg = VarName.new 'color'
+      func = HayBolitas.new arg
+      expect('hayBolitas(color)').to be_parsed_as(:expression).and_return(func)
+      expect('hayBolitas(  color )').to be_parsed_as(:expression).and_return(func)
+    end
+
+    it "should parse the puedeMover(exp) function" do
+      arg = VarName.new 'dir'
+      func = PuedeMover.new arg
+      expect('puedeMover(dir)').to be_parsed_as(:expression).and_return(func)
+      expect('puedeMover(  dir  )').to be_parsed_as(:expression).and_return(func)
+    end
+
+  end
+
+end

data/spec/parser/procedure_calls_spec.rb

@@ -0,0 +1,36 @@
+describe Gobstones::Parser, "procedure calls" do
+
+  it "should parse 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
+    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]
+    expect('Proc1(Verde)').to be_parsed_as(:command).and_return(expected)
+  end
+
+  it "should parse a procedure with many args" do
+    first_arg = 42.to_gbs_num
+    second_arg = NroBolitas.new Verde.new
+    third_arg = Norte.new
+    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'))
+    num_expr = Mul.new 5.to_gbs_num, paren_expr
+    func_call = FunctionCall.new 'func', [Verde.new, Opuesto.new(Norte.new)]
+    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

data/spec/parser/procedure_definitions_spec.rb

@@ -0,0 +1,39 @@
+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
+
+    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
+
+    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)]
+    proc_def = Procedure.new 'MyProc', args, body
+
+    expect('procedure MyProc(arg)
+{
+  Poner(Verde)
+}').to be_parsed_as(:definition).and_return(proc_def)
+  end
+
+  it "should 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

@@ -0,0 +1,23 @@
+describe Gobstones::Parser, "repeatWith statements" do
+
+  it "should parse an empty statement" do
+    var_name = VarName.new 'i'
+    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
+
+    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
+
+    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

@@ -0,0 +1,62 @@
+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 "should parse 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
+      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|
+
+      describe "#{command}() cmd" do
+
+        it "should be parsed ok with a primitive as argument" do
+          cmd = Kernel.const_get(command).new Verde.new
+          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
+          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]
+          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 "should parse 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
+      vaciar_tablero_cmd = VaciarTablero.new
+      expect('VaciarTablero()').to be_parsed_as(:command).
+        and_return(vaciar_tablero_cmd)
+    end
+
+  end
+
+end

data/spec/parser/treetop_parser_spec.rb

@@ -0,0 +1,109 @@
+describe Gobstones::Parser do
+
+  before(:all) { @parser = TreetopParser.new }
+
+  describe "removing comments of a gobstones piece of code" do
+
+    it "should remove 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
+      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 "should remove 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
+      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 "should remove 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 "should remove 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
+      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 "should remove 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
+      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