gobstones 0.0.1.1

data/spec/parser/assignments_spec.rb

@@ -0,0 +1,39 @@
+describe Gobstones::Parser, "assignments" do
+
+  describe "single" do
+
+    it "should parse a valid assignment with a simple expression" do
+      assignment = SingleAssignment.new VarName.new('myDir'), Norte.new
+
+      expect('myDir:=Norte').
+        to be_parsed_as(:command).and_return(assignment)
+      expect('myDir  :=   Norte').
+        to be_parsed_as(:command).and_return(assignment)
+    end
+
+    it "should parse a valid assignment with a complex expression" do
+      a, b = VarName.new('a'), VarName.new('b')
+      exp = Or.new False.new, ParenthesesExpr.new(And.new(a, b))
+      assignment = SingleAssignment.new VarName.new('myVar'), exp
+
+      expect('myVar := False || (a && b)').
+        to be_parsed_as(:command).and_return(assignment)
+    end
+
+    it "should not parse with an invalid var name" do
+      expect('MyWrongVar := a').to be_parsed_as(:command).and_fail
+    end
+
+    it "should not parse with a command on the right side" do
+      expect('myVar := Skip').to be_parsed_as(:command).and_fail
+    end
+
+  end
+
+  describe "multiple" do
+
+    # TODO implement
+
+  end
+
+end

data/spec/parser/boolean_expressions_spec.rb

@@ -0,0 +1,111 @@
+describe Gobstones::Parser, "boolean expressions" do
+
+  let(:a) { VarName.new 'a' }
+  let(:b) { VarName.new 'b' }
+  let(:c) { VarName.new 'c' }
+  let(:d) { VarName.new 'd' }
+
+  describe "relational operators" do
+
+    it "should parse an expression with ==" do
+      eq = Equal.new a, b
+
+      expect('a==b').to be_parsed_as(:expression).and_return(eq)
+      expect('a  == b').to be_parsed_as(:expression).and_return(eq)
+    end
+
+    it "should parse an expression with /=" do
+      not_eq = NotEqual.new a, b
+
+      expect('a/=b').to be_parsed_as(:expression).and_return(not_eq)
+      expect('a /=   b').to be_parsed_as(:expression).and_return(not_eq)
+    end
+
+    it "should parse an expression with <" do
+      lt = LessThan.new a, b
+
+      expect('a<b').to be_parsed_as(:expression).and_return(lt)
+      expect('a  <  b').to be_parsed_as(:expression).and_return(lt)
+    end
+
+    it "should parse an expression with <=" do
+      le = LessEqual.new a, b
+
+      expect('a<=b').to be_parsed_as(:expression).and_return(le)
+      expect('a  <= b').to be_parsed_as(:expression).and_return(le)
+    end
+
+    it "should parse an expression with >=" do
+      ge = GreaterEqual.new a, b
+
+      expect('a>=b').to be_parsed_as(:expression).and_return(ge)
+      expect('a >=  b').to be_parsed_as(:expression).and_return(ge)
+    end
+
+    it "should parse an expression with >" do
+      gt = GreaterThan.new a, b
+
+      expect('a>b').to be_parsed_as(:expression).and_return(gt)
+      expect('a  > b').to be_parsed_as(:expression).and_return(gt)
+    end
+
+  end
+
+  describe "not, and, or" do
+
+    it "should parse a not expression" do
+      exp = Equal.new a, b
+      not_exp = Not.new exp
+
+      expect('not a == b').to be_parsed_as(:expression).and_return(not_exp)
+    end
+
+    it "should parse an And expression" do
+      exp = And.new a, b
+
+      expect('a&&b').to be_parsed_as(:expression).and_return(exp)
+      expect('a &&  b').to be_parsed_as(:expression).and_return(exp)
+    end
+
+    it "should parse an Or expression" do
+      exp = Or.new a, b
+
+      expect('a||b').to be_parsed_as(:expression).and_return(exp)
+      expect('a   || b').to be_parsed_as(:expression).and_return(exp)
+    end
+
+    describe "nested" do
+
+      it "should parse a nested || expression, associating right" do
+        inner_or = Or.new b, c
+        outer_or = Or.new a, inner_or
+
+        expect('a || b || c').to be_parsed_as(:expression).and_return(outer_or)
+      end
+
+      it "should parse a nested && expression, associating right" do
+        inner_and = And.new b, c
+        outer_and = And.new a, inner_and
+
+        expect('a && b && c').to be_parsed_as(:expression).and_return(outer_and)
+      end
+
+      it "|| should take precedence over &&, left" do
+        bc_and = And.new b, c
+        abc_or = Or.new a, bc_and
+
+        expect('a || b && c').to be_parsed_as(:expression).and_return(abc_or)
+      end
+
+      it "|| should take precedence over &&, right" do
+        ab_and = And.new a, b
+        abc_or = Or.new ab_and, c
+
+        expect('a && b || c').to be_parsed_as(:expression).and_return(abc_or)
+      end
+
+    end
+
+  end
+
+end

data/spec/parser/command_block_spec.rb

