gobstones 0.0.1.1 → 0.0.2

data/spec/lang/commands/mover_cmd_spec.rb

@@ -1,18 +1,16 @@
 describe Mover do
 
-  let(:context) { ProgramExecutionContext.for double('GobstonesProgram') }
-  let(:north) { Norte.new }
-  let(:south) { Sur.new }
+  let(:context) { clean_context }
 
-  it "should run" do
-    Mover.new(north).evaluate(context)
+  it "moves the head to the specified direction when evaluating" do
+    Mover.new(norte).evaluate(context)
 
     expect(context.head.x_pos).to eq(0)
     expect(context.head.y_pos).to eq(1)
   end
 
-  it "should undo" do
-    cmd = Mover.new(north)
+  it "undoes the given movement" do
+    cmd = Mover.new norte
 
     cmd.evaluate context
     cmd.undo context
@@ -21,18 +19,18 @@ describe Mover do
     expect(context.head.y_pos).to eq(0)
   end
 
-  it "should return opposite cmd" do
-    expect(Mover.new(north).opposite).to eq(Mover.new(south))
+  it "returns the opposite command" do
+    expect(Mover.new(norte).opposite).to eq(Mover.new(sur))
   end
 
-  it "should fail if types don't match" do
-    expect { Mover.new(Verde.new).evaluate(context) }.
+  it "fails if the argument is not a direction" do
+    expect { Mover.new(verde).evaluate(context) }.
       to raise_error(GobstonesTypeError, /is not a direction/)
   end
 
-  it "should fail when out of board" do
-    expect { Mover.new(south).evaluate(context) }.
+  it "fails when the resulting position is out of board" do
+    expect { Mover.new(sur).evaluate(context) }.
       to raise_error(OutOfBoardError)
   end
 
-end
+end

data/spec/lang/commands/multiple_assignment_spec.rb

@@ -0,0 +1,37 @@
+describe MultipleAssignment do
+
+  let(:my_function_return) { ReturnFromFunction.new [42.to_gbs_num, verde, MinDir.new] }
+  let(:my_function_def) { Function.new 'myFunction', no_arguments, empty_body, my_function_return }
+  let(:program) { Program.new [my_function_def], no_return_statement }
+  let(:context) { program_context_for program }
+  let(:a) { 'a'.to_var_name }
+  let(:b) { 'b'.to_var_name }
+  let(:c) { 'c'.to_var_name }
+
+  context "success" do
+
+    it "evaluates and set all the variables with the return values of a function call" do
+      var_tuple = VarTuple.new [a, b, c]
+      function_call = FunctionCall.new 'myFunction', []
+      assign = MultipleAssignment.new var_tuple, function_call
+      assign.evaluate context
+      expect(context.has_variable_named?('a')).to be true
+      expect(context.get(a)).to eq(42.to_gbs_num)
+      expect(context.has_variable_named?('b')).to be true
+      expect(context.get(b)).to eq(verde)
+      expect(context.has_variable_named?('c')).to be true
+      expect(context.get(c)).to eq(norte)
+    end
+
+  end
+
+  context "failure" do
+
+    it "fails if there are more variables to be assigned on the left"
+
+    it "fails if there are more things to assign on the right"
+
+    it "fails if the expression on the right is not a function call"
+
+  end
+end

data/spec/lang/commands/poner_cmd_spec.rb

@@ -1,29 +1,28 @@
 describe Poner do
 
-  let(:context) { ProgramExecutionContext.for double('GobstonesProgram') }
-  let(:green) { Verde.new }
+  let(:context) { clean_context }
 
-  it "should execute" do
-    Poner.new(green).evaluate(context)
+  it "puts a ball of the given color in the current cell when evaluating" do
+    Poner.new(verde).evaluate(context)
 
-    expect(context.head.number_of_balls(green)).to eq(1)
+    expect(context.head.number_of_balls(verde)).to eq(1)
   end
 
