gobstones 0.0.1.1

data/lib/gobstones/type_check_result.rb

@@ -0,0 +1,16 @@
+module Gobstones
+
+  class TypeCheckResult
+
+    def initialize(expected, actual)
+      @expected = expected
+      @actual = actual
+    end
+
+    def ok?
+      @expected == @actual
+    end
+
+  end
+
+end

data/spec/lang/commands/assignments_spec.rb

@@ -0,0 +1,13 @@
+describe SingleAssignment do
+
+  let(:context) { ExecutionContext.new }
+  let(:a) { VarName.new 'a' }
+
+  it "should associate the var name with the evaluated expression" 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/boom_cmd_spec.rb

@@ -0,0 +1,8 @@
+describe Boom do
+
+  it "should raise an exception when evaluating, with the right message" do
+    msg = 'This is a program error'
+    expect { Boom.new(msg).evaluate }.to raise_error(BoomError, msg)
+  end
+
+end

data/spec/lang/commands/cmd_block_spec.rb

@@ -0,0 +1,21 @@
+describe CmdBlock do
+
+  it "should evaluate all inner commands" do
+    program = Program.new [], nil
+    context = ProgramExecutionContext.for program
+    cmd_block = CmdBlock.new [
+      Poner.new(Rojo.new), Poner.new(Verde.new),
+      Poner.new(Negro.new), Poner.new(Azul.new)]
+    cmd_block.evaluate context
+    expect(context.head.are_there_balls?(Rojo.new)).to be_true
+    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?(Verde.new)).to be_true
+  end
+
+  it "builds an empty command block" do
+    expect(CmdBlock.new []).to be_empty
+    expect(CmdBlock.empty).to be_empty
+  end
+
+end

data/spec/lang/commands/if_cmd_spec.rb

@@ -0,0 +1,49 @@
+describe "if command" do
+
+  let(:context) { ProgramExecutionContext.for double('GobstonesProgram') }
+  let(:then_block) { CmdBlock.new [Poner.new(Verde.new)] }
+  let(:else_block) { CmdBlock.new [Poner.new(Rojo.new)] }
+
+  describe "if-then" do
+
+    it "should evaluate the block if the condition is true" do
+      if_cmd = IfCmd.new True.new, then_block
+      if_cmd.evaluate context
+      expect(context.head.are_there_balls?(Verde.new)).to be_true
+    end
+
+    it "should not evaluate the block if the condition is false" do
+      if_cmd = IfCmd.new False.new, then_block
+      if_cmd.evaluate context
+      expect(context.head.are_there_balls?(Verde.new)).to be_false
+    end
+
+    it "should raise a type error if the condition is not boolean" do
+      [Number.new(42), Norte.new, Verde.new].each do |value|
+        if_cmd = IfCmd.new value, then_block
+        expect { if_cmd.evaluate context }
+          .to raise_error(GobstonesTypeError, /is not a boolean/)
+      end
+    end
+
+  end
+
+  describe "if-then-else" do
+
+    it "should evaluate the 'then' block and not evaluate the 'else' block" do
+      if_cmd = IfElseCmd.new True.new, then_block, else_block
+      if_cmd.evaluate context
+      expect(context.head.are_there_balls?(Verde.new)).to be_true
+      expect(context.head.are_there_balls?(Rojo.new)).to be_false
+    end
+
+    it "should not evaluate the 'then' block and evaluate the 'else' block" do
+      if_cmd = IfElseCmd.new False.new, then_block, else_block
+      if_cmd.evaluate context
+      expect(context.head.are_there_balls?(Verde.new)).to be_false
+      expect(context.head.are_there_balls?(Rojo.new)).to be_true
+    end
+
+  end
+
+end

data/spec/lang/commands/ir_al_origen_cmd_spec.rb

@@ -0,0 +1,16 @@
+describe IrAlOrigen do
+
+  let(:context) { ProgramExecutionContext.for double('GobstonesProgram') }
+
+  it "should evaluate and put the head in 0, 0" do
+    context.head.move_north
+    context.head.move_east
+    ir_al_origen = IrAlOrigen.new
+
+    ir_al_origen.evaluate context
+
+    expect(context.head.x_pos).to eq(0)
+    expect(context.head.y_pos).to eq(0)
+  end
+
+end

data/spec/lang/commands/mover_cmd_spec.rb

@@ -0,0 +1,38 @@
+describe Mover do
+
+  let(:context) { ProgramExecutionContext.for double('GobstonesProgram') }
+  let(:north) { Norte.new }
+  let(:south) { Sur.new }
+
+  it "should run" do
+    Mover.new(north).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)
+
+    cmd.evaluate context
+    cmd.undo context
+
+    expect(context.head.x_pos).to eq(0)
+    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))
+  end
+
+  it "should fail if types don't match" do
+    expect { Mover.new(Verde.new).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) }.
+      to raise_error(OutOfBoardError)
+  end
+
+end

data/spec/lang/commands/poner_cmd_spec.rb

@@ -0,0 +1,29 @@
+describe Poner do
+
+  let(:context) { ProgramExecutionContext.for double('GobstonesProgram') }
+  let(:green) { Verde.new }
+
+  it "should execute" do
+    Poner.new(green).evaluate(context)
+
+    expect(context.head.number_of_balls(green)).to eq(1)
+  end
+
+  it "should undo" do
+    context.head.put green
+
+    Poner.new(green).undo context
+
+    expect(context.head.number_of_balls(green)).to eq(0)
+  end
+
+  it "should return the opposite cmd" do
+    expect(Poner.new(green).opposite).to eq(Sacar.new(green))
+  end
+
+  it "should fail if types don't match" do
+    expect { Poner.new(Norte.new).evaluate(context) }.
+      to raise_error(GobstonesTypeError, /is not a color/)
+  end
+
+end

