gobstones 0.0.1.1 → 0.0.2

data/spec/parser/arithmetic_expressions_spec.rb

@@ -1,34 +1,34 @@
 describe Gobstones::Parser, "arithmetic expressions" do
 
-  let(:a) { VarName.new 'a' }
-  let(:b) { VarName.new 'b' }
-  let(:c) { VarName.new 'c' }
-  let(:d) { VarName.new 'd' }
+  let(:a) { 'a'.to_var_name }
+  let(:b) { 'b'.to_var_name }
+  let(:c) { 'c'.to_var_name }
+  let(:d) { 'd'.to_var_name }
 
   describe "addition and subtraction" do
 
-    it "should parse a + expression" do
+    it "parses a + expression" do
       sum = Add.new a, b
 
       expect('a+b').to be_parsed_as(:expression).and_return(sum)
       expect('a +  b').to be_parsed_as(:expression).and_return(sum)
     end
 
-    it "should parse a nested + expression, associating to left" do
+    it "parses a nested + expression, associating to left" do
       sum_ab = Add.new a, b
       total = Add.new sum_ab, c
 
       expect('a + b + c').to be_parsed_as(:expression).and_return(total)
     end
 
-    it "should parse a - expression" do
+    it "parses a - expression" do
       sub = Sub.new a, b
 
       expect('a-b').to be_parsed_as(:expression).and_return(sub)
       expect('a -  b').to be_parsed_as(:expression).and_return(sub)
     end
 
-    it "should parse a nested expression with + and -, associating to left" do
+    it "parses a nested expression with + and -, associating to left" do
       sum_ab = Add.new a, b
       total = Sub.new sum_ab, c
 
@@ -39,42 +39,42 @@ describe Gobstones::Parser, "arithmetic expressions" do
 
   describe "multiplication, division, modulus and power" do
 
-    it "should parse a * expression" do
+    it "parses a * expression" do
       mul = Mul.new a, b
 
       expect('a*b').to be_parsed_as(:expression).and_return(mul)
       expect('a   * b').to be_parsed_as(:expression).and_return(mul)
     end
 
-    it "should parse a nested * expression" do
+    it "parses a nested * expression" do
       mul_ab = Mul.new a, b
       total = Mul.new mul_ab, c
 
       expect('a * b * c').to be_parsed_as(:expression).and_return(total)
     end
 
-    it "should parse a div expression" do
+    it "parses a div expression" do
       div = Div.new a, b
 
       expect('a div b').to be_parsed_as(:expression).and_return(div)
       expect('a   div  b').to be_parsed_as(:expression).and_return(div)
     end
 
-    it "should parse a mod expression" do
+    it "parses a mod expression" do
       mod = Mod.new a, b
 
       expect('a mod b').to be_parsed_as(:expression).and_return(mod)
       expect('a  mod   b').to be_parsed_as(:expression).and_return(mod)
     end
 
-    it "should parse a power expression" do
+    it "parses a power expression" do
       pow = Pow.new a, b
 
       expect('a^b').to be_parsed_as(:expression).and_return(pow)
       expect('a ^  b').to be_parsed_as(:expression).and_return(pow)
     end
 
-    it "should parse a nested power expression, associating left" do
+    it "parses a nested power expression, associating left" do
       pow_ab = Pow.new a, b
       pow_abc = Pow.new pow_ab, c
       pow_abcd = Pow.new pow_abc, d
@@ -86,7 +86,7 @@ describe Gobstones::Parser, "arithmetic expressions" do
 
   describe "complex arithmetic expressions (without parentheses)" do
 
-    it "should parse using precedence of + and - over *" do
+    it "parses using precedence of + and - over *" do
       mul = Mul.new b, c
       sub = Sub.new a, mul
       add = Add.new sub, d
@@ -94,7 +94,7 @@ describe Gobstones::Parser, "arithmetic expressions" do
       expect('a - b * c + d').to be_parsed_as(:expression).and_return(add)
     end
 
-    it "should parse using precedence of * over div and mod" do
+    it "parses using precedence of * over div and mod" do
       div = Div.new a, b
       mod = Mod.new a, c
       inner_mul = Mul.new div, mod
@@ -104,7 +104,7 @@ describe Gobstones::Parser, "arithmetic expressions" do
         to be_parsed_as(:expression).and_return(outer_mul)
     end
 