-  it "should undo" do
-    context.head.put green
+  it "undoes the command" do
+    context.head.put verde
 
-    Poner.new(green).undo context
+    Poner.new(verde).undo context
 
-    expect(context.head.number_of_balls(green)).to eq(0)
+    expect(context.head.number_of_balls(verde)).to eq(0)
   end
 
-  it "should return the opposite cmd" do
-    expect(Poner.new(green).opposite).to eq(Sacar.new(green))
+  it "returns the opposite command" do
+    expect(Poner.new(verde).opposite).to eq(Sacar.new(verde))
   end
 
-  it "should fail if types don't match" do
-    expect { Poner.new(Norte.new).evaluate(context) }.
+  it "fails if the argument is not a color" do
+    expect { Poner.new(norte).evaluate(context) }.
       to raise_error(GobstonesTypeError, /is not a color/)
   end
 
-end
+end

data/spec/lang/commands/procedure_call_spec.rb

@@ -1,44 +1,39 @@
 describe "procedure calls" do
 
-  let(:empty_args) { VarTuple.new [] }
-  let(:empty_body) { CmdBlock.empty }
-
-  it "should execute an existing procedure when calling it" do
-    poner_cmd = Poner.new Verde.new
-    body = CmdBlock.new [poner_cmd]
-    my_procedure = Procedure.new 'MyProcedure', empty_args, body
-    program = Program.new [my_procedure], nil
-    context = ProgramExecutionContext.for program
+  it "evaluates an existing procedure when calling it" do
+    poner_cmd = Poner.new verde
+    body = CommandBlock.new [poner_cmd]
+    my_procedure = Procedure.new 'MyProcedure', no_arguments, body
+    program = Program.new [my_procedure], no_return_statement
+    context = program_context_for program
 
     proc_call = ProcedureCall.new 'MyProcedure', []
     proc_call.evaluate context
 
-    expect(context.head.are_there_balls?(Verde.new)).to be_true
+    expect(context.head.are_there_balls?(verde)).to be true
   end
 
-  it "should allow to call a procedure from another procedure" do
-    poner_cmd = Poner.new Azul.new
-    inner_procedure_body = CmdBlock.new [poner_cmd]
-    inner_procedure = Procedure.new 'Inner', empty_args, inner_procedure_body
+  it "allows to call a procedure from another procedure" do
+    poner_cmd = Poner.new azul
+    inner_procedure_body = CommandBlock.new [poner_cmd]
+    inner_procedure = Procedure.new 'Inner', no_arguments, inner_procedure_body
     call_to_inner_procedure = ProcedureCall.new 'Inner', []
-    outer_procedure_body = CmdBlock.new [call_to_inner_procedure]
-    outer_procedure = Procedure.new 'Outer', empty_args, outer_procedure_body
-    program = Program.new [outer_procedure, inner_procedure], nil
-    program_context = ProgramExecutionContext.for program
+    outer_procedure_body = CommandBlock.new [call_to_inner_procedure]
+    outer_procedure = Procedure.new 'Outer', no_arguments, outer_procedure_body
+    program = Program.new [outer_procedure, inner_procedure], no_return_statement
+    program_context = program_context_for program
 
     call_to_outer_procedure = ProcedureCall.new 'Outer', []
     call_to_outer_procedure.evaluate program_context
 
-    expect(program_context.head.are_there_balls?(Azul.new)).to be_true
+    expect(program_context.head.are_there_balls?(azul)).to be true
   end
 
-  it "should fail to execute an undefined procedure" do
-    program = Program.new [], nil
-    context = ProgramExecutionContext.for program
+  it "fails to execute an undefined procedure" do
     proc_call = ProcedureCall.new 'UndefinedProcedure', []
 
-    expect { proc_call.evaluate context }
+    expect { proc_call.evaluate clean_context }
       .to raise_error(DefinitionNotFound, DefinitionNotFound.message_for('UndefinedProcedure'))
   end
 
