gobstones 0.0.1.1 → 0.0.2

data/spec/parser/function_calls_spec.rb

@@ -1,37 +1,38 @@
 describe Gobstones::Parser, "function calls" do
 
-  it "should parse a function call without args" do
+  it "parses a function call without args" do
     expected = FunctionCall.new 'f1'
     expect('f1()').to be_parsed_as(:expression).and_return(expected)
   end
 
-  it "should not parse a function call without a valid identifier" do
+  it "does not parse a function call without a valid identifier" do
     expect('F1()').to be_parsed_as(:expression).and_fail
   end
 
-  it "should parse a function call with one arg" do
-    expected = FunctionCall.new 'func1', [Verde.new]
+  it "parses a function call with one arg" do
+    expected = FunctionCall.new 'func1', [verde]
     expect('func1(Verde)').to be_parsed_as(:expression).and_return(expected)
   end
 
-  it "should parse a function with many args" do
+  it "parses a function 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 = FunctionCall.new 'func1', [first_arg, second_arg, third_arg]
 
     expect('func1(42, nroBolitas(Verde), Norte)').
       to be_parsed_as(:expression).and_return(expected)
   end
 
-  it "should parse a complex function 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 function call" do
+    or_expr = Or.new 'a'.to_var_name, 'b'.to_var_name
+    div = Div.new 10.to_gbs_num, 'c'.to_var_name
+    paren_expr = EnclosedByParensExpression.new div
     num_expr = Mul.new 5.to_gbs_num, paren_expr
-    func2_call = FunctionCall.new 'func2', [Verde.new, Opuesto.new(Norte.new)]
+    func2_call = FunctionCall.new 'func2', [verde, Opuesto.new(norte)]
     func1_call = FunctionCall.new 'func1', [or_expr, num_expr, func2_call]
     expect('func1(a || b, 5*(10 div c), func2(Verde, opuesto(Norte)))').
       to be_parsed_as(:expression).and_return(func1_call)
   end
 
-end
+end

data/spec/parser/function_definitions_spec.rb

@@ -1,33 +1,28 @@
 describe Gobstones::Parser, "function definitions" do
 
-  it "should parse a function without args and a single return" do
-    args = VarTuple.new []
+  it "parses a function without args and a single return" do
     func_return = ReturnFromFunction.new [42.to_gbs_num]
 
-    func_def = Function.new 'just42', args, CmdBlock.new([]), func_return
+    func_def = Function.new 'just42', no_arguments, empty_body, func_return
 
     expect('function just42() { return (42) }').
       to be_parsed_as(:definition).and_return(func_def)
   end
 
-  it "should parse a function 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]
-    body =
-    return_st = ReturnFromFunction.new [Verde.new, PuedeMover.new(Norte.new)]
-    func_def = Function.new 'myCoolFunction', args, CmdBlock.new([]), return_st
+  it "parses a function with some args" do
+    args = VarTuple.new ['firstArg'.to_var_name, 'secondArg'.to_var_name, 'thirdArg'.to_var_name]
+    return_st = ReturnFromFunction.new [verde, PuedeMover.new(norte)]
+    func_def = Function.new 'myCoolFunction', args, empty_body, return_st
 
     expect('function myCoolFunction (firstArg, secondArg, thirdArg) {
   return (Verde, puedeMover(Norte))
 }').to be_parsed_as(:definition).and_return(func_def)
   end
 
-  it "should parse a function with some statements" do
-    args = VarTuple.new [VarName.new('arg')]
-    body = CmdBlock.new [Poner.new(Verde.new)]
-    return_st = ReturnFromFunction.new [True.new]
+  it "parses a function with some statements" do
+    args = VarTuple.new ['arg'.to_var_name]
+    body = CommandBlock.new [Poner.new(verde)]
+    return_st = ReturnFromFunction.new [true_value]
     func_def = Function.new 'myFunc', args, body, return_st
 
     expect('function myFunc(arg)
@@ -37,14 +32,14 @@ describe Gobstones::Parser, "function definitions" do
 }').to be_parsed_as(:definition).and_return(func_def)
   end
 