-    it "should parse using precedence of div and mod over ^" do
+    it "parses using precedence of div and mod over ^" do
       pow_ab = Pow.new a, b
       pow_cd = Pow.new c, d
       div = Div.new pow_ab, pow_cd
@@ -112,7 +112,7 @@ describe Gobstones::Parser, "arithmetic expressions" do
       expect('a^b div c^d').to be_parsed_as(:expression).and_return(div)
     end
 
-    it "should parse an expression with all kind of operators" do
+    it "parses an expression with all kind of operators" do
       pow = Pow.new b, c
       mod = Mod.new a, pow
       div = Div.new d, b
@@ -126,4 +126,4 @@ describe Gobstones::Parser, "arithmetic expressions" do
 
   end
 
-end
+end

data/spec/parser/assignments_spec.rb

@@ -2,8 +2,8 @@ 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
+    it "parses a valid assignment with a simple expression" do
+      assignment = SingleAssignment.new 'myDir'.to_var_name, norte
 
       expect('myDir:=Norte').
         to be_parsed_as(:command).and_return(assignment)
@@ -11,20 +11,20 @@ describe Gobstones::Parser, "assignments" do
         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
+    it "parses a valid assignment with a complex expression" do
+      a, b = 'a'.to_var_name, 'b'.to_var_name
+      exp = Or.new false_value, EnclosedByParensExpression.new(And.new(a, b))
+      assignment = SingleAssignment.new 'myVar'.to_var_name, 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
+    it "does 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
+    it "does not parse with a command on the right side" do
       expect('myVar := Skip').to be_parsed_as(:command).and_fail
     end
 
@@ -32,8 +32,22 @@ describe Gobstones::Parser, "assignments" do
 
   describe "multiple" do
 
-    # TODO implement
+    context "failures" do
+
+      it 'fails if the expression on the left side is not a var tuple' do
+        expect('myVar = funcCall()').to be_parsed_as(:command).and_fail
+      end
+
+    end
+
+    it 'parses a valid assignment with a function call on the right side' do
+      var_tuple = VarTuple.new ['aColor'.to_var_name, 'aDirection'.to_var_name]
+      func_call = FunctionCall.new 'myFunction', []
+      assignment = MultipleAssignment.new var_tuple, func_call
+      expect('(aColor, aDirection) := myFunction()').
+          to be_parsed_as(:command).and_return(assignment)
+    end
 
   end
 
-end
+end

data/spec/parser/boolean_expressions_spec.rb

@@ -1,48 +1,48 @@
 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' }
+  let(:a) { 'a'.to_var_name }
+  let(:b) { 'b'.to_var_name }
+  let(:c) { 'c'.to_var_name }
+  let(:d) { 'd'.to_var_name }
 
   describe "relational operators" do
 
-    it "should parse an expression with ==" do
+    it "parses 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
+    it "parses 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
+    it "parses 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
+    it "parses 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
+    it "parses 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
+    it "parses an expression with >" do
       gt = GreaterThan.new a, b
 
       expect('a>b').to be_parsed_as(:expression).and_return(gt)
@@ -53,21 +53,21 @@ describe Gobstones::Parser, "boolean expressions" do
 
   describe "not, and, or" do
 
-    it "should parse a not expression" do
+    it "parses 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
+    it "parses 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
+    it "parses an Or expression" do
       exp = Or.new a, b
 
       expect('a||b').to be_parsed_as(:expression).and_return(exp)
@@ -76,28 +76,28 @@ describe Gobstones::Parser, "boolean expressions" do
 
     describe "nested" do
 
-      it "should parse a nested || expression, associating right" do
+      it "parses 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
+      it "parses 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
+      it "parses with || taking 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
+      it "parses with || taking precedence over &&, right" do
         ab_and = And.new a, b
         abc_or = Or.new ab_and, c
 
@@ -108,4 +108,4 @@ describe Gobstones::Parser, "boolean expressions" do
 
   end
 
-end
+end

data/spec/parser/command_block_spec.rb

@@ -1,22 +1,20 @@
 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)
+  it "parses an empty block" do
+    expect('{}').to be_parsed_as(:command).and_return(CommandBlock.empty)
+    expect('{     }').to be_parsed_as(:command).and_return(CommandBlock.empty)
   end
 