data/spec/lang/commands/procedure_call_spec.rb

@@ -0,0 +1,44 @@
+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
+
+    proc_call = ProcedureCall.new 'MyProcedure', []
+    proc_call.evaluate context
+
+    expect(context.head.are_there_balls?(Verde.new)).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
+    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
+
+    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
+  end
+
+  it "should fail to execute an undefined procedure" do
+    program = Program.new [], nil
+    context = ProgramExecutionContext.for program
+    proc_call = ProcedureCall.new 'UndefinedProcedure', []
+
+    expect { proc_call.evaluate context }
+      .to raise_error(DefinitionNotFound, DefinitionNotFound.message_for('UndefinedProcedure'))
+  end
+
+end

data/spec/lang/commands/procedure_spec.rb

@@ -0,0 +1,67 @@
+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
+  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
+
+    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)
+  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'
+    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]
+    procedure = Procedure.new 'MyProc', args, body
+
+    procedure.evaluate program_context, [Negro.new, Norte.new]
+
+    expect(program_context.head.are_there_balls?(Negro.new)).to be_true
+    expect(program_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'
+    args = VarTuple.new [a_direction]
+    procedure = Procedure.new 'MyProc', args, empty_body
+
+    procedure.evaluate program_context, [Oeste.new]
+
+    expect(program_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
+    error_message = "Wrong number of arguments in procedure 'MyProcedure': expected 0, got 1"
+    expect { procedure.evaluate program_context, [Norte.new] }
+      .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]
+    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] }
+      .to raise_error(WrongArgumentsError, error_message)
+  end
+
+end

data/spec/lang/commands/repeat_with_cmd_spec.rb

@@ -0,0 +1,41 @@
+describe RepeatWithCmd do
+
+  let(:context) { ProgramExecutionContext.for double('GobstonesProgram') }
+  let(:var_name) { VarName.new 'var' }
+
+  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)
+  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([])
+    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([])
+    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([])
+    repeat_with.evaluate context
+    expect(context.has_variable_named?('var')).to be_false
+  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
+    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
+  end
+
+end

data/spec/lang/commands/sacar_cmd_spec.rb

@@ -0,0 +1,34 @@
+describe Sacar do
+
+  let(:context) { ProgramExecutionContext.for double('GobstonesProgram') }
+  let(:red) { Rojo.new }
+
+  it "should execute" do
+    3.times { context.head.put red }
+
+    Sacar.new(red).evaluate context
+
+    expect(context.head.number_of_balls(red)).to eq(2)
+  end
+
+  it "should undo" do
+    Sacar.new(red).undo context
+
+    expect(context.head.number_of_balls(red)).to eq(1)
+  end
+
+  it "should return the opposite cmd" do
+    expect(Sacar.new(red).opposite).to eq(Poner.new(red))
+  end
+
+  it "should fail if there are no balls in the board" do
+    expect { Sacar.new(red).evaluate(context) }.
+      to raise_error(EmptyCellError)
+  end
+
+  it "should fail if types don't match" do
+    expect { Sacar.new(True.new).evaluate(context) }.
+      to raise_error(GobstonesTypeError, /is not a color/)
+  end
+
+end

data/spec/lang/commands/skip_cmd_spec.rb

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

data/spec/lang/commands/vaciar_tablero_cmd_spec.rb

@@ -0,0 +1,13 @@
+describe VaciarTablero do
+
+  let(:context) { ProgramExecutionContext.for double('GobstonesProgram') }
+  let(:red) { Rojo.new }
+
+  it "should empty the board in the context" do
+    context.head.put red
+    vaciar_tablero = VaciarTablero.new
+    vaciar_tablero.evaluate context
+    expect(context.board.empty?).to be_true
+  end
+
+end

data/spec/lang/commands/while_cmd_spec.rb

@@ -0,0 +1,37 @@
+describe WhileCmd do
+
+  let(:context) { ProgramExecutionContext.for double('GobstonesProgram') }
+  let(:while_block) { CmdBlock.new [Poner.new(Verde.new)] }
+
+  def condition(times)
+    cond = double('while condition')
+    expected_values = [True.new] * times + [False.new]
+    allow(cond).to receive(:evaluate).and_return(*expected_values)
+    cond
+  end
+
+  it "should evaluate the command block until the condition is not satisfied" do
+    while_cmd = WhileCmd.new condition(3), while_block
+    while_cmd.evaluate context
+    expect(context.head.number_of_balls(Verde.new)).to eq(3)
+  end
+
+  it "should not evaluate the command block if the condition is not satisfied" do
+    while_cmd = WhileCmd.new condition(0), while_block
+    while_cmd.evaluate context
+    expect(context.head.are_there_balls?(Verde.new)).to be_false
+  end
+
+  it "should raise a type error if the condition is not boolean" do
+    while_cmd = WhileCmd.new Sur.new, while_block
+    expect { while_cmd.evaluate context }
+      .to raise_error(GobstonesTypeError, /is not a boolean/)
+  end
+
+  it "should fail by stack overflow if the condition is always true" do
+    while_cmd = WhileCmd.new True.new, while_block
+    expect { while_cmd.evaluate context }
+      .to raise_error(GobstonesRuntimeError, /stack overflow/)
+  end
+
+end