-end
+end

data/spec/lang/commands/procedure_spec.rb

@@ -1,67 +1,63 @@
 describe Procedure do
 
-  let(:program_context) { ProgramExecutionContext.for Program.new([], nil) }
-  let(:empty_args) { VarTuple.new [] }
-  let(:empty_body) { CmdBlock.empty }
-
-  it "should execute its body and leave state in the program context" do
-    poner_cmd = Poner.new Rojo.new
-    body = CmdBlock.new [poner_cmd]
-    procedure = Procedure.new 'MyProcedure', empty_args, body
-    procedure.evaluate program_context
-    expect(program_context.head.are_there_balls?(Rojo.new)).to be_true
+  let(:context) { clean_context }
+
+  it "executes its body and leaves state in the program context" do
+    poner_cmd = Poner.new rojo
+    body = CommandBlock.new [poner_cmd]
+    procedure = Procedure.new 'MyProcedure', no_arguments, body
+    procedure.evaluate context
+    expect(context.head.are_there_balls?(rojo)).to be true
   end
 
-  it "should execute in a new clean context, without having variables defined in another contexts" do
-    var_name = VarName.new 'var'
-    program_context.set var_name, Verde.new
+  it "fails getting a variable which is in the outer context" do
+    var_name = 'var'.to_var_name
+    context.set var_name, verde
 
     poner_cmd = Poner.new var_name
-    body = CmdBlock.new [poner_cmd]
-    procedure = Procedure.new 'MyProcedure', empty_args, body
-    expect { procedure.evaluate program_context }
-      .to raise_error(UndefinedVariableError)
+    body = CommandBlock.new [poner_cmd]
+    procedure = Procedure.new 'MyProcedure', no_arguments, body
+    expect { procedure.evaluate context }.to raise_error(UndefinedVariableError)
   end
 
-  it "should set arguments in the new context and they can be used" do
-    a_color = VarName.new 'a_color'
-    a_direction = VarName.new 'a_direction'
+  it "sets arguments in the new context so they can be used" do
+    a_color = 'a_color'.to_var_name
+    a_direction = 'a_direction'.to_var_name
     args = VarTuple.new [a_color, a_direction]
     mover_cmd = Mover.new a_direction
     poner_cmd = Poner.new a_color
-    body = CmdBlock.new [mover_cmd, poner_cmd]
+    body = CommandBlock.new [mover_cmd, poner_cmd]
     procedure = Procedure.new 'MyProc', args, body
 
-    procedure.evaluate program_context, [Negro.new, Norte.new]
+    procedure.evaluate context, [negro, norte]
 
-    expect(program_context.head.are_there_balls?(Negro.new)).to be_true
-    expect(program_context.head.y_pos).to eq(1)
+    expect(context.head.are_there_balls?(negro)).to be true
+    expect(context.head.y_pos).to eq(1)
   end
 
-  it "should not set arguments as var names in outer context" do
-    a_direction = VarName.new 'a_direction'
+  it "does not set arguments as var names in outer context" do
+    a_direction = 'a_direction'.to_var_name
     args = VarTuple.new [a_direction]
     procedure = Procedure.new 'MyProc', args, empty_body
 
-    procedure.evaluate program_context, [Oeste.new]
+    procedure.evaluate context, [oeste]
 
-    expect(program_context.has_variable_named?('a_direction')).to be_false
+    expect(context.has_variable_named?('a_direction')).to be false
   end
 
-  it "should fail if it is executed with more arguments than expected" do
-    procedure = Procedure.new 'MyProcedure', empty_args, empty_body
+  it "fails if it is executed with more arguments than expected" do
+    procedure = Procedure.new 'MyProcedure', no_arguments, empty_body
     error_message = "Wrong number of arguments in procedure 'MyProcedure': expected 0, got 1"