-  it "should not parse a function without a valid identifier" do
+  it "does not parse a function without a valid identifier" do
     expect('function MyWrongFunc() { return(True) }').
       to be_parsed_as(:definition).and_fail
   end
 
-  it "should not parse a function without a return statement" do
+  it "does not parse a function without a return statement" do
     expect('function myFuncWithoutReturn() { }').
       to be_parsed_as(:definition).and_fail
   end
 
-end
+end

data/spec/parser/gobstones_program_spec.rb

@@ -1,16 +1,16 @@
 describe Gobstones::Parser, "program definitions" do
 
-  it "should parse a simple program with a single main" do
-    main_def = Main.new CmdBlock.new([]), NoReturnStatement.new
-    program = Program.new [], main_def
+  it "parses a simple program with a single main" do
+    main_def = Main.new empty_body, no_return_statement
+    program = Program.new no_definitions, main_def
 
     expect('procedure Main(){}').to be_parsed_as(:program).and_return(program)
   end
 
-  it "should parse a program with Main and procedures" do
-    main_def = Main.new CmdBlock.new([]), NoReturnStatement.new
-    proc_1 = Procedure.new 'Procedure1', VarTuple.new([]), CmdBlock.new([])
-    proc_2 = Procedure.new 'Procedure2', VarTuple.new([]), CmdBlock.new([])
+  it "parses a program with Main and procedures" do
+    main_def = Main.new empty_body, no_return_statement
+    proc_1 = Procedure.new 'Procedure1', no_arguments, empty_body
+    proc_2 = Procedure.new 'Procedure2', no_arguments, empty_body
     program = Program.new [proc_1, proc_2], main_def
 
     gbs_code = <<GBS
@@ -23,11 +23,11 @@ GBS
     expect(gbs_code).to be_parsed_as(:program).and_return(program)
   end
 
-  it "should parse a program with Main, procedures and functions" do
-    main_def = Main.new CmdBlock.new([]), NoReturnStatement.new
-    proc_1 = Procedure.new 'Procedure1', VarTuple.new([]), CmdBlock.new([])
-    func_1 = Function.new 'function1', VarTuple.new([]), CmdBlock.new([]), ReturnFromFunction.new([42.to_gbs_num])
-    proc_2 = Procedure.new 'Procedure2', VarTuple.new([]), CmdBlock.new([])
+  it "parses a program with Main, procedures and functions" do
+    main_def = Main.new empty_body, NoReturnStatement.new
+    proc_1 = Procedure.new 'Procedure1', no_arguments, empty_body
+    func_1 = Function.new 'function1', no_arguments, empty_body, ReturnFromFunction.new([42.to_gbs_num])
+    proc_2 = Procedure.new 'Procedure2', no_arguments, empty_body
     program = Program.new [proc_1, func_1, proc_2], main_def
     gbs_code = <<GBS
 procedure Procedure1(){ }
@@ -41,15 +41,15 @@ GBS
     expect(gbs_code).to be_parsed_as(:program).and_return(program)
   end
 