-  it "should parse a block with one simple cmd" do
-    cmd_block = CmdBlock.new [Skip.new]
+  it "parses a block with one simple cmd" do
+    cmd_block = CommandBlock.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
+  it "parses a block with many simple commands" do
+    first = Poner.new verde
     second = Boom.new "error"
-    third = Mover.new Oeste.new
-    cmd_block = CmdBlock.new [first, second, third]
+    third = Mover.new oeste
+    cmd_block = CommandBlock.new [first, second, third]
 
     expect('{
       Poner(Verde)
@@ -25,21 +23,21 @@ describe Gobstones::Parser, "command blocks" do
      }').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]
+  it "allows semicolon between commands" do
+    first = Poner.new verde
+    second = Boom.new 'error'
+    third = Mover.new oeste
+    cmd_block = CommandBlock.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
+  it "parses 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]
+    second = IfCmd.new true_value, empty_body
+    cmd_block = CommandBlock.new [first, second]
 
     expect('{
       Proc()

data/spec/parser/data_types_spec.rb

@@ -2,11 +2,11 @@ describe Gobstones::Parser, "data types" do
 
   describe "numbers" do
 
-    it "should parse a positive number" do
+    it "parses 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
+    it "parses a negative number" do
       expect('-42').to be_parsed_as(:expression).and_return(-42.to_gbs_num)
     end
 
@@ -14,54 +14,54 @@ describe Gobstones::Parser, "data types" do
 
   describe "booleans" do
 
-    it "should parse a true boolean" do
-      expect('True').to be_parsed_as(:expression).and_return(True.new)
+    it "parses a true boolean" do
+      expect('True').to be_parsed_as(:expression).and_return(true_value)
     end
 
-    it "should parse a false boolean" do
-      expect('False').to be_parsed_as(:expression).and_return(False.new)
+    it "parses a false boolean" do
+      expect('False').to be_parsed_as(:expression).and_return(false_value)
     end
 
   end
 
   describe "colors" do
 
-    it "should parse the 'Azul' color" do
-      expect('Azul').to be_parsed_as(:expression).and_return(Azul.new)
+    it "parses the 'Azul' color" do
+      expect('Azul').to be_parsed_as(:expression).and_return(azul)
     end
 
-    it "should parse the 'Negro' color" do
-      expect('Negro').to be_parsed_as(:expression).and_return(Negro.new)
+    it "parses the 'Negro' color" do
+      expect('Negro').to be_parsed_as(:expression).and_return(negro)
     end
 
-    it "should parse the 'Rojo' color" do
-      expect('Rojo').to be_parsed_as(:expression).and_return(Rojo.new)
+    it "parses the 'Rojo' color" do
+      expect('Rojo').to be_parsed_as(:expression).and_return(rojo)
     end
 
-    it "should parse the 'Verde' color" do
-      expect('Verde').to be_parsed_as(:expression).and_return(Verde.new)
+    it "parses the 'Verde' color" do
+      expect('Verde').to be_parsed_as(:expression).and_return(verde)
     end
 
   end
 
   describe "directions" do
 
-    it "should parse the 'Norte' direction" do
-      expect('Norte').to be_parsed_as(:expression).and_return(Norte.new)
+    it "parses the 'Norte' direction" do
+      expect('Norte').to be_parsed_as(:expression).and_return(norte)
     end
 
-    it "should parse the 'Este' direction" do
-      expect('Este').to be_parsed_as(:expression).and_return(Este.new)
+    it "parses the 'Este' direction" do
+      expect('Este').to be_parsed_as(:expression).and_return(este)
     end
 
-    it "should parse the 'Sur' direction" do
-      expect('Sur').to be_parsed_as(:expression).and_return(Sur.new)
+    it "parses the 'Sur' direction" do
+      expect('Sur').to be_parsed_as(:expression).and_return(sur)
     end
 
-    it "should parse the 'Oeste' direction" do
-      expect('Oeste').to be_parsed_as(:expression).and_return(Oeste.new)
+    it "parses the 'Oeste' direction" do
+      expect('Oeste').to be_parsed_as(:expression).and_return(oeste)
     end
 
   end
 
-end
+end