@@ -0,0 +1,50 @@
+describe Gobstones::Parser, "command blocks" do
+
+  it "should parse an empty block" do
+    cmd_block = CmdBlock.empty
+
+    expect('{}').to be_parsed_as(:command).and_return(cmd_block)
+    expect('{     }').to be_parsed_as(:command).and_return(cmd_block)
+  end
+
+  it "should parse a block with one simple cmd" do
+    cmd_block = CmdBlock.new [Skip.new]
+    expect('{ Skip }').to be_parsed_as(:command).and_return(cmd_block)
+  end
+
+  it "should parse a block with many simple commands" do
+    first = Poner.new Verde.new
+    second = Boom.new "error"
+    third = Mover.new Oeste.new
+    cmd_block = CmdBlock.new [first, second, third]
+
+    expect('{
+      Poner(Verde)
+      BOOM("error")
+      Mover(Oeste)
+     }').to be_parsed_as(:command).and_return(cmd_block)
+  end
+
+  it "should allow ; between commands" do
+    first = Poner.new Verde.new
+    second = Boom.new "error"
+    third = Mover.new Oeste.new
+    cmd_block = CmdBlock.new [first, second, third]
+
+    expect('{Poner(Verde); BOOM("error");
+      Mover(Oeste);
+     }').to be_parsed_as(:command).and_return(cmd_block)
+  end
+
+  it "should parse a block with simple and complex commands" do
+    first = ProcedureCall.new 'Proc', []
+    second = IfCmd.new True.new, CmdBlock.empty
+    cmd_block = CmdBlock.new [first, second]
+
+    expect('{
+      Proc()
+      if (True) {}
+     }').to be_parsed_as(:command).and_return(cmd_block)
+  end
+
+end

data/spec/parser/data_types_spec.rb

@@ -0,0 +1,67 @@
+describe Gobstones::Parser, "data types" do
+
+  describe "numbers" do
+
+    it "should parse a positive number" do
+      expect('42').to be_parsed_as(:expression).and_return(42.to_gbs_num)
+    end
+
+    it "should parse a negative number" do
+      expect('-42').to be_parsed_as(:expression).and_return(-42.to_gbs_num)
+    end
+
+  end
+
+  describe "booleans" do
+
+    it "should parse a true boolean" do
+      expect('True').to be_parsed_as(:expression).and_return(True.new)
+    end
+
+    it "should parse a false boolean" do
+      expect('False').to be_parsed_as(:expression).and_return(False.new)
+    end
+
+  end
+
+  describe "colors" do
+
+    it "should parse the 'Azul' color" do
+      expect('Azul').to be_parsed_as(:expression).and_return(Azul.new)
+    end
+
+    it "should parse the 'Negro' color" do
+      expect('Negro').to be_parsed_as(:expression).and_return(Negro.new)
+    end
+
+    it "should parse the 'Rojo' color" do
+      expect('Rojo').to be_parsed_as(:expression).and_return(Rojo.new)
+    end
+
+    it "should parse the 'Verde' color" do
+      expect('Verde').to be_parsed_as(:expression).and_return(Verde.new)
+    end
+
+  end
+
+  describe "directions" do
+
+    it "should parse the 'Norte' direction" do
+      expect('Norte').to be_parsed_as(:expression).and_return(Norte.new)
+    end
+
+    it "should parse the 'Este' direction" do
+      expect('Este').to be_parsed_as(:expression).and_return(Este.new)
+    end
+
+    it "should parse the 'Sur' direction" do
+      expect('Sur').to be_parsed_as(:expression).and_return(Sur.new)
+    end
+
+    it "should parse the 'Oeste' direction" do
+      expect('Oeste').to be_parsed_as(:expression).and_return(Oeste.new)
+    end
+
+  end
+
+end

data/spec/parser/function_calls_spec.rb

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

data/spec/parser/function_definitions_spec.rb

@@ -0,0 +1,50 @@
+describe Gobstones::Parser, "function definitions" do
+
+  it "should parse a function without args and a single return" do
+    args = VarTuple.new []
+    func_return = ReturnFromFunction.new [42.to_gbs_num]
+
+    func_def = Function.new 'just42', args, CmdBlock.new([]), 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
+
+    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]
+    func_def = Function.new 'myFunc', args, body, return_st
+
+    expect('function myFunc(arg)
+{
+  Poner(Verde)
+  return (True)
+}').to be_parsed_as(:definition).and_return(func_def)
+  end
+
+  it "should 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
+    expect('function myFuncWithoutReturn() { }').
+      to be_parsed_as(:definition).and_fail
+  end
+
+end

data/spec/parser/gobstones_program_spec.rb

@@ -0,0 +1,55 @@
+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
+
+    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([])
+    program = Program.new [proc_1, proc_2], main_def
+
+    gbs_code = <<GBS
+procedure Procedure1(){ }
+
+procedure Procedure2 () {}
+
+procedure Main() {}
+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([])
+    program = Program.new [proc_1, func_1, proc_2], main_def
+    gbs_code = <<GBS
+procedure Procedure1(){ }
+
+function function1() { return (42) }
+
+procedure Procedure2 () {}
+
+procedure Main() {}
+GBS
+    expect(gbs_code).to be_parsed_as(:program).and_return(program)
+  end
+
+  it "should 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
+    expect('procedure Procedure1() {}
+    procedure Main() {}
+    procedure Procedure2() {}').to be_parsed_as(:program).and_fail
+  end
+
+end

data/spec/parser/if_command_spec.rb

@@ -0,0 +1,46 @@
+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
+
+      expect('if (True) {}').to be_parsed_as(:command).and_return(if_cmd)
+      expect('if (True) {
+      }').to be_parsed_as(:command).and_return(if_cmd)
+      expect('if (True)
+        {}').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
+
+      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
+
+      expect('if (puedeMover(Norte) || (a && False)) {}').
+        to be_parsed_as(:command).and_return(if_cmd)
+    end
+
+  end
+
+  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
+
+      expect('if (False) { } else { Mover(Norte) }').
+        to be_parsed_as(:command).and_return(if_else_cmd)
+    end
+
+  end
+
+end