gobstones 0.0.1.1 → 0.0.2

data/lib/gobstones/parser/parse_error.rb

@@ -14,4 +14,4 @@ module Gobstones
 
   end
 
-end
+end

data/lib/gobstones/runner/all.rb

@@ -2,5 +2,4 @@ require 'gobstones/runner/board'
 require 'gobstones/runner/cell'
 require 'gobstones/runner/execution_context'
 require 'gobstones/runner/head'
-
-require 'gobstones/runner/errors/all'
+require 'gobstones/runner/errors/all'

data/lib/gobstones/runner/board.rb

@@ -8,10 +8,14 @@ module Gobstones
 
       attr_reader :rows, :columns
 
-      def initialize(r, c)
+      def initialize(r, c, matrix=[])
         @rows, @columns = r, c
-        @matrix = []
-        r.times { @matrix << []; c.times { @matrix.last << Cell.new } }
+        if matrix.empty?
+          @matrix = []
+          r.times { @matrix << []; c.times { @matrix.last << Cell.new } }
+        else
+          @matrix = matrix
+        end
       end
 
       def cell_at(x, y)
@@ -50,8 +54,13 @@ module Gobstones
         true
       end
 
+      def clone
+        new_matrix = @matrix.map { |row| row.map { |cell| cell.clone } }
+        self.class.new @rows, @columns, new_matrix
+      end
+
     end
 
   end
 
-end
+end

data/lib/gobstones/runner/cell.rb

@@ -37,6 +37,16 @@ module Gobstones
         @values.values.all? { |value| value.zero? }
       end
 
+      def clone
+        self.class.new.tap do |copy|
+          [Azul.new, Negro.new, Rojo.new, Verde.new].each do |color|
+            number_of_balls(color).times do
+              copy.put color
+            end
+          end
+        end
+      end
+
       private
 
       def check(color)

data/lib/gobstones/runner/errors/all.rb

@@ -5,4 +5,4 @@ require 'gobstones/runner/errors/gobstones_runtime_error'
 require 'gobstones/runner/errors/gobstones_type_error'
 require 'gobstones/runner/errors/undefined_variable_error'
 require 'gobstones/runner/errors/out_of_board_error'
-require 'gobstones/runner/errors/wrong_arguments_error'
+require 'gobstones/runner/errors/wrong_arguments_error'

data/lib/gobstones/runner/errors/definition_not_found_error.rb

@@ -16,4 +16,4 @@ module Gobstones
 
   end
 
-end
+end

data/lib/gobstones/runner/execution_context.rb

@@ -10,20 +10,30 @@ module Gobstones
         @values = {}
       end
 
-      def set(var_name, value)
-        @values[var_name] = value
+      def set(variable_name, value)
+        @values[variable_name] = value
       end
 
-      def get(var_name)
-        @values[var_name] || (raise UndefinedVariableError)
+      def get(variable_name)
+        @values[variable_name] || undefined_variable_error
       end
 
-      def clear(var_name)
-        @values.delete(var_name)
+      def clear(variable_name)
+        @values.delete(variable_name)
       end
 
       def has_variable_named?(name)
-        @values.keys.any? { |var| var.name == name }
+        @values.keys.any? { |variable| variable.named? name }
+      end
+
+      def program_context
+        raise 'subclass responsibility'
+      end
+
+      protected
+
+      def undefined_variable_error
+        raise UndefinedVariableError
       end
 
     end
@@ -43,14 +53,10 @@ module Gobstones
       end
 
       def definition_named(name, found_block, not_found_block)
-        found_definition = @program.definitions.find { |definition|
-          definition.named? name
-        }
-        if found_definition
-          found_block.call found_definition
-        else
-          not_found_block.call
-        end
+        if_none = proc { return not_found_block.call }
+        found_definition = @program.definitions.detect(if_none) \
+          { |definition| definition.named? name }
+        found_block.call found_definition
       end
 
       def program_context
@@ -66,7 +72,7 @@ module Gobstones
     class ProcedureExecutionContext < ExecutionContext
 
       def self.based_on(outer_context)
-        self.new outer_context
+        new outer_context
       end
 
       def initialize(outer_context)
@@ -84,6 +90,50 @@ module Gobstones
 
     end
 
+    class FunctionExecutionContext < ExecutionContext
+
+      attr_reader :head
+
+      def self.based_on(outer_context)
+        new outer_context
+      end
+
+      def initialize(outer_context)
+        super()
+        @outer_context = outer_context
+        @head = outer_context.head.clone
+      end
+
+      def program_context
+        @outer_context.program_context
+      end
+
+    end
+
+    class NullExecutionContext < ExecutionContext
+
+      def set(variable_name, value)
+
+      end
+
+      def get(variable_name)
+        undefined_variable_error
+      end
+
+      def clear(variable_name)
+
+      end
+
+      def has_variable_named?(variable_name)
+        false
+      end
+
+      def program_context
+        raise 'a null execution does not know its program context'
+      end
+
+    end
+
   end
 
 end

