gobstones 0.0.2 → 0.0.3

data/lib/gobstones/runner/head.rb

@@ -1,11 +1,9 @@
 require 'gobstones/runner/board'
+require 'gobstones/runner/errors/out_of_board_error'
 
 module Gobstones
-
   module Runner
-
     class Head
-
       MAX_ROWS = 9
       MAX_COLS = 9
 
@@ -16,15 +14,16 @@ module Gobstones
       end
 
       def self.with_position_and_board(x_pos, y_pos, board)
-        new.with_position_and_board x_pos, y_pos, board
+        new.with_position_and_board(x_pos, y_pos, board)
       end
 
       def initialize
-        with_position_and_board 0, 0, Board.new(MAX_ROWS, MAX_COLS)
+        with_position_and_board(0, 0, Board.new(MAX_ROWS, MAX_COLS))
       end
 
       def at_random
-        @x_pos, @y_pos = rand(MAX_ROWS), rand(MAX_COLS)
+        @x_pos = rand(MAX_ROWS)
+        @y_pos = rand(MAX_COLS)
         self
       end
 
@@ -37,27 +36,28 @@ module Gobstones
 
       def can_move?(dir)
         check dir
-        dir.can_move? self
+        dir.can_move?(self)
       end
 
       def can_move_north?
-        @y_pos < MAX_COLS-1
+        @y_pos < MAX_COLS - 1
       end
 
       def can_move_south?
-        @y_pos > 0
+        @y_pos.positive?
       end
 
       def can_move_east?
-        @x_pos < MAX_ROWS-1
+        @x_pos < MAX_ROWS - 1
       end
 
       def can_move_west?
-        @x_pos > 0
+        @x_pos.positive?
       end
 
       def move(dir)
         raise OutOfBoardError unless can_move?(dir)
+
         dir.move self
       end
 
@@ -78,7 +78,8 @@ module Gobstones
       end
 
       def go_to_origin
-        @x_pos, @y_pos = 0, 0
+        @x_pos = 0
+        @y_pos = 0
       end
 
       def put(color)
@@ -90,26 +91,22 @@ module Gobstones
       end
 
       def number_of_balls(color)
-        @board.number_of_balls x_pos, y_pos, color
+        @board.number_of_balls(x_pos, y_pos, color)
       end
 
       def are_there_balls?(color)
-        @board.are_there_balls? x_pos, y_pos, color
+        @board.are_there_balls?(x_pos, y_pos, color)
       end
 
       def clone
-        self.class.with_position_and_board x_pos, y_pos, board.clone
+        self.class.with_position_and_board(x_pos, y_pos, board.clone)
       end
 
       private
 
       def check(dir)
-        raise GobstonesTypeError, "#{dir} is not a direction" \
-          unless [Norte, Sur, Este, Oeste].include? dir.class
+        raise GobstonesTypeError, "#{dir} is not a direction" unless [Norte, Sur, Este, Oeste].include?(dir.class)
       end
-
     end
-
   end
-
 end

data/lib/gobstones/runner/program_result.rb

@@ -0,0 +1,12 @@
+module Gobstones
+  module Runner
+    class ProgramResult
+      attr_reader :head, :return_values
+
+      def initialize(head, return_values)
+        @head = head
+        @return_values = return_values
+      end
+    end
+  end
+end

data/lib/gobstones/type_check_result.rb

@@ -1,7 +1,5 @@
 module Gobstones
-
   class TypeCheckResult
-
     def initialize(expected, actual)
       @expected = expected
       @actual = actual
@@ -10,7 +8,5 @@ module Gobstones
     def ok?
       @expected == @actual
     end
-
   end
-
 end

data/spec/lang/commands/boom_spec.rb

@@ -0,0 +1,7 @@
+RSpec.describe Boom do
+  it 'raises an error when evaluating, with the message specified' do
+    message = 'This is a program error'
+
+    expect { described_class.new(message).evaluate(clean_context) }.to raise_error(BoomError, message)
+  end
+end

data/spec/lang/commands/command_block_spec.rb