-  it "should not parse a program without a Main definition" do
+  it "does not parse a program without a Main definition" do
     expect('procedure Procedure1(){}
     procedure Procedure2() {}').to be_parsed_as(:program).and_fail
   end
 
-  it "should not parse a program if Main is not the last definition" do
+  it "does not parse a program if Main is not the last definition" do
     expect('procedure Procedure1() {}
     procedure Main() {}
     procedure Procedure2() {}').to be_parsed_as(:program).and_fail
   end
 
-end
+end

data/spec/parser/if_command_spec.rb

@@ -2,8 +2,8 @@ describe Gobstones::Parser, "if statements" do
 
   describe "if" do
 
-    it "should parse a statement with a simple boolean and an empty block" do
-      if_cmd = IfCmd.new True.new, CmdBlock.empty
+    it "parses a statement with a simple boolean and an empty block" do
+      if_cmd = IfCmd.new true_value, empty_body
 
       expect('if (True) {}').to be_parsed_as(:command).and_return(if_cmd)
       expect('if (True) {
@@ -12,18 +12,19 @@ describe Gobstones::Parser, "if statements" do
         {}').to be_parsed_as(:command).and_return(if_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]
-      if_cmd = IfCmd.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]
+      if_cmd = IfCmd.new false_value, cmd_block
 
       expect('if(False){Poner(Verde); Skip}').
         to be_parsed_as(:command).and_return(if_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)
-      if_cmd = IfCmd.new exp, CmdBlock.empty
+    it "parses a statement with a complex boolean expression" do
+      and_expr = And.new 'a'.to_var_name, false_value
+      inner_and = EnclosedByParensExpression.new and_expr
+      exp = Or.new PuedeMover.new(norte), inner_and
+      if_cmd = IfCmd.new exp, empty_body
 
       expect('if (puedeMover(Norte) || (a && False)) {}').
         to be_parsed_as(:command).and_return(if_cmd)
@@ -33,9 +34,9 @@ describe Gobstones::Parser, "if statements" do
 
   describe "if-else" do
 
-    it "should parse a statement with an else block" do
-      else_block = CmdBlock.new [Mover.new(Norte.new)]
-      if_else_cmd = IfElseCmd.new False.new, CmdBlock.empty, else_block
+    it "parses a statement with an else block" do
+      else_block = CommandBlock.new [Mover.new(norte)]
+      if_else_cmd = IfElseCmd.new false_value, empty_body, else_block
 
       expect('if (False) { } else { Mover(Norte) }').
         to be_parsed_as(:command).and_return(if_else_cmd)

data/spec/parser/main_definition_spec.rb

@@ -1,23 +1,23 @@
 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
+  let(:return_tuple) { VarTuple.new ['x'.to_var_name, 'y'.to_var_name] }
+
+  it "parses a valid Main definition without return nor commands" do
+    main = Main.new empty_body, no_return_statement
 
     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)
+  it "parses a valid main procedure with a return of var names" do
+    main = Main.new empty_body, 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]
+  it "parses a valid main procedure with commands and return" do
+    cmd_block = CommandBlock.new [Mover.new(oeste), Skip.new]
     main = Main.new cmd_block, ReturnFromMain.new(return_tuple)
 
     expect('procedure Main() {
@@ -27,16 +27,16 @@ describe Gobstones::Parser, "main definition" do
     }').to be_parsed_as(:main).and_return(main)
   end
 
-  it "should not parse a main procedure with an invalid identifier" do
+  it "does 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
+  it "does 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
+  it "does not parse a main procedure with args" do
     expect('procedure Main(arg1, arg2) {}').to be_parsed_as(:main).and_fail
   end
 
-end
+end

data/spec/parser/nested_expressions_spec.rb

@@ -1,39 +1,35 @@
 describe Gobstones::Parser, "nested expressions" do
 
-  it "should parse literals between ()" do
+  it "parses literals between ()" do
     expect('(  42 )').to be_parsed_as(:expression).
-      and_return(ParenthesesExpr.new(42.to_gbs_num))
+      and_return(EnclosedByParensExpression.new(42.to_gbs_num))
     expect('(True )').to be_parsed_as(:expression).
-      and_return(ParenthesesExpr.new(True.new))
+      and_return(EnclosedByParensExpression.new(true_value))
     expect('(Rojo )').to be_parsed_as(:expression).
-      and_return(ParenthesesExpr.new(Rojo.new))
+      and_return(EnclosedByParensExpression.new(rojo))
     expect('(Verde)').to be_parsed_as(:expression).
-      and_return(ParenthesesExpr.new(Verde.new))
+      and_return(EnclosedByParensExpression.new(verde))
   end
 
-  it "should parse primitive functions between ()" do
-    puede_mover = ParenthesesExpr.new(PuedeMover.new(Norte.new))
+  it "parses primitive functions between ()" do
+    puede_mover = EnclosedByParensExpression.new(PuedeMover.new(norte))
     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)