data/lib/gobstones/runner/head.rb

@@ -15,9 +15,12 @@ module Gobstones
         new.at_random
       end
 
+      def self.with_position_and_board(x_pos, y_pos, board)
+        new.with_position_and_board x_pos, y_pos, board
+      end
+
       def initialize
-        go_to_origin
-        @board = Board.new MAX_ROWS, MAX_COLS
+        with_position_and_board 0, 0, Board.new(MAX_ROWS, MAX_COLS)
       end
 
       def at_random
@@ -25,6 +28,13 @@ module Gobstones
         self
       end
 
+      def with_position_and_board(x_pos, y_pos, board)
+        @x_pos = x_pos
+        @y_pos = y_pos
+        @board = board
+        self
+      end
+
       def can_move?(dir)
         check dir
         dir.can_move? self
@@ -87,6 +97,10 @@ module Gobstones
         @board.are_there_balls? x_pos, y_pos, color
       end
 
+      def clone
+        self.class.with_position_and_board x_pos, y_pos, board.clone
+      end
+
       private
 
       def check(dir)
@@ -98,4 +112,4 @@ module Gobstones
 
   end
 
-end
+end

data/spec/gobstones_lang_test_objects.rb

@@ -0,0 +1,75 @@
+module GobstonesLangTestObjects
+
+  # Programs, contexts and definitions
+
+  def clean_context
+    program_context_for empty_program
+  end
+
+  def program_context_for(program)
+    ProgramExecutionContext.for program
+  end
+
+  def empty_program
+    Program.new no_definitions, no_return_statement
+  end
+
+  def no_definitions
+    []
+  end
+
+  def no_arguments
+    VarTuple.empty
+  end
+
+  def no_return_statement
+    NoReturnStatement.new
+  end
+
+  def empty_body
+    CommandBlock.empty
+  end
+
+  # Literals
+
+  def true_value
+    True.new
+  end
+
+  def false_value
+    False.new
+  end
+
+  def verde
+    Verde.new
+  end
+
+  def azul
+    Azul.new
+  end
+
+  def negro
+    Negro.new
+  end
+
+  def rojo
+    Rojo.new
+  end
+
+  def norte
+    Norte.new
+  end
+
+  def sur
+    Sur.new
+  end
+
+  def este
+    Este.new
+  end
+
+  def oeste
+    Oeste.new
+  end
+
+end

data/spec/lang/commands/boom_cmd_spec.rb

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

data/spec/lang/commands/cmd_block_spec.rb

@@ -1,21 +1,21 @@
-describe CmdBlock do
+describe CommandBlock 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)]
+  let(:context) { clean_context }
+
+  it "evaluates all inner commands" do
+    cmd_block = CommandBlock.new [
+      Poner.new(rojo), Poner.new(verde),
+      Poner.new(negro), Poner.new(azul)]
     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
+    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 "builds an empty command block" do
-    expect(CmdBlock.new []).to be_empty
-    expect(CmdBlock.empty).to be_empty
+    expect(CommandBlock.new []).to be_empty
+    expect(CommandBlock.empty).to be_empty
   end
 
-end
+end

data/spec/lang/commands/if_cmd_spec.rb

@@ -1,49 +1,50 @@
 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)] }
+  let(:context) { clean_context }
+  let(:then_block) { CommandBlock.new [Poner.new(verde)] }
+  let(:else_block) { CommandBlock.new [Poner.new(rojo)] }
 
   describe "if-then" do
 
-    it "should evaluate the block if the condition is true" do
-      if_cmd = IfCmd.new True.new, then_block
+    it "evaluates the 'then' command block if the condition is true" do
+      if_cmd = IfCmd.new true_value, then_block
       if_cmd.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 not evaluate the block if the condition is false" do
-      if_cmd = IfCmd.new False.new, then_block
+    it "does not evaluate the 'then' command block if the condition is false" do
+      if_cmd = IfCmd.new false_value, then_block
       if_cmd.evaluate context
-      expect(context.head.are_there_balls?(Verde.new)).to be_false
+      expect(context.head.are_there_balls?(verde)).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|
+    it "raises a type error if the condition is not boolean" do
+      [42.to_gbs_num, norte, verde].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
+    it "evaluates the 'then' block and it does not evaluate the 'else' block" do
+      if_cmd = IfElseCmd.new true_value, 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
+      expect(context.head.are_there_balls?(verde)).to be true
+      expect(context.head.are_there_balls?(rojo)).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
+    it "does not evaluate the 'then' block and it evaluates the 'else' block" do
+      if_cmd = IfElseCmd.new false_value, 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
+      expect(context.head.are_there_balls?(verde)).to be false
+      expect(context.head.are_there_balls?(rojo)).to be true
     end
 
   end
 
-end
+end

data/spec/lang/commands/ir_al_origen_cmd_spec.rb

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