@@ -0,0 +1,15 @@
+RSpec.describe CommandBlock do
+  let(:context) { clean_context }
+
+  it 'evaluates all inner commands' do
+    command_block = described_class.new([Poner.new(rojo), Poner.new(verde), Poner.new(negro), Poner.new(azul)])
+    command_block.evaluate context
+
+    expect_balls(azul, negro, rojo, verde)
+  end
+
+  it 'builds an empty command block' do
+    expect(described_class.new([])).to be_empty
+    expect(described_class.empty).to be_empty
+  end
+end

data/spec/lang/commands/if_spec.rb

@@ -0,0 +1,32 @@
+RSpec.describe If do
+  subject(:evaluate_if_command) { described_class.new(condition, then_block).evaluate(context) }
+
+  let(:context) { clean_context }
+  let(:then_block) { CommandBlock.with_just(Poner.new(verde)) }
+
+  context 'when condition is true' do
+    let(:condition) { true_value }
+
+    it "evaluates the 'then' block" do
+      evaluate_if_command and expect_balls(verde)
+    end
+  end
+
+  context 'when condition is false' do
+    let(:condition) { false_value }
+
+    it "does not evaluate the 'then' block" do
+      evaluate_if_command and expect_no_balls(verde)
+    end
+  end
+
+  [42.to_gbs_num, norte, verde].each do |value|
+    context "when condition has a wrong type (#{value.class})" do
+      let(:condition) { value }
+
+      it 'raises a type error' do
+        expect { evaluate_if_command }.to raise_error(GobstonesTypeError, /is not a boolean/)
+      end
+    end
+  end
+end

data/spec/lang/commands/if_then_else_spec.rb

@@ -0,0 +1,19 @@
+RSpec.describe IfThenElse do
+  let(:context) { clean_context }
+  let(:then_block) { CommandBlock.with_just(Poner.new(verde)) }
+  let(:else_block) { CommandBlock.with_just(Poner.new(rojo)) }
+
+  it "evaluates the 'then' block and it does not evaluate the 'else' block" do
+    described_class.new(true_value, then_block, else_block).evaluate context
+
+    expect_balls(verde)
+    expect_no_balls(rojo)
+  end
+
+  it "does not evaluate the 'then' block and it evaluates the 'else' block" do
+    described_class.new(false_value, then_block, else_block).evaluate context
+
+    expect_no_balls(verde)
+    expect_balls(rojo)
+  end
+end

data/spec/lang/commands/ir_al_origen_spec.rb

@@ -0,0 +1,11 @@
+RSpec.describe IrAlOrigen do
+  let(:context) { clean_context }
+
+  it 'puts the head in 0, 0 when evaluating' do
+    context.head.move_north
+    context.head.move_east
+    described_class.new.evaluate context
+
+    expect_positioned_at(0, 0)
+  end
+end

data/spec/lang/commands/mover_spec.rb

@@ -0,0 +1,30 @@
+RSpec.describe Mover do
+  let(:context) { clean_context }
+
+  it 'moves the head to the specified direction when evaluating' do
+    described_class.new(norte).evaluate(context)
+
+    expect_positioned_at(0, 1)
+  end
+
+  it 'undoes the given movement' do
+    cmd = described_class.new(norte)
+
+    cmd.evaluate context
+    cmd.undo context
+
+    expect_positioned_at(0, 0)
+  end
+
+  it 'returns the opposite command' do
+    expect(described_class.new(norte).opposite).to eq(described_class.new(sur))
+  end
+
+  it 'fails if the argument is not a direction' do
+    expect { described_class.new(verde).evaluate(context) }.to raise_error(GobstonesTypeError, /is not a direction/)
+  end
+
+  it 'fails when the resulting position is out of board' do
+    expect { described_class.new(sur).evaluate(context) }.to raise_error(OutOfBoardError)
+  end
+end

data/spec/lang/commands/multiple_assignment_spec.rb

@@ -1,37 +1,54 @@
-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 }
+RSpec.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(:call_to_my_function) { FunctionCall.new('myFunction', []) }
+  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 }
+  let(:d) { 'd'.to_var_name }
 