+  it "parses nested arithmetic expressions between ()" do
+    paren_expr = EnclosedByParensExpression.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
+  it "parses a nested expressions with many ()" do
+    or_expr = Or.new 'b'.to_var_name, 'c'.to_var_name
+    inner_paren = EnclosedByParensExpression.new or_expr
+    and_expr = And.new 'a'.to_var_name, inner_paren
+    outer_paren = EnclosedByParensExpression.new and_expr
+    result = And.new outer_paren, 'd'.to_var_name
     expect('(a && (b || c)) && d').to be_parsed_as(:expression).and_return(result)
   end
 
-end
+end

data/spec/parser/primitive_expressions_spec.rb

@@ -2,20 +2,20 @@ 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'))
+    it "parses valid var names" do
+      expect('v').to be_parsed_as(:expression).and_return('v'.to_var_name)
+      expect('var1').to be_parsed_as(:expression).and_return('var1'.to_var_name)
+      expect('a_var').to be_parsed_as(:expression).and_return('a_var'.to_var_name)
+      expect('vAR').to be_parsed_as(:expression).and_return('vAR'.to_var_name)
     end
 
-    it "should not parse invalid var names" do
-      expect('1').not_to be_parsed_as(:expression).and_return(VarName.new('1'))
+    it "does not parse invalid var names" do
+      expect('1').not_to be_parsed_as(:expression).and_return('1'.to_var_name)
       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
+    it "does 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
@@ -26,27 +26,27 @@ describe Gobstones::Parser, "primitive expressions" do
 
   describe "type bounds functions" do
 
-    it "should parse the minBool() function" do
+    it "parses the minBool() function" do
       expect('minBool()').to be_parsed_as(:expression).and_return(MinBool.new)
     end
 
-    it "should parse the maxBool() function" do
+    it "parses the maxBool() function" do
       expect('maxBool()').to be_parsed_as(:expression).and_return(MaxBool.new)
     end
 
-    it "should parse the minColor() function" do
+    it "parses the minColor() function" do
       expect('minColor()').to be_parsed_as(:expression).and_return(MinColor.new)
     end
 
-    it "should parse the maxColor() function" do
+    it "parses the maxColor() function" do
       expect('maxColor()').to be_parsed_as(:expression).and_return(MaxColor.new)
     end
 
-    it "should parse the minDir() function" do
+    it "parses the minDir() function" do
       expect('minDir()').to be_parsed_as(:expression).and_return(MinDir.new)
     end
 
-    it "should parse the maxDir() function" do
+    it "parses the maxDir() function" do
       expect('maxDir()').to be_parsed_as(:expression).and_return(MaxDir.new)
     end
 
@@ -54,23 +54,20 @@ describe Gobstones::Parser, "primitive expressions" do
 
   describe "other type functions" do
 
-    it "should parse the siguiente() function " do
-      arg = VarName.new 'x'
-      func = Siguiente.new arg
+    it "parses the siguiente() function " do
+      func = Siguiente.new 'x'.to_var_name
       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
+    it "parses the previo() function" do
+      func = Previo.new 'y'.to_var_name
       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
+    it "parses the opuesto() function" do
+      func = Opuesto.new 'z'.to_var_name
       expect('opuesto(z)').to be_parsed_as(:expression).and_return(func)
       expect('opuesto(   z )').to be_parsed_as(:expression).and_return(func)
     end
@@ -79,27 +76,24 @@ describe Gobstones::Parser, "primitive expressions" do
 
   describe "board primitive functions" do
 
-    it "should parse the nroBolitas(exp) function" do
-      arg = VarName.new 'color'
-      func = NroBolitas.new arg
+    it "parses the nroBolitas(exp) function" do
+      func = NroBolitas.new 'color'.to_var_name
       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
+    it "parses the hayBolitas(exp) function" do
+      func = HayBolitas.new 'color'.to_var_name
       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
+    it "parses the puedeMover(exp) function" do
+      func = PuedeMover.new 'dir'.to_var_name
       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
+end