-    expect { procedure.evaluate program_context, [Norte.new] }
+    expect { procedure.evaluate context, [norte] }
       .to raise_error(WrongArgumentsError, error_message)
   end
 
-  it "should fail if it is executed with less arguments than expected" do
-    arg1, arg2 = VarName.new('arg1'), VarName.new('arg2')
-    args = VarTuple.new [arg1, arg2]
+  it "fails if it is executed with less arguments than expected" do
+    args = VarTuple.new ['arg1'.to_var_name, 'arg2'.to_var_name]
     procedure = Procedure.new 'MyProcedure2', args, empty_body
     error_message = "Wrong number of arguments in procedure 'MyProcedure2': expected 2, got 1"
-    expect { procedure.evaluate program_context, [Verde.new] }
+    expect { procedure.evaluate context, [verde] }
       .to raise_error(WrongArgumentsError, error_message)
   end
 
-end
+end

data/spec/lang/commands/repeat_with_cmd_spec.rb

@@ -1,41 +1,60 @@
 describe RepeatWithCmd do
 
-  let(:context) { ProgramExecutionContext.for double('GobstonesProgram') }
-  let(:var_name) { VarName.new 'var' }
+  let(:context) { clean_context }
+  let(:var_name) { 'var'.to_var_name }
+
+  it "iterates over numbers when evaluating" do
+    command_block = CommandBlock.new [Poner.new(rojo)]
+    repeat_with = RepeatWithCmd.new var_name, 1.to_gbs_num, 10.to_gbs_num, command_block
 
-  it "should iterate over numbers" do
-    repeat_with = RepeatWithCmd.new var_name, 1.to_gbs_num, 10.to_gbs_num, CmdBlock.new([Poner.new(Rojo.new)])
     repeat_with.evaluate context
-    expect(context.head.number_of_balls(Rojo.new)).to eq(10)
+
+    expect(context.head.number_of_balls(rojo)).to eq(10)
   end
 