-  context "success" do
+  def expect_assignment(variable, value)
+    expect(context.has_variable_named?(variable.name)).to be(true)
+    expect(context.get(variable)).to eq(value)
+  end
 
-    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
+  context 'when assignment can be made' do
+    it 'evaluates and set all the variables with the return values of a function call' do
+      var_tuple = VarTuple.new([a, b, c])
+      assign = described_class.new(var_tuple, call_to_my_function)
       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
 
+      expect_assignment(a, 42.to_gbs_num)
+      expect_assignment(b, verde)
+      expect_assignment(c, norte)
+    end
   end
 
-  context "failure" do
+  context 'when assignment cannot be made' do
+    it 'fails if there are more variables to be assigned on the left' do
+      var_tuple = VarTuple.new([a, b, c, d])
+      assign = described_class.new(var_tuple, call_to_my_function)
 
-    it "fails if there are more variables to be assigned on the left"
+      error_message = 'Wrong number of arguments in assignment: expected 4, got 3'
+      expect { assign.evaluate context }.to raise_error(Gobstones::Runner::WrongArgumentsError, error_message)
+    end
+
+    it 'fails if there are more things to assign on the right' do
+      var_tuple = VarTuple.new([a, b])
+      assign = described_class.new(var_tuple, call_to_my_function)
 
-    it "fails if there are more things to assign on the right"
+      error_message = 'Wrong number of arguments in assignment: expected 2, got 3'
+      expect { assign.evaluate context }.to raise_error(Gobstones::Runner::WrongArgumentsError, error_message)
+    end
 
-    it "fails if the expression on the right is not a function call"
+    it 'fails if the expression on the right is not a function call' do
+      var_tuple = VarTuple.new([a, b])
+      assign = described_class.new(var_tuple, Add.new(12.to_gbs_num, 23.to_gbs_num))
 
+      error_message = 'expected a function call in multiple assignment'
+      expect { assign.evaluate context }.to raise_error(Gobstones::Runner::GobstonesTypeError, error_message)
+    end
   end
 end

data/spec/lang/commands/poner_spec.rb

@@ -0,0 +1,27 @@
+RSpec.describe Poner do
+  subject(:poner_cmd) { described_class.new(verde) }
+
+  let(:context) { clean_context }
+
+  it 'puts a ball of the given color in the current cell when evaluating' do
+    poner_cmd.evaluate(context)
+
+    expect(context.head.number_of_balls(verde)).to eq(1)
+  end
+
+  it 'undoes the command' do
+    context.head.put verde
+
+    poner_cmd.undo(context)
+
+    expect(context.head.number_of_balls(verde)).to eq(0)
+  end
+
+  it 'returns the opposite command' do
+    expect(poner_cmd.opposite).to eq(Sacar.new(verde))
+  end
+
+  it 'fails if the argument is not a color' do
+    expect { described_class.new(norte).evaluate(context) }.to raise_error(GobstonesTypeError, /is not a color/)
+  end
+end

data/spec/lang/commands/procedure_call_spec.rb

