gobstones 0.0.2 → 0.0.3

data/spec/parser/assignments_spec.rb

@@ -1,53 +1,43 @@
-describe Gobstones::Parser, "assignments" do
+RSpec.describe Gobstones::Parser, 'assignments' do
+  describe 'single' do
+    it 'parses a valid assignment with a simple expression' do
+      assignment = SingleAssignment.new('myDir'.to_var_name, norte)
 
-  describe "single" do
-
-    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)
-      expect('myDir  :=   Norte').
-        to be_parsed_as(:command).and_return(assignment)
+      expect('myDir:=Norte').to be_parsed_as(:command).and_return(assignment)
+      expect('myDir  :=   Norte').to be_parsed_as(:command).and_return(assignment)
     end
 
-    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
+    it 'parses a valid assignment with a complex expression' do
+      a = 'a'.to_var_name
+      b = '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)
+      expect('myVar := False || (a && b)').to be_parsed_as(:command).and_return(assignment)
     end
 
-    it "does 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 "does 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
-
   end
 
-  describe "multiple" do
-
-    context "failures" do
-
+  describe 'multiple' do
+    context 'when input causes a failure' 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
+      var_tuple = VarTuple.with_names(%w[aColor aDirection])
+      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

data/spec/parser/boolean_expressions_spec.rb

@@ -1,111 +1,103 @@
-describe Gobstones::Parser, "boolean expressions" do
-
+RSpec.describe 'parsing boolean expressions' do
   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 "parses an expression with ==" do
-      eq = Equal.new a, b
+  describe 'relational operators' 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 "parses an expression with /=" do
-      not_eq = NotEqual.new a, b
+    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 "parses an expression with <" do
-      lt = LessThan.new a, b
+    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 "parses an expression with <=" do
-      le = LessEqual.new a, b
+    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 "parses an expression with >=" do
-      ge = GreaterEqual.new a, b
+    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 "parses an expression with >" do
-      gt = GreaterThan.new a, b
+    it 'parses 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 "parses a not expression" do
-      exp = Equal.new a, b
-      not_exp = Not.new exp
+  describe 'not, and, or' 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 "parses an And expression" do
-      exp = And.new a, b
+    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 "parses an Or expression" do
-      exp = Or.new a, b
+    it 'parses 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 "parses a nested || expression, associating right" do
-        inner_or = Or.new b, c
-        outer_or = Or.new a, inner_or
+    describe 'nested' 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 "parses a nested && expression, associating right" do
-        inner_and = And.new b, c
-        outer_and = And.new a, inner_and
+      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 "parses with || taking precedence over &&, left" do
-        bc_and = And.new b, c
-        abc_or = Or.new a, bc_and
+      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 "parses with || taking precedence over &&, right" do
-        ab_and = And.new a, b
-        abc_or = Or.new ab_and, c
+      it 'parses with || taking 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

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

@@ -1,31 +1,25 @@
-describe Gobstones::Parser, "data types" do
-
-  describe "numbers" do
-
-    it "parses a positive number" do
+RSpec.describe Gobstones::Parser, 'data types' do
+  describe 'numbers' do
+    it 'parses a positive number' do
       expect('42').to be_parsed_as(:expression).and_return(42.to_gbs_num)
     end
 
-    it "parses a negative number" do
+    it 'parses a negative number' do
       expect('-42').to be_parsed_as(:expression).and_return(-42.to_gbs_num)
     end
-
   end
 
-  describe "booleans" do
-
-    it "parses a true boolean" do
+  describe 'booleans' do
+    it 'parses a true boolean' do
       expect('True').to be_parsed_as(:expression).and_return(true_value)
     end
 
-    it "parses a false boolean" do
+    it 'parses a false boolean' do
       expect('False').to be_parsed_as(:expression).and_return(false_value)
     end
-
   end
 
-  describe "colors" do
-
+  describe 'colors' do
     it "parses the 'Azul' color" do
       expect('Azul').to be_parsed_as(:expression).and_return(azul)
     end
@@ -41,11 +35,9 @@ describe Gobstones::Parser, "data types" do
     it "parses the 'Verde' color" do
       expect('Verde').to be_parsed_as(:expression).and_return(verde)
     end
-
   end
 
-  describe "directions" do
-
+  describe 'directions' do
     it "parses the 'Norte' direction" do
       expect('Norte').to be_parsed_as(:expression).and_return(norte)
     end
@@ -61,7 +53,5 @@ describe Gobstones::Parser, "data types" do
     it "parses the 'Oeste' direction" do
       expect('Oeste').to be_parsed_as(:expression).and_return(oeste)
     end
-
   end
-
 end

data/spec/parser/function_calls_spec.rb

@@ -1,38 +1,38 @@
-describe Gobstones::Parser, "function calls" do
+RSpec.describe Gobstones::Parser, 'function calls' do
+  it 'parses a function call without args' do
+    expected = FunctionCall.new('f1')
 
-  it "parses a function call without args" do
-    expected = FunctionCall.new 'f1'
     expect('f1()').to be_parsed_as(:expression).and_return(expected)
   end
 
-  it "does 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 "parses a function call with one arg" do
-    expected = FunctionCall.new 'func1', [verde]
+  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 "parses 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
+    second_arg = NroBolitas.new(verde)
     third_arg = norte
-    expected = FunctionCall.new 'func1', [first_arg, second_arg, third_arg]
+    expected = FunctionCall.new('func1', [first_arg, second_arg, third_arg])
 
-    expect('func1(42, nroBolitas(Verde), Norte)').
-      to be_parsed_as(:expression).and_return(expected)
+    expect('func1(42, nroBolitas(Verde), Norte)').to be_parsed_as(:expression).and_return(expected)
   end
 
-  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, Opuesto.new(norte)]
-    func1_call = FunctionCall.new 'func1', [or_expr, num_expr, func2_call]
+  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, 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

data/spec/parser/function_definitions_spec.rb

@@ -1,29 +1,27 @@
-describe Gobstones::Parser, "function definitions" do
-
-  it "parses a function without args and a single return" do
-    func_return = ReturnFromFunction.new [42.to_gbs_num]
-
-    func_def = Function.new 'just42', no_arguments, empty_body, func_return
+RSpec.describe Gobstones::Parser, 'function definitions' do
+  it 'parses a function without args and a single return' do
+    func_return = ReturnFromFunction.new([42.to_gbs_num])
+    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 "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
+  it 'parses a function with some args' do
+    args = VarTuple.with_names(%w[firstArg secondArg thirdArg])
+    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 "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
+  it 'parses a function with some statements' do
+    args = VarTuple.with_names(%w[arg])
+    body = CommandBlock.with_just(Poner.new(verde))
+    return_st = ReturnFromFunction.new([true_value])
+    func_def = Function.new('myFunc', args, body, return_st)
 
     expect('function myFunc(arg)
 {
@@ -32,14 +30,11 @@ describe Gobstones::Parser, "function definitions" do
 }').to be_parsed_as(:definition).and_return(func_def)
   end
 
-  it "does not parse a function without a valid identifier" do
-    expect('function MyWrongFunc() { return(True) }').
-      to be_parsed_as(:definition).and_fail
+  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 "does not parse a function without a return statement" do
-    expect('function myFuncWithoutReturn() { }').
-      to be_parsed_as(:definition).and_fail
+  it 'does not parse a function without a return statement' do
+    expect('function myFuncWithoutReturn() { }').to be_parsed_as(:definition).and_fail
   end
-
 end