-  it "should throw an error if the range values have not the same type" do
-    repeat_with = RepeatWithCmd.new var_name, 1.to_gbs_num, Este.new, CmdBlock.new([])
+  it "raises an error if the range values have not the same type" do
+    repeat_with = RepeatWithCmd.new var_name, 1.to_gbs_num, este, empty_body
+
     expect { repeat_with.evaluate context }
       .to raise_error(GobstonesTypeError, /types don't match in range values/)
   end
 
-  it "should throw an error if the index variable is previously defined" do
-    repeat_with = RepeatWithCmd.new var_name, 1.to_gbs_num, 5.to_gbs_num, CmdBlock.new([])
+  it "raises an error if the index variable is previously defined" do
+    repeat_with = RepeatWithCmd.new var_name, 1.to_gbs_num, 5.to_gbs_num, empty_body
+
     context.set var_name, 42.to_gbs_num
+
     expect { repeat_with.evaluate context }
       .to raise_error(GobstonesRuntimeError, /index variable can't be used because it's already defined/)
   end
 
-  it "should remove the index variable assignment after execution" do
-    repeat_with = RepeatWithCmd.new var_name, Azul.new, Verde.new, CmdBlock.new([])
+  it "removes the index variable assignment after execution" do
+    repeat_with = RepeatWithCmd.new var_name, azul, verde, empty_body
+
+    repeat_with.evaluate context
+
+    expect(context.has_variable_named?('var')).to be false
+  end
+
+  it "allows to use the index variable inside the command block" do
+    cmd_block = CommandBlock.new [Poner.new(var_name)]
+    repeat_with = RepeatWithCmd.new var_name, azul, verde, cmd_block
+
     repeat_with.evaluate context
-    expect(context.has_variable_named?('var')).to be_false
+
+    expect(context.head.are_there_balls?(azul)).to be true
+    expect(context.head.are_there_balls?(negro)).to be true
+    expect(context.head.are_there_balls?(rojo)).to be true
+    expect(context.head.are_there_balls?(verde)).to be true
   end
 
-  it "should allow to use the index variable inside the command block" do
-    cmd_block = CmdBlock.new [Poner.new(VarName.new('var'))]
-    repeat_with = RepeatWithCmd.new var_name, Azul.new, Verde.new, cmd_block
+  it "does no iterations if the from is higher than the to" do
+    cmd_block = CommandBlock.new [Poner.new(verde)]
+    repeat_with = RepeatWithCmd.new var_name, 8.to_gbs_num, 4.to_gbs_num, cmd_block
+
     repeat_with.evaluate context
-    expect(context.head.are_there_balls?(Azul.new)).to be_true
-    expect(context.head.are_there_balls?(Negro.new)).to be_true
-    expect(context.head.are_there_balls?(Rojo.new)).to be_true
-    expect(context.head.are_there_balls?(Verde.new)).to be_true
+
+    expect(context.head.are_there_balls?(verde)).to be false
   end
 
-end
+end

data/spec/lang/commands/sacar_cmd_spec.rb

@@ -1,34 +1,35 @@
 describe Sacar do
 
-  let(:context) { ProgramExecutionContext.for double('GobstonesProgram') }
-  let(:red) { Rojo.new }
+  let(:context) { clean_context }
 
-  it "should execute" do
-    3.times { context.head.put red }
+  it "take off balls from the board when evaluating" do
+    3.times { context.head.put rojo }
 
-    Sacar.new(red).evaluate context
+    Sacar.new(rojo).evaluate context
 
-    expect(context.head.number_of_balls(red)).to eq(2)
+    expect(context.head.number_of_balls(rojo)).to eq(2)
   end
 
-  it "should undo" do
-    Sacar.new(red).undo context
+  it "undoes a command" do
+    Sacar.new(rojo).undo context
 
-    expect(context.head.number_of_balls(red)).to eq(1)
+    expect(context.head.number_of_balls(rojo)).to eq(1)
   end
 
-  it "should return the opposite cmd" do
-    expect(Sacar.new(red).opposite).to eq(Poner.new(red))
+  it "returns the opposite command" do
+    opposite_command = Sacar.new(rojo).opposite
+
+    expect(opposite_command).to eq(Poner.new(rojo))
   end
 
-  it "should fail if there are no balls in the board" do
-    expect { Sacar.new(red).evaluate(context) }.
+  it "fails if there are no balls in the board" do
+    expect { Sacar.new(rojo).evaluate(context) }.
       to raise_error(EmptyCellError)
   end
 
-  it "should fail if types don't match" do
-    expect { Sacar.new(True.new).evaluate(context) }.
+  it "fails if the argument is not a color" do
+    expect { Sacar.new(true_value).evaluate(context) }.
       to raise_error(GobstonesTypeError, /is not a color/)
   end
 
-end
+end

data/spec/lang/commands/single_assignment_spec.rb

@@ -0,0 +1,13 @@
+describe SingleAssignment do
+
+  let(:context) { clean_context }
+  let(:a) { 'a'.to_var_name }
+
+  it "evaluates the associated expression to the var name" do
+    assign = SingleAssignment.new a, Add.new(3.to_gbs_num, 4.to_gbs_num)
+    assign.evaluate context
+    expect(context.has_variable_named?('a')).to be true
+    expect(context.get(a)).to eq(7.to_gbs_num)
+  end
+
+end

data/spec/lang/commands/skip_cmd_spec.rb

@@ -1,6 +1,6 @@
 describe Skip do
 
-  let(:context) { ProgramExecutionContext.for Program.new([], nil) }
+  let(:context) { clean_context }
 
   it "evaluates and does nothing" do
     Skip.new.evaluate context
@@ -9,4 +9,4 @@ describe Skip do
     expect(context.head.board).to be_empty
   end
 
-end
+end