@@ -1,39 +1,37 @@
-describe "procedure calls" do
-
-  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', []
+RSpec.describe ProcedureCall do
+  it 'evaluates an existing procedure when calling it' do
+    poner_cmd = Poner.new(verde)
+    body = CommandBlock.with_just(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 = described_class.new('MyProcedure', [])
     proc_call.evaluate context
 
-    expect(context.head.are_there_balls?(verde)).to be true
+    expect(context.head.are_there_balls?(verde)).to be(true)
   end
 
-  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 = 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', []
+  it 'allows to call a procedure from another procedure' do
+    poner_cmd = Poner.new(azul)
+    inner_procedure_body = CommandBlock.with_just(poner_cmd)
+    inner_procedure = Procedure.new('Inner', no_arguments, inner_procedure_body)
+    call_to_inner_procedure = described_class.new('Inner', [])
+    outer_procedure_body = CommandBlock.with_just(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 = described_class.new('Outer', [])
     call_to_outer_procedure.evaluate program_context
 
-    expect(program_context.head.are_there_balls?(azul)).to be true
+    expect(program_context.head.are_there_balls?(azul)).to be(true)
   end
 
-  it "fails to execute an undefined procedure" do
-    proc_call = ProcedureCall.new 'UndefinedProcedure', []
+  it 'fails to execute an undefined procedure' do
+    proc_call = described_class.new('UndefinedProcedure', [])
 
-    expect { proc_call.evaluate clean_context }
-      .to raise_error(DefinitionNotFound, DefinitionNotFound.message_for('UndefinedProcedure'))
+    expect { proc_call.evaluate clean_context }.
+      to raise_error(DefinitionNotFound, DefinitionNotFound.message_for('UndefinedProcedure'))
   end
-
 end

data/spec/lang/commands/procedure_spec.rb

@@ -1,63 +1,63 @@
-describe Procedure do
-
+RSpec.describe Procedure do
   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
+  it 'executes its body and leaves state in the program context' do
+    poner_cmd = Poner.new(rojo)
+    body = CommandBlock.with_just(poner_cmd)
+    procedure = described_class.new('MyProcedure', no_arguments, body)
     procedure.evaluate context
-    expect(context.head.are_there_balls?(rojo)).to be true
+
+    expect_balls(rojo)
   end
 
-  it "fails getting a variable which is in the outer context" do
+  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 = CommandBlock.new [poner_cmd]
-    procedure = Procedure.new 'MyProcedure', no_arguments, body
+    poner_cmd = Poner.new(var_name)
+    body = CommandBlock.with_just(poner_cmd)
+    procedure = described_class.new('MyProcedure', no_arguments, body)
+
     expect { procedure.evaluate context }.to raise_error(UndefinedVariableError)
   end
 
-  it "sets arguments in the new context so they can be used" do
+  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 = CommandBlock.new [mover_cmd, poner_cmd]
-    procedure = Procedure.new 'MyProc', args, body
+    args = VarTuple.new([a_color, a_direction])
+    mover_cmd = Mover.new(a_direction)
+    poner_cmd = Poner.new(a_color)
+    body = CommandBlock.new([mover_cmd, poner_cmd])
+    procedure = described_class.new('MyProc', args, body)
 
     procedure.evaluate context, [negro, norte]
 
-    expect(context.head.are_there_balls?(negro)).to be true
+    expect_balls(negro)
     expect(context.head.y_pos).to eq(1)
   end
 
-  it "does not set arguments as var names in outer context" do
+  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
+    args = VarTuple.new([a_direction])
+    procedure = described_class.new('MyProc', args, empty_body)
 
     procedure.evaluate context, [oeste]
 
-    expect(context.has_variable_named?('a_direction')).to be false
+    expect(context.has_variable_named?('a_direction')).to be(false)
   end
 
-  it "fails if it is executed with more arguments than expected" do
-    procedure = Procedure.new 'MyProcedure', no_arguments, empty_body
+  it 'fails if it is executed with more arguments than expected' do
+    procedure = described_class.new('MyProcedure', no_arguments, empty_body)
+
     error_message = "Wrong number of arguments in procedure 'MyProcedure': expected 0, got 1"
-    expect { procedure.evaluate context, [norte] }
-      .to raise_error(WrongArgumentsError, error_message)
+    expect { procedure.evaluate context, [norte] }.to raise_error(WrongArgumentsError, error_message)
   end
 
-  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
+  it 'fails if it is executed with less arguments than expected' do
+    args = VarTuple.with_names(%w[arg1 arg2])
+    procedure = described_class.new('MyProcedure2', args, empty_body)
+
     error_message = "Wrong number of arguments in procedure 'MyProcedure2': expected 2, got 1"
-    expect { procedure.evaluate context, [verde] }
-      .to raise_error(WrongArgumentsError, error_message)
+    expect { procedure.evaluate context, [verde] }.to raise_error(WrongArgumentsError, error_message)
   end
-
 end