gobstones 0.0.2 → 0.0.3

data/spec/parser/gobstones_program_spec.rb

@@ -1,55 +1,55 @@
-describe Gobstones::Parser, "program definitions" do
-
-  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
+RSpec.describe Gobstones::Parser, 'program definitions' do
+  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 "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
+  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
+      procedure Procedure1(){ }
 
-    gbs_code = <<GBS
-procedure Procedure1(){ }
+      procedure Procedure2 () {}
 
-procedure Procedure2 () {}
+      procedure Main() {}
+    GBS
 
-procedure Main() {}
-GBS
     expect(gbs_code).to be_parsed_as(:program).and_return(program)
   end
 
-  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(){ }
+  it 'parses a program with Main, procedures and functions' do
+    main_def = Main.new(empty_body, no_return_statement)
+    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(){ }
 
-function function1() { return (42) }
+      function function1() { return (42) }
 
-procedure Procedure2 () {}
+      procedure Procedure2 () {}
+
+      procedure Main() {}
+    GBS
 
-procedure Main() {}
-GBS
     expect(gbs_code).to be_parsed_as(:program).and_return(program)
   end
 
-  it "does 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 "does 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

data/spec/parser/if_command_spec.rb

@@ -1,9 +1,7 @@
-describe Gobstones::Parser, "if statements" do
-
-  describe "if" do
-
-    it "parses a statement with a simple boolean and an empty block" do
-      if_cmd = IfCmd.new true_value, empty_body
+RSpec.describe Gobstones::Parser, 'if statements' do
+  describe 'if' do
+    it 'parses a statement with a simple boolean and an empty block' do
+      if_cmd = If.new(true_value, empty_body)
 
       expect('if (True) {}').to be_parsed_as(:command).and_return(if_cmd)
       expect('if (True) {
@@ -12,36 +10,29 @@ describe Gobstones::Parser, "if statements" do
         {}').to be_parsed_as(:command).and_return(if_cmd)
     end
 
-    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
+    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 = If.new(false_value, cmd_block)
 
-      expect('if(False){Poner(Verde); Skip}').
-        to be_parsed_as(:command).and_return(if_cmd)
+      expect('if(False){Poner(Verde); Skip}').to be_parsed_as(:command).and_return(if_cmd)
     end
 
-    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
+    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 = If.new(exp, empty_body)
 
-      expect('if (puedeMover(Norte) || (a && False)) {}').
-        to be_parsed_as(:command).and_return(if_cmd)
+      expect('if (puedeMover(Norte) || (a && False)) {}').to be_parsed_as(:command).and_return(if_cmd)
     end
-
   end
 
-  describe "if-else" do
+  describe 'if-else' do
+    it 'parses a statement with an else block' do
+      else_block = CommandBlock.with_just(Mover.new(norte))
+      if_else_cmd = IfThenElse.new(false_value, empty_body, 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)
+      expect('if (False) { } else { Mover(Norte) }').to be_parsed_as(:command).and_return(if_else_cmd)
     end
-
   end
-
 end

data/spec/parser/main_definition_spec.rb

@@ -1,24 +1,22 @@
-describe Gobstones::Parser, "main definition" do
+RSpec.describe Gobstones::Parser, 'main definition' do
+  let(:return_tuple) { VarTuple.with_names(%w[x y]) }
 
-  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
+  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 "parses a valid main procedure with a return of var names" do
-    main = Main.new empty_body, 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)
+    expect('procedure Main() { return (x, y); }').to be_parsed_as(:main).and_return(main)
   end
 
-  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)
+  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() {
        Mover(Oeste)
@@ -27,16 +25,15 @@ describe Gobstones::Parser, "main definition" do
     }').to be_parsed_as(:main).and_return(main)
   end
 
-  it "does 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 "does 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 "does 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

data/spec/parser/nested_expressions_spec.rb

@@ -1,35 +1,31 @@
-describe Gobstones::Parser, "nested expressions" do
-
-  it "parses literals between ()" do
-    expect('(  42 )').to be_parsed_as(:expression).
-      and_return(EnclosedByParensExpression.new(42.to_gbs_num))
-    expect('(True )').to be_parsed_as(:expression).
-      and_return(EnclosedByParensExpression.new(true_value))
-    expect('(Rojo )').to be_parsed_as(:expression).
-      and_return(EnclosedByParensExpression.new(rojo))
-    expect('(Verde)').to be_parsed_as(:expression).
-      and_return(EnclosedByParensExpression.new(verde))
+RSpec.describe Gobstones::Parser, 'nested expressions' do
+  it 'parses literals between ()' do
+    expect('(  42 )').to be_parsed_as(:expression).and_return(EnclosedByParensExpression.new(42.to_gbs_num))
+    expect('(True )').to be_parsed_as(:expression).and_return(EnclosedByParensExpression.new(true_value))
+    expect('(Rojo )').to be_parsed_as(:expression).and_return(EnclosedByParensExpression.new(rojo))
+    expect('(Verde)').to be_parsed_as(:expression).and_return(EnclosedByParensExpression.new(verde))
   end
 
-  it "parses primitive functions between ()" do
+  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)
+
+    expect('(puedeMover(Norte))').to be_parsed_as(:expression).and_return(puede_mover)
   end
 
-  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
+  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 "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
+  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

data/spec/parser/primitive_expressions_spec.rb

@@ -1,99 +1,94 @@
-describe Gobstones::Parser, "primitive expressions" do
-
-  describe "variable identifiers" do
-
-    it "parses valid var names" do
+RSpec.describe Gobstones::Parser, 'primitive expressions' do
+  describe 'variable identifiers' do
+    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 "does not parse invalid var names" do
+    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 "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
-      end
-    end
+    it 'does not parse reserved words as var names' do
+      literals = %w[True False Rojo Negro Azul Verde Norte Oeste Este Sur]
 
+      expect(RESERVED_IDS - literals).to all(be_parsed_as(:expression).and_fail)
+    end
   end
 
-  describe "type bounds functions" do
-
-    it "parses the minBool() function" do
+  describe 'type bounds functions' do
+    it 'parses the minBool() function' do
       expect('minBool()').to be_parsed_as(:expression).and_return(MinBool.new)
     end
 
-    it "parses the maxBool() function" do
+    it 'parses the maxBool() function' do
       expect('maxBool()').to be_parsed_as(:expression).and_return(MaxBool.new)
     end
 
-    it "parses the minColor() function" do
+    it 'parses the minColor() function' do
       expect('minColor()').to be_parsed_as(:expression).and_return(MinColor.new)
     end
 
-    it "parses the maxColor() function" do
+    it 'parses the maxColor() function' do
       expect('maxColor()').to be_parsed_as(:expression).and_return(MaxColor.new)
     end
 
-    it "parses the minDir() function" do
+    it 'parses the minDir() function' do
       expect('minDir()').to be_parsed_as(:expression).and_return(MinDir.new)
     end
 
-    it "parses the maxDir() function" do
+    it 'parses the maxDir() function' do
       expect('maxDir()').to be_parsed_as(:expression).and_return(MaxDir.new)
     end
-
   end
 
-  describe "other type functions" do
+  describe 'other type functions' do
+    it 'parses the siguiente() function ' do
+      func = Siguiente.new('x'.to_var_name)
 
-    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 "parses the previo() function" do
-      func = Previo.new 'y'.to_var_name
+    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 "parses the opuesto() function" do
-      func = Opuesto.new 'z'.to_var_name
+    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
-
   end
 
-  describe "board primitive functions" do
+  describe 'board primitive functions' do
+    it 'parses the nroBolitas(exp) function' do
+      func = NroBolitas.new('color'.to_var_name)
 
-    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 "parses the hayBolitas(exp) function" do
-      func = HayBolitas.new 'color'.to_var_name
+    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 "parses the puedeMover(exp) function" do
-      func = PuedeMover.new 'dir'.to_var_name
+    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

data/spec/parser/procedure_calls_spec.rb

@@ -1,36 +1,35 @@
-describe Gobstones::Parser, "procedure calls" do
-
-  it "parses a procedure call without args" do
+RSpec.describe Gobstones::Parser, 'procedure calls' do
+  it 'parses a procedure call without args' do
     expect('P1()').to be_parsed_as(:command).and_return(ProcedureCall.new('P1'))
   end
 
-  it "does not parse a procedure call without a valid identifier" do
+  it 'does not parse a procedure call without a valid identifier' do
     expect('p1()').to be_parsed_as(:command).and_fail
   end
 
-  it "parses a procedure call with one arg" do
-    expected = ProcedureCall.new 'Proc1', [verde]
+  it 'parses a procedure call with one arg' do
+    expected = ProcedureCall.new('Proc1', [verde])
+
     expect('Proc1(Verde)').to be_parsed_as(:command).and_return(expected)
   end
 
-  it "parses a procedure with many args" do
+  it 'parses a procedure with many args' do
     first_arg = 42.to_gbs_num
-    second_arg = NroBolitas.new verde
+    second_arg = NroBolitas.new(verde)
     third_arg = norte
-    expected = ProcedureCall.new 'Proc1', [first_arg, second_arg, third_arg]
+    expected = ProcedureCall.new('Proc1', [first_arg, second_arg, third_arg])
 
-    expect('Proc1(42, nroBolitas(Verde), Norte)').
-      to be_parsed_as(:command).and_return(expected)
+    expect('Proc1(42, nroBolitas(Verde), Norte)').to be_parsed_as(:command).and_return(expected)
   end
 
-  it "parses a complex procedure call" do
-    or_expr = Or.new 'a'.to_var_name, 'b'.to_var_name
-    paren_expr = EnclosedByParensExpression.new Div.new(10.to_gbs_num, 'c'.to_var_name)
-    num_expr = Mul.new 5.to_gbs_num, paren_expr
-    func_call = FunctionCall.new 'func', [verde, Opuesto.new(norte)]
-    proc_call = ProcedureCall.new 'Proc1', [or_expr, num_expr, func_call]
+  it 'parses a complex procedure call' do
+    or_expr = Or.new('a'.to_var_name, 'b'.to_var_name)
+    paren_expr = EnclosedByParensExpression.new(Div.new(10.to_gbs_num, 'c'.to_var_name))
+    num_expr = Mul.new(5.to_gbs_num, paren_expr)
+    func_call = FunctionCall.new('func', [verde, Opuesto.new(norte